diff --git a/CHANGELOG.md b/CHANGELOG.md
index 39bed22f..67168d31 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@
### Added
+- AI 渠道支持自定义 HTTP 请求头、环境变量和会话 ID 占位符;保存后的鉴权头可安全用于连接测试,独立审计身份隔离主渠道请求头,自定义头不会跟随跨源重定向。
+
- 支持通过 `agent.task_timeout_minutes` 配置单代理、多代理、工作流及异步任务执行超时:未配置默认 600 分钟,`0` 表示不限时,负数拒绝加载;续跑保留重新计时行为,单次工具超时仍独立生效。
- 漏洞列表的单条下载按钮新增格式选择弹窗,支持 Markdown 与 Word(.docx),Word 下载复用漏洞读取权限并仅包含所选漏洞(#365)。
diff --git a/config.example.yaml b/config.example.yaml
index 92db51b2..a3f10aff 100644
--- a/config.example.yaml
+++ b/config.example.yaml
@@ -108,6 +108,18 @@ ai:
model: qwen3-max
max_total_tokens: 120000
max_completion_tokens: 32768
+ # headers: 可选。追加或覆盖发给模型网关的 HTTP 请求头,值支持 ${ENV_VAR} 与 ${ENV_VAR:-默认值}。
+ # 用于兼容要求私有鉴权头、版本头或组织头的第三方 OpenAI 兼容供应商(如 opencode 等聚合网关)。
+ # 配置后会覆盖同名的内置头(Authorization、User-Agent 等),空值项会被忽略。
+ # headers:
+ # X-Api-Key: ${OPENCODE_API_KEY}
+ # x-opencode-session: "%session_id%" # 自动替换为当前对话 ID
+ # X-Client-Name: cyberstrike-ai
+ # HTTP-Referer: https://example.com
+ # 配置自定义头时,仅允许同源重定向,跨主机、端口或协议的重定向会被拒绝。
+ # HITL 审计仅在未显式配置 provider/base_url/api_key 时继承主渠道 headers;
+ # 独立审计身份如需请求头,请在 hitl.audit_model.headers 中单独配置。
+ # 空 headers 与未配置等价;所有自定义头值在设置接口中均按敏感值脱敏。
# Eino 路径模型推理:DeepSeek/OpenAI 为 thinking / reasoning_effort;Claude 4.6+ 为 adaptive + output_config.effort(仅显式配置 effort 时下发);3.7 为 enabled+budget_tokens:10000(文档示例),effort 不映射,自定义预算用 extra_request_fields
reasoning:
mode: on # auto | on | off;off:OpenAI/Claude 不附加推理字段,DeepSeek 发送 thinking.type=disabled(其默认开启思考)
diff --git a/internal/config/config.go b/internal/config/config.go
index f4eaa2a9..e5af521a 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -847,6 +847,9 @@ type OpenAIConfig struct {
Model string `yaml:"model" json:"model"`
MaxTotalTokens int `yaml:"max_total_tokens,omitempty" json:"max_total_tokens,omitempty"`
MaxCompletionTokens int `yaml:"max_completion_tokens,omitempty" json:"max_completion_tokens,omitempty"`
+ // Headers 追加或覆盖发给模型网关的 HTTP 请求头,值支持 ${ENV_VAR} 展开。
+ // 用于兼容要求私有鉴权头、版本头或组织头的第三方 OpenAI 兼容供应商。
+ Headers map[string]string `yaml:"headers,omitempty" json:"headers,omitempty"`
// Reasoning 控制 Eino ChatModel 的 thinking / reasoning_effort / output_config 等(Eino 单/多代理路径生效)。
Reasoning OpenAIReasoningConfig `yaml:"reasoning,omitempty" json:"reasoning,omitempty"`
}
@@ -866,6 +869,7 @@ type AIChannelConfig struct {
Model string `yaml:"model" json:"model"`
MaxTotalTokens int `yaml:"max_total_tokens,omitempty" json:"max_total_tokens,omitempty"`
MaxCompletionTokens int `yaml:"max_completion_tokens,omitempty" json:"max_completion_tokens,omitempty"`
+ Headers map[string]string `yaml:"headers,omitempty" json:"headers,omitempty"`
Reasoning OpenAIReasoningConfig `yaml:"reasoning,omitempty" json:"reasoning,omitempty"`
}
@@ -881,6 +885,7 @@ func (c AIChannelConfig) ToOpenAIConfig() OpenAIConfig {
Model: c.Model,
MaxTotalTokens: c.MaxTotalTokens,
MaxCompletionTokens: c.MaxCompletionTokens,
+ Headers: ExpandHeaderMap(c.Headers),
Reasoning: c.Reasoning,
}
}
@@ -897,6 +902,7 @@ func AIChannelFromOpenAI(id, name string, oa OpenAIConfig) AIChannelConfig {
Model: oa.Model,
MaxTotalTokens: oa.MaxTotalTokens,
MaxCompletionTokens: oa.MaxCompletionTokens,
+ Headers: ExpandHeaderMap(oa.Headers),
Reasoning: oa.Reasoning,
}
}
@@ -1231,6 +1237,7 @@ func (h HitlConfig) TypeSafeConfigEffective() (baseURL, apiKey, model string) {
func (h HitlConfig) AuditModelEffective(main OpenAIConfig) OpenAIConfig {
out := main
am := h.AuditModel
+ out.Headers = auditModelHeaders(main, am)
if strings.TrimSpace(am.Provider) != "" || strings.TrimSpace(am.BaseURL) != "" || strings.TrimSpace(am.Model) != "" {
out.Reasoning.Profile = ""
}
diff --git a/internal/config/envexpand.go b/internal/config/envexpand.go
index 26faa0c1..4cd2154c 100644
--- a/internal/config/envexpand.go
+++ b/internal/config/envexpand.go
@@ -71,3 +71,16 @@ func ExpandConfigEnv(cfg *ExternalMCPServerConfig) {
cfg.Headers[k] = expandEnvVar(v)
}
}
+
+// ExpandHeaderMap 返回 headers 的副本,并展开其中的 ${VAR} / ${VAR:-default} 引用。
+// 与 MCP 配置的 Headers 展开规则保持一致。
+func ExpandHeaderMap(headers map[string]string) map[string]string {
+ if len(headers) == 0 {
+ return nil
+ }
+ out := make(map[string]string, len(headers))
+ for k, v := range headers {
+ out[expandEnvVar(k)] = expandEnvVar(v)
+ }
+ return out
+}
diff --git a/internal/config/model_headers.go b/internal/config/model_headers.go
new file mode 100644
index 00000000..7e7ee49d
--- /dev/null
+++ b/internal/config/model_headers.go
@@ -0,0 +1,16 @@
+package config
+
+import "strings"
+
+// auditModelHeaders treats an explicit audit identity as a separate credential
+// boundary, even when its provider or URL happens to equal the main model's.
+// A model-name-only override can safely continue using the main identity.
+func auditModelHeaders(main, audit OpenAIConfig) map[string]string {
+ if len(audit.Headers) > 0 {
+ return ExpandHeaderMap(audit.Headers)
+ }
+ if strings.TrimSpace(audit.Provider) != "" || strings.TrimSpace(audit.BaseURL) != "" || strings.TrimSpace(audit.APIKey) != "" {
+ return nil
+ }
+ return ExpandHeaderMap(main.Headers)
+}
diff --git a/internal/config/model_headers_test.go b/internal/config/model_headers_test.go
new file mode 100644
index 00000000..97cdb1c0
--- /dev/null
+++ b/internal/config/model_headers_test.go
@@ -0,0 +1,34 @@
+package config
+
+import "testing"
+
+func TestAuditModelHeaderIdentityBoundary(t *testing.T) {
+ t.Setenv("CSAI_AUDIT_TEST_HEADER", "audit-secret")
+ main := OpenAIConfig{Provider: "openai", BaseURL: "https://main.invalid/v1", APIKey: "main-key", Headers: map[string]string{"Authorization": "Bearer main"}}
+ for _, tc := range []struct {
+ name string
+ audit OpenAIConfig
+ want string
+ }{
+ {"inherit", OpenAIConfig{}, "Bearer main"},
+ {"model only", OpenAIConfig{Model: "small"}, "Bearer main"},
+ {"provider", OpenAIConfig{Provider: "openai"}, ""},
+ {"endpoint", OpenAIConfig{BaseURL: "https://audit.invalid/v1"}, ""},
+ {"key", OpenAIConfig{APIKey: "audit-key"}, ""},
+ {"explicit", OpenAIConfig{BaseURL: "https://audit.invalid", Headers: map[string]string{"Authorization": "${CSAI_AUDIT_TEST_HEADER}"}}, "audit-secret"},
+ {"empty follows inheritance", OpenAIConfig{Headers: map[string]string{}}, "Bearer main"},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ got := (HitlConfig{AuditModel: tc.audit}).AuditModelEffective(main)
+ if got.Headers["Authorization"] != tc.want {
+ t.Fatalf("headers=%v", got.Headers)
+ }
+ if got.Headers != nil {
+ got.Headers["Authorization"] = "changed"
+ }
+ if main.Headers["Authorization"] != "Bearer main" {
+ t.Fatal("mutated main headers")
+ }
+ })
+ }
+}
diff --git a/internal/handler/config.go b/internal/handler/config.go
index f963f47a..d018552e 100644
--- a/internal/handler/config.go
+++ b/internal/handler/config.go
@@ -1262,12 +1262,13 @@ func (h *ConfigHandler) UpdateConfig(c *gin.Context) {
// TestOpenAIRequest 测试OpenAI连接请求
type TestOpenAIRequest struct {
- CredentialScope string `json:"credential_scope,omitempty"`
- ChannelID string `json:"channel_id,omitempty"`
- Provider string `json:"provider"`
- BaseURL string `json:"base_url"`
- APIKey string `json:"api_key"`
- Model string `json:"model"`
+ CredentialScope string `json:"credential_scope,omitempty"`
+ ChannelID string `json:"channel_id,omitempty"`
+ Provider string `json:"provider"`
+ BaseURL string `json:"base_url"`
+ APIKey string `json:"api_key"`
+ Model string `json:"model"`
+ Headers map[string]string `json:"headers,omitempty"`
}
// TestOpenAI 测试OpenAI API连接是否可用
@@ -1284,6 +1285,11 @@ func (h *ConfigHandler) TestOpenAI(c *gin.Context) {
return
}
req.APIKey = resolvedKey
+ resolvedHeaders, headerErr := h.resolveProbeHeaders(req)
+ if headerErr != nil {
+ c.JSON(http.StatusBadRequest, gin.H{"error": headerErr.Error()})
+ return
+ }
if strings.TrimSpace(req.APIKey) == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "API Key 不能为空"})
return
@@ -1317,11 +1323,15 @@ func (h *ConfigHandler) TestOpenAI(c *gin.Context) {
BaseURL: baseURL,
APIKey: strings.TrimSpace(req.APIKey),
Model: req.Model,
+ Headers: resolvedHeaders,
}
client := openai.NewClient(tmpCfg, nil, h.logger)
ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
defer cancel()
+ // 连接测试没有真实对话上下文,用一个明确的探测值填充 %session_id%,
+ // 这样带会话占位符的渠道也能在测试时把自定义头真实发出去。
+ ctx = openai.WithSessionID(ctx, "connect-test")
start := time.Now()
if llm.IsClaudeProvider(req.Provider) {
@@ -2150,6 +2160,7 @@ func updateOpenAIConfig(doc *yaml.Node, cfg config.OpenAIConfig) {
setStringInMap(openaiNode, "api_key", cfg.APIKey)
setStringInMap(openaiNode, "base_url", cfg.BaseURL)
setStringInMap(openaiNode, "model", cfg.Model)
+ setStringMapInMap(openaiNode, "headers", cfg.Headers)
if cfg.MaxTotalTokens > 0 {
setIntInMap(openaiNode, "max_total_tokens", cfg.MaxTotalTokens)
}
@@ -2206,6 +2217,7 @@ func updateAIConfig(doc *yaml.Node, cfg config.AIConfig) {
setStringInMap(channelNode, "api_key", ch.APIKey)
setStringInMap(channelNode, "base_url", ch.BaseURL)
setStringInMap(channelNode, "model", ch.Model)
+ setStringMapInMap(channelNode, "headers", ch.Headers)
if ch.MaxTotalTokens > 0 {
setIntInMap(channelNode, "max_total_tokens", ch.MaxTotalTokens)
}
@@ -2359,6 +2371,7 @@ func updateHitlConfig(doc *yaml.Node, cfg config.HitlConfig) {
setStringInMap(auditModelNode, "base_url", cfg.AuditModel.BaseURL)
setStringInMap(auditModelNode, "api_key", cfg.AuditModel.APIKey)
setStringInMap(auditModelNode, "model", cfg.AuditModel.Model)
+ setStringMapInMap(auditModelNode, "headers", cfg.AuditModel.Headers)
setStringInMap(ensureMap(auditModelNode, "reasoning"), "profile", cfg.AuditModel.Reasoning.Profile)
// flow 样式 [a, b, c] 单行展示,工具多时比块序列省行数
setFlowStringSliceInMap(hitlNode, "tool_whitelist", cfg.ToolWhitelist)
@@ -2607,6 +2620,34 @@ func setStringInMap(mapNode *yaml.Node, key, value string) {
valueNode.Value = value
}
+// setStringMapInMap 把 map[string]string 写成 YAML 映射节点(键排序,空值删除)。
+func setStringMapInMap(mapNode *yaml.Node, key string, values map[string]string) {
+ if len(values) == 0 {
+ removeKeyFromMap(mapNode, key)
+ return
+ }
+ keys := make([]string, 0, len(values))
+ for k := range values {
+ if strings.TrimSpace(k) == "" {
+ continue
+ }
+ keys = append(keys, k)
+ }
+ if len(keys) == 0 {
+ removeKeyFromMap(mapNode, key)
+ return
+ }
+ sort.Strings(keys)
+ mapValue := &yaml.Node{Kind: yaml.MappingNode, Tag: "!!map"}
+ for _, k := range keys {
+ mapValue.Content = append(mapValue.Content,
+ &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!str", Value: k},
+ &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!str", Value: values[k]})
+ }
+ _, valueNode := ensureKeyValue(mapNode, key)
+ *valueNode = *mapValue
+}
+
func removeKeyFromMap(mapNode *yaml.Node, key string) {
if mapNode == nil || mapNode.Kind != yaml.MappingNode {
return
diff --git a/internal/handler/config_header_boundaries_test.go b/internal/handler/config_header_boundaries_test.go
new file mode 100644
index 00000000..6fb96ed6
--- /dev/null
+++ b/internal/handler/config_header_boundaries_test.go
@@ -0,0 +1,222 @@
+package handler
+
+import (
+ "context"
+ "cyberstrike-ai/internal/config"
+ "cyberstrike-ai/internal/openai"
+ "encoding/json"
+ "github.com/gin-gonic/gin"
+ "go.uber.org/zap"
+ "gopkg.in/yaml.v3"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+)
+
+func TestSavedHeaderProbeRestoresScopedSecret(t *testing.T) {
+ var got string
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ got = r.Header.Get("X-Api-Key")
+ w.Header().Set("Content-Type", "application/json")
+ w.Write([]byte(`{"choices":[{"message":{"content":"pong"}}]}`))
+ }))
+ defer srv.Close()
+ cfg := &config.Config{AI: config.AIConfig{Channels: map[string]config.AIChannelConfig{"gateway": {APIKey: "dummy", BaseURL: srv.URL, Model: "m", Headers: map[string]string{"X-Api-Key": "review-test-secret"}}}}}
+ masked, err := maskedConfigResponse(configSecretSnapshot(cfg))
+ if err != nil {
+ t.Fatal(err)
+ }
+ tree := masked.(map[string]interface{})
+ hdr := tree["ai"].(map[string]interface{})["channels"].(map[string]interface{})["gateway"].(map[string]interface{})["headers"]
+ payload, _ := json.Marshal(map[string]interface{}{"channel_id": "gateway", "base_url": srv.URL, "api_key": "********", "model": "m", "headers": hdr})
+ c, _ := gin.CreateTestContext(httptest.NewRecorder())
+ c.Request = httptest.NewRequest("POST", "/api/config/test-openai", strings.NewReader(string(payload)))
+ c.Request.Header.Set("Content-Type", "application/json")
+ h := &ConfigHandler{config: cfg, logger: zap.NewNop()}
+ h.TestOpenAI(c)
+ if got != "review-test-secret" {
+ t.Fatalf("expected stored header, got %q", got)
+ }
+ t.Log("Saved header restored from matching channel")
+}
+func TestAuditIndependentProviderDoesNotReceiveMainHeaders(t *testing.T) {
+ var got string
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ got = r.Header.Get("Authorization")
+ w.Write([]byte(`{}`))
+ }))
+ defer srv.Close()
+ main := config.OpenAIConfig{BaseURL: "https://main-provider.invalid", APIKey: "main-key", Model: "m", Headers: map[string]string{"Authorization": "Bearer main-header-secret"}}
+ audit := (config.HitlConfig{AuditModel: config.OpenAIConfig{BaseURL: srv.URL, APIKey: "audit-key", Model: "audit"}}).AuditModelEffective(main)
+ var out map[string]interface{}
+ err := openai.NewClient(&audit, nil, zap.NewNop()).ChatCompletion(context.Background(), map[string]string{"model": "audit"}, &out)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if got != "Bearer audit-key" {
+ t.Fatalf("unexpected auth %q", got)
+ }
+ t.Log("Independent audit identity retained")
+}
+func TestProbeHeaderScopeAndTargetFailures(t *testing.T) {
+ stored := config.AIChannelConfig{Provider: "openai", BaseURL: "https://model.invalid/v1", APIKey: "key", Headers: map[string]string{"X-Api-Key": "stored-secret"}}
+ h := &ConfigHandler{config: &config.Config{AI: config.AIConfig{Channels: map[string]config.AIChannelConfig{"a": stored}}, OpenAI: stored.ToOpenAIConfig()}, logger: zap.NewNop()}
+ base := TestOpenAIRequest{ChannelID: "a", Provider: "openai", BaseURL: stored.BaseURL, APIKey: "key", Headers: map[string]string{"x-api-key": maskedSecret, "X-Label": "label"}}
+ got, err := h.resolveProbeHeaders(base)
+ if err != nil || got["x-api-key"] != "stored-secret" || got["X-Label"] != "label" {
+ t.Fatalf("restore: %v %v", got, err)
+ }
+ for _, tc := range []struct {
+ name string
+ edit func(*TestOpenAIRequest)
+ }{
+ {"unknown channel", func(r *TestOpenAIRequest) { r.ChannelID = "other" }},
+ {"unscoped", func(r *TestOpenAIRequest) { r.ChannelID = "" }},
+ {"different destination", func(r *TestOpenAIRequest) { r.BaseURL = "https://other.invalid/v1" }},
+ {"different path", func(r *TestOpenAIRequest) { r.BaseURL = "https://model.invalid/another" }},
+ {"different provider", func(r *TestOpenAIRequest) { r.Provider = "claude" }},
+ {"different key", func(r *TestOpenAIRequest) { r.APIKey = "another" }},
+ {"unknown scope", func(r *TestOpenAIRequest) { r.CredentialScope = "other" }},
+ {"missing saved header", func(r *TestOpenAIRequest) { r.Headers = map[string]string{"Authorization": maskedSecret} }},
+ {"partial marker", func(r *TestOpenAIRequest) { r.Headers = map[string]string{"X-Api-Key": "Bearer " + maskedSecret} }},
+ {"duplicate case", func(r *TestOpenAIRequest) {
+ r.Headers = map[string]string{"X-Api-Key": maskedSecret, "x-api-key": "override"}
+ }},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ r := base
+ tc.edit(&r)
+ if _, err := h.resolveProbeHeaders(r); err == nil {
+ t.Fatal("unsafe marker accepted")
+ }
+ })
+ }
+ for _, scope := range []string{"openai", "hitlAudit"} {
+ r := base
+ r.ChannelID = ""
+ r.CredentialScope = scope
+ got, err = h.resolveProbeHeaders(r)
+ if err != nil || got["x-api-key"] != "stored-secret" {
+ t.Fatalf("scope %s: %v", scope, err)
+ }
+ }
+ r := base
+ r.Headers = map[string]string{"X-Api-Key": "fresh"}
+ r.BaseURL = "https://new.invalid"
+ got, err = h.resolveProbeHeaders(r)
+ if err != nil || got["X-Api-Key"] != "fresh" {
+ t.Fatal("fresh credential rejected")
+ }
+ h.config.Hitl.AuditModel = config.OpenAIConfig{BaseURL: "https://audit.invalid", APIKey: "audit-key"}
+ r = base
+ r.CredentialScope = "hitlAudit"
+ r.BaseURL = "https://audit.invalid"
+ r.APIKey = "audit-key"
+ if _, err = h.resolveProbeHeaders(r); err == nil {
+ t.Fatal("main credential restored for independent audit")
+ }
+}
+func TestProbeHeaderFailureMakesNoRequest(t *testing.T) {
+ calls := 0
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { calls++ }))
+ defer srv.Close()
+ h := &ConfigHandler{config: &config.Config{AI: config.AIConfig{Channels: map[string]config.AIChannelConfig{"a": {APIKey: "key", BaseURL: "https://saved.invalid", Headers: map[string]string{"Authorization": "Bearer secret"}}}}}, logger: zap.NewNop()}
+ payload, _ := json.Marshal(TestOpenAIRequest{ChannelID: "a", APIKey: "key", BaseURL: srv.URL, Model: "m", Headers: map[string]string{"Authorization": maskedSecret}})
+ w := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(w)
+ c.Request = httptest.NewRequest("POST", "/test", strings.NewReader(string(payload)))
+ c.Request.Header.Set("Content-Type", "application/json")
+ h.TestOpenAI(c)
+ if w.Code != 400 || calls != 0 {
+ t.Fatalf("status=%d outbound=%d", w.Code, calls)
+ }
+}
+
+func TestAuditHeadersPersistAndRestoreMaskedConfig(t *testing.T) {
+ cfg := &config.Config{Hitl: config.HitlConfig{AuditModel: config.OpenAIConfig{Headers: map[string]string{"X-Api-Key": "audit-test-secret"}}}}
+ response, err := maskedConfigResponse(configSecretSnapshot(cfg))
+ if err != nil {
+ t.Fatal(err)
+ }
+ raw, err := json.Marshal(response)
+ if err != nil {
+ t.Fatal(err)
+ }
+ var req UpdateConfigRequest
+ if err = json.Unmarshal(raw, &req); err != nil {
+ t.Fatal(err)
+ }
+ if err = restoreConfigRequestSecrets(&req, cfg); err != nil {
+ t.Fatal(err)
+ }
+ var doc yaml.Node
+ if err = yaml.Unmarshal([]byte("hitl: {}\n"), &doc); err != nil {
+ t.Fatal(err)
+ }
+ updateHitlConfig(&doc, *req.Hitl)
+ raw, err = yaml.Marshal(&doc)
+ if err != nil {
+ t.Fatal(err)
+ }
+ var saved config.Config
+ if err = yaml.Unmarshal(raw, &saved); err != nil {
+ t.Fatal(err)
+ }
+ if saved.Hitl.AuditModel.Headers["X-Api-Key"] != "audit-test-secret" {
+ t.Fatal("audit header lost on save")
+ }
+}
+
+func TestPrivateHeaderNamesAreMaskedAndRestored(t *testing.T) {
+ cfg := &config.Config{AI: config.AIConfig{Channels: map[string]config.AIChannelConfig{"a": {Headers: map[string]string{"X-Gateway-Token": "private-token", "X-Client-Name": "client-name"}}, "b": {Headers: map[string]string{"X-Gateway-Token": "other-token"}}}}}
+ response, err := maskedConfigResponse(configSecretSnapshot(cfg))
+ if err != nil {
+ t.Fatal(err)
+ }
+ raw, _ := json.Marshal(response)
+ if strings.Contains(string(raw), "private-token") || strings.Contains(string(raw), "other-token") || strings.Contains(string(raw), "client-name") {
+ t.Fatal("custom header disclosed")
+ }
+ var req UpdateConfigRequest
+ if err = json.Unmarshal(raw, &req); err != nil {
+ t.Fatal(err)
+ }
+ // HTTP field casing is not an identity change, but channels must remain isolated.
+ ch := req.AI.Channels["a"]
+ delete(ch.Headers, "X-Gateway-Token")
+ ch.Headers["x-gateway-token"] = maskedSecret
+ req.AI.Channels["a"] = ch
+ if err = restoreConfigRequestSecrets(&req, cfg); err != nil {
+ t.Fatal(err)
+ }
+ if req.AI.Channels["a"].Headers["x-gateway-token"] != "private-token" || req.AI.Channels["b"].Headers["X-Gateway-Token"] != "other-token" {
+ t.Fatal("wrong channel credential")
+ }
+ if cfg.AI.Channels["a"].Headers["X-Gateway-Token"] != "private-token" {
+ t.Fatal("live config mutated")
+ }
+ for _, headers := range []map[string]interface{}{{"Missing": maskedSecret}, {"X-Gateway-Token": maskedSecret, "x-gateway-token": maskedSecret}} {
+ if transformHeaderSecrets(headers, map[string]interface{}{"X-Gateway-Token": "private-token"}, true) == nil {
+ t.Fatal("ambiguous or missing header accepted")
+ }
+ }
+}
+func TestEmptyAuditHeadersRoundTripPreservesPolicy(t *testing.T) {
+ main := config.OpenAIConfig{Headers: map[string]string{"Authorization": "Bearer main"}}
+ for _, identity := range []string{"", "https://audit.invalid"} {
+ hitl := config.HitlConfig{AuditModel: config.OpenAIConfig{BaseURL: identity, Headers: map[string]string{}}}
+ before := hitl.AuditModelEffective(main).Headers["Authorization"]
+ var doc yaml.Node
+ yaml.Unmarshal([]byte("hitl: {}\n"), &doc)
+ updateHitlConfig(&doc, hitl)
+ raw, _ := yaml.Marshal(&doc)
+ var saved config.Config
+ if err := yaml.Unmarshal(raw, &saved); err != nil {
+ t.Fatal(err)
+ }
+ if after := saved.Hitl.AuditModelEffective(main).Headers["Authorization"]; after != before {
+ t.Fatalf("round trip changed header policy: %q -> %q", before, after)
+ }
+ }
+}
diff --git a/internal/handler/config_header_secrets.go b/internal/handler/config_header_secrets.go
new file mode 100644
index 00000000..0fb7e108
--- /dev/null
+++ b/internal/handler/config_header_secrets.go
@@ -0,0 +1,47 @@
+package handler
+
+import (
+ "fmt"
+ "strings"
+)
+
+// Any private header name may carry a credential. A fixed list such as
+// Authorization/X-Api-Key cannot safely classify a user-defined header map.
+func transformHeaderSecrets(headers, stored map[string]interface{}, restoring bool) error {
+ seen := map[string]bool{}
+ for name, value := range headers {
+ key := strings.ToLower(strings.TrimSpace(name))
+ if restoring && seen[key] {
+ return fmt.Errorf("重复的请求头名称")
+ }
+ seen[key] = true
+ text, ok := value.(string)
+ if !ok {
+ continue
+ }
+ if !restoring {
+ if text != "" {
+ headers[name] = maskedSecret
+ }
+ continue
+ }
+ if text != maskedSecret {
+ continue
+ }
+ found := ""
+ count := 0
+ for oldName, oldValue := range stored {
+ if strings.EqualFold(strings.TrimSpace(oldName), strings.TrimSpace(name)) {
+ if oldText, ok := oldValue.(string); ok {
+ found = oldText
+ count++
+ }
+ }
+ }
+ if count != 1 || found == "" || found == maskedSecret {
+ return fmt.Errorf("没有唯一的已保存请求头凭据,请填写新的值")
+ }
+ headers[name] = found
+ }
+ return nil
+}
diff --git a/internal/handler/config_probe_headers.go b/internal/handler/config_probe_headers.go
new file mode 100644
index 00000000..1b7f8e28
--- /dev/null
+++ b/internal/handler/config_probe_headers.go
@@ -0,0 +1,94 @@
+package handler
+
+import (
+ "cyberstrike-ai/internal/config"
+ "fmt"
+ "strings"
+)
+
+// resolveProbeHeaders restores only explicitly scoped, same-target secrets.
+// Missing/ambiguous markers fail before any outbound HTTP request is made.
+func (h *ConfigHandler) resolveProbeHeaders(req TestOpenAIRequest) (map[string]string, error) {
+ needsStored := false
+ seen := map[string]bool{}
+ for name, value := range req.Headers {
+ key := strings.ToLower(strings.TrimSpace(name))
+ if seen[key] {
+ return nil, fmt.Errorf("重复的请求头名称")
+ }
+ seen[key] = true
+ if strings.Contains(value, maskedSecret) {
+ needsStored = true
+ }
+ }
+ if !needsStored {
+ return config.ExpandHeaderMap(req.Headers), nil
+ }
+ h.mu.RLock()
+ defer h.mu.RUnlock()
+ if h.config == nil {
+ return nil, fmt.Errorf("没有已保存的请求头凭据")
+ }
+ var stored config.OpenAIConfig
+ switch {
+ case req.ChannelID != "":
+ ch, ok := h.config.AI.Channels[req.ChannelID]
+ if !ok {
+ return nil, fmt.Errorf("未知通道,无法恢复请求头凭据")
+ }
+ stored = ch.ToOpenAIConfig()
+ if req.CredentialScope == "hitlAudit" {
+ stored = h.config.Hitl.AuditModelEffective(stored)
+ } else if req.CredentialScope != "" && req.CredentialScope != "openai" {
+ return nil, fmt.Errorf("请求头凭据范围不匹配")
+ }
+ case req.CredentialScope == "hitlAudit":
+ stored = h.config.Hitl.AuditModelEffective(h.config.OpenAI)
+ case req.CredentialScope == "openai":
+ stored = h.config.OpenAI
+ default:
+ return nil, fmt.Errorf("请指定通道或模型凭据范围以恢复请求头")
+ }
+ if probeHeaderProvider(req.Provider) != probeHeaderProvider(stored.Provider) || probeHeaderURL(req.Provider, req.BaseURL) != probeHeaderURL(stored.Provider, stored.BaseURL) || strings.TrimSpace(req.APIKey) != strings.TrimSpace(stored.APIKey) {
+ return nil, fmt.Errorf("模型身份或地址已改变,请重新填写请求头凭据")
+ }
+ out := make(map[string]string, len(req.Headers))
+ for name, value := range req.Headers {
+ if strings.Contains(value, maskedSecret) {
+ if value != maskedSecret {
+ return nil, fmt.Errorf("无效的请求头凭据占位符")
+ }
+ found := ""
+ count := 0
+ for savedName, savedValue := range stored.Headers {
+ if strings.EqualFold(strings.TrimSpace(savedName), strings.TrimSpace(name)) {
+ found = savedValue
+ count++
+ }
+ }
+ if count != 1 || strings.TrimSpace(found) == "" || strings.Contains(found, maskedSecret) {
+ return nil, fmt.Errorf("没有唯一的已保存请求头凭据")
+ }
+ value = found
+ }
+ out[name] = value
+ }
+ return config.ExpandHeaderMap(out), nil
+}
+func probeHeaderProvider(provider string) string {
+ provider = strings.ToLower(strings.TrimSpace(provider))
+ if provider == "" {
+ return "openai"
+ }
+ return provider
+}
+func probeHeaderURL(provider, raw string) string {
+ raw = strings.TrimRight(strings.TrimSpace(raw), "/")
+ if raw == "" {
+ if probeHeaderProvider(provider) == "claude" {
+ return "https://api.anthropic.com"
+ }
+ return "https://api.openai.com/v1"
+ }
+ return raw
+}
diff --git a/internal/handler/config_secrets.go b/internal/handler/config_secrets.go
index d095d9fb..47c1087f 100644
--- a/internal/handler/config_secrets.go
+++ b/internal/handler/config_secrets.go
@@ -44,6 +44,15 @@ func transformSecretTree(tree, current interface{}, restoring bool) error {
case map[string]interface{}:
previous, _ := current.(map[string]interface{})
for key, value := range node {
+ if key == "headers" {
+ if headers, ok := value.(map[string]interface{}); ok {
+ stored, _ := previous[key].(map[string]interface{})
+ if err := transformHeaderSecrets(headers, stored, restoring); err != nil {
+ return err
+ }
+ continue
+ }
+ }
text, isString := value.(string)
if secretConfigKey(key) && isString {
if !restoring && text != "" {
diff --git a/internal/handler/config_testopenai_headers_test.go b/internal/handler/config_testopenai_headers_test.go
new file mode 100644
index 00000000..fc4423dd
--- /dev/null
+++ b/internal/handler/config_testopenai_headers_test.go
@@ -0,0 +1,89 @@
+package handler
+
+import (
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "github.com/gin-gonic/gin"
+ "go.uber.org/zap"
+
+ "cyberstrike-ai/internal/config"
+)
+
+// TestTestOpenAIForwardsCustomHeaders 校验「测试连接」与真实对话一样会带上渠道自定义请求头:
+// 静态头原样发送,%session_id% 用探测值填充,Authorization 仍按 api_key 生成。
+func TestTestOpenAIForwardsCustomHeaders(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+
+ var gotSession, gotFlag, gotAuth string
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ gotSession = r.Header.Get("X-Opencode-Session")
+ gotFlag = r.Header.Get("X-Custom-Flag")
+ gotAuth = r.Header.Get("Authorization")
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write([]byte(`{"id":"chatcmpl-test","model":"test-model","choices":[{"message":{"role":"assistant","content":"pong"}}]}`))
+ }))
+ defer srv.Close()
+
+ h := &ConfigHandler{config: &config.Config{}, logger: zap.NewNop()}
+
+ body := `{"provider":"openai","base_url":"` + srv.URL + `/v1","api_key":"test-key","model":"test-model",` +
+ `"headers":{"X-Opencode-Session":"%session_id%","X-Custom-Flag":"hello"}}`
+
+ w := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(w)
+ c.Request = httptest.NewRequest(http.MethodPost, "/api/config/test-openai", strings.NewReader(body))
+ c.Request.Header.Set("Content-Type", "application/json")
+
+ h.TestOpenAI(c)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("status = %d body=%s", w.Code, w.Body.String())
+ }
+ var resp map[string]interface{}
+ if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
+ t.Fatalf("decode response: %v", err)
+ }
+ if resp["success"] != true {
+ t.Fatalf("probe failed: %s", w.Body.String())
+ }
+ if gotSession != "connect-test" {
+ t.Fatalf("X-Opencode-Session = %q, want connect-test", gotSession)
+ }
+ if gotFlag != "hello" {
+ t.Fatalf("X-Custom-Flag = %q, want hello", gotFlag)
+ }
+ if gotAuth != "Bearer test-key" {
+ t.Fatalf("Authorization = %q", gotAuth)
+ }
+}
+
+// TestTestOpenAIWithoutHeadersKeepsBuiltinAuth 确认未配置 headers 时行为不变。
+func TestTestOpenAIWithoutHeadersKeepsBuiltinAuth(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+
+ var gotAuth string
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ gotAuth = r.Header.Get("Authorization")
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write([]byte(`{"id":"x","model":"m","choices":[{"message":{"role":"assistant","content":"pong"}}]}`))
+ }))
+ defer srv.Close()
+
+ h := &ConfigHandler{config: &config.Config{}, logger: zap.NewNop()}
+ body := `{"provider":"openai","base_url":"` + srv.URL + `/v1","api_key":"plain-key","model":"m"}`
+
+ w := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(w)
+ c.Request = httptest.NewRequest(http.MethodPost, "/api/config/test-openai", strings.NewReader(body))
+ c.Request.Header.Set("Content-Type", "application/json")
+
+ h.TestOpenAI(c)
+
+ if gotAuth != "Bearer plain-key" {
+ t.Fatalf("Authorization = %q, want Bearer plain-key", gotAuth)
+ }
+}
diff --git a/internal/handler/task_manager.go b/internal/handler/task_manager.go
index e1b4301b..d9398730 100644
--- a/internal/handler/task_manager.go
+++ b/internal/handler/task_manager.go
@@ -11,6 +11,7 @@ import (
"time"
"cyberstrike-ai/internal/multiagent"
+ "cyberstrike-ai/internal/openai"
"cyberstrike-ai/internal/runlease"
"cyberstrike-ai/internal/security"
)
@@ -584,6 +585,9 @@ func (m *AgentTaskManager) UpdateTaskStatus(conversationID string, status string
// BindProcessScope snapshots ownership once at task start. Continuations must
// derive from this context, never resolve ownership again using conversation ID.
func (m *AgentTaskManager) BindProcessScope(ctx context.Context, conversationID, runID string) context.Context {
+ // 把对话 ID 放进 ctx:自定义请求头的 %session_id% 占位符据此替换,
+ // 保证每次对话发出的 x-opencode-session 等头对应当前 session。
+ ctx = openai.WithSessionID(ctx, conversationID)
m.mu.RLock()
defer m.mu.RUnlock()
if task := m.tasks[conversationID]; task != nil && task.RunID == runID {
diff --git a/internal/openai/eino_http.go b/internal/openai/eino_http.go
index 625da8ac..df9c5592 100644
--- a/internal/openai/eino_http.go
+++ b/internal/openai/eino_http.go
@@ -22,6 +22,7 @@ func NewEinoHTTPClient(cfg *config.OpenAIConfig, base *http.Client) *http.Client
transport = &einoSSEErrorRoundTripper{base: transport}
transport = &einoSSESanitizingRoundTripper{base: transport}
transport = &einoUsageNormalizingRoundTripper{base: transport}
+ transport = &headersRoundTripper{base: transport, cfg: cfg}
cloned.Transport = transport
- return &cloned
+ return customHeaderHTTPClient(&cloned, cfg)
}
diff --git a/internal/openai/header_redirect.go b/internal/openai/header_redirect.go
new file mode 100644
index 00000000..e7d9400f
--- /dev/null
+++ b/internal/openai/header_redirect.go
@@ -0,0 +1,57 @@
+package openai
+
+import (
+ "cyberstrike-ai/internal/config"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strings"
+)
+
+// customHeaderHTTPClient does not mutate shared clients. Custom headers can
+// contain credentials under arbitrary names, so none may follow a cross-origin
+// redirect (including HTTPS downgrades). Checking only in the transport is too
+// late: net/http also copies private headers into redirected requests.
+func customHeaderHTTPClient(base *http.Client, cfg *config.OpenAIConfig) *http.Client {
+ if base == nil {
+ base = http.DefaultClient
+ }
+ if cfg == nil || len(cfg.Headers) == 0 {
+ return base
+ }
+ cloned := *base
+ previous := base.CheckRedirect
+ cloned.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+ if previous != nil {
+ if err := previous(req, via); err != nil {
+ return err
+ }
+ } else if len(via) >= 10 {
+ return fmt.Errorf("stopped after 10 redirects")
+ }
+ if len(via) == 0 || !sameHeaderOrigin(req.URL, via[0].URL) {
+ return fmt.Errorf("cross-origin redirect blocked for model custom headers")
+ }
+ return nil
+ }
+ return &cloned
+}
+
+func sameHeaderOrigin(a, b *url.URL) bool {
+ if a == nil || b == nil {
+ return false
+ }
+ port := func(u *url.URL) string {
+ if p := u.Port(); p != "" {
+ return p
+ }
+ if strings.EqualFold(u.Scheme, "https") {
+ return "443"
+ }
+ if strings.EqualFold(u.Scheme, "http") {
+ return "80"
+ }
+ return ""
+ }
+ return strings.EqualFold(a.Scheme, b.Scheme) && strings.EqualFold(a.Hostname(), b.Hostname()) && port(a) == port(b)
+}
diff --git a/internal/openai/header_redirect_test.go b/internal/openai/header_redirect_test.go
new file mode 100644
index 00000000..91e28584
--- /dev/null
+++ b/internal/openai/header_redirect_test.go
@@ -0,0 +1,131 @@
+package openai
+
+import (
+ "context"
+ "cyberstrike-ai/internal/config"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "strings"
+ "testing"
+)
+
+func TestCustomHeadersDoNotCrossRedirectOrigin(t *testing.T) {
+ for _, kind := range []string{"eino", "builtin"} {
+ t.Run(kind, func(t *testing.T) {
+ targetCalls := 0
+ dest := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { targetCalls++; w.Write([]byte(`{}`)) }))
+ defer dest.Close()
+ for _, mode := range []string{"port", "host", "downgrade"} {
+ t.Run(mode, func(t *testing.T) {
+ target := dest.URL
+ if mode == "host" {
+ target = strings.Replace(target, "127.0.0.1", "localhost", 1)
+ }
+ handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { http.Redirect(w, r, target, 302) })
+ var src *httptest.Server
+ if mode == "downgrade" {
+ src = httptest.NewTLSServer(handler)
+ } else {
+ src = httptest.NewServer(handler)
+ }
+ defer src.Close()
+ cfg := &config.OpenAIConfig{BaseURL: src.URL, APIKey: "test-key", Headers: map[string]string{"Authorization": "Bearer test-private", "X-Private-Key": "private"}}
+ var err error
+ if kind == "eino" {
+ var resp *http.Response
+ resp, err = NewEinoHTTPClient(cfg, src.Client()).Get(src.URL)
+ if resp != nil {
+ resp.Body.Close()
+ }
+ } else {
+ var out interface{}
+ err = NewClient(cfg, src.Client(), nil).ChatCompletion(context.Background(), map[string]string{}, &out)
+ }
+ if err == nil || !strings.Contains(err.Error(), "cross-origin") {
+ t.Fatalf("expected blocked redirect: %v", err)
+ }
+ if targetCalls != 0 {
+ t.Fatalf("credentials could reach other origin: %d requests", targetCalls)
+ }
+ })
+ }
+ })
+ }
+}
+func TestCustomHeadersSameOriginRedirectAndClientIsolation(t *testing.T) {
+ finalCalls := 0
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/final" {
+ http.Redirect(w, r, "/final", 307)
+ return
+ }
+ finalCalls++
+ if r.Header.Get("Authorization") != "Bearer custom" || r.Header.Get("X-Private-Key") != "private" {
+ t.Error("same-origin headers lost")
+ }
+ w.Write([]byte(`{}`))
+ }))
+ defer srv.Close()
+ cfg := &config.OpenAIConfig{BaseURL: srv.URL, APIKey: "key", Headers: map[string]string{"Authorization": "Bearer custom", "X-Private-Key": "private"}}
+ base := srv.Client()
+ callbacks := 0
+ base.CheckRedirect = func(req *http.Request, via []*http.Request) error { callbacks++; return nil }
+ resp, err := NewEinoHTTPClient(cfg, base).Get(srv.URL)
+ if err != nil {
+ t.Fatal(err)
+ }
+ resp.Body.Close()
+ var out interface{}
+ if err = NewClient(cfg, base, nil).ChatCompletion(context.Background(), map[string]string{}, &out); err != nil {
+ t.Fatal(err)
+ }
+ if finalCalls != 2 || callbacks != 2 {
+ t.Fatalf("calls=%d callbacks=%d", finalCalls, callbacks)
+ }
+ // Existing callbacks are preserved; they can decline a redirect without a request.
+ base.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }
+ resp, err = NewEinoHTTPClient(cfg, base).Get(srv.URL)
+ if err != nil || resp.StatusCode != 307 {
+ t.Fatalf("callback not preserved: %v", err)
+ }
+ resp.Body.Close()
+ if customHeaderHTTPClient(base, nil) != base {
+ t.Fatal("no-header client changed")
+ }
+ // RoundTrip must not mutate a request owned by the caller.
+ req, _ := http.NewRequest("GET", srv.URL+"/final", nil)
+ resp, err = NewEinoHTTPClient(cfg, base).Do(req)
+ if err != nil {
+ t.Fatal(err)
+ }
+ resp.Body.Close()
+ if req.Header.Get("Authorization") != "" {
+ t.Fatal("request mutated")
+ }
+}
+func TestHeaderRedirectPolicyLimitsAndCallbackMutation(t *testing.T) {
+ cfg := &config.OpenAIConfig{Headers: map[string]string{"X-Private": "value"}}
+ req, _ := http.NewRequest("GET", "https://example.com:443/next", nil)
+ first, _ := http.NewRequest("GET", "https://example.com/start", nil)
+ client := customHeaderHTTPClient(nil, cfg)
+ if err := client.CheckRedirect(req, []*http.Request{first}); err != nil {
+ t.Fatal(err)
+ }
+ if client.CheckRedirect(req, make([]*http.Request, 10)) == nil {
+ t.Fatal("redirect loop limit lost")
+ }
+ base := &http.Client{CheckRedirect: func(r *http.Request, _ []*http.Request) error {
+ r.URL, _ = url.Parse("https://other.invalid")
+ return nil
+ }}
+ if customHeaderHTTPClient(base, cfg).CheckRedirect(req, []*http.Request{first}) == nil {
+ t.Fatal("callback rewrote destination across boundary")
+ }
+ sentinel := fmt.Errorf("custom decline")
+ base.CheckRedirect = func(*http.Request, []*http.Request) error { return sentinel }
+ if customHeaderHTTPClient(base, cfg).CheckRedirect(req, nil) != sentinel {
+ t.Fatal("custom error lost")
+ }
+}
diff --git a/internal/openai/openai.go b/internal/openai/openai.go
index 318813e4..7b3aa77b 100644
--- a/internal/openai/openai.go
+++ b/internal/openai/openai.go
@@ -115,9 +115,10 @@ func (c *Client) ChatCompletion(ctx context.Context, payload interface{}, out in
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+c.config.APIKey)
+ applyCustomHeaders(req, c.config)
requestStart := time.Now()
- resp, err := c.httpClient.Do(req)
+ resp, err := customHeaderHTTPClient(c.httpClient, c.config).Do(req)
if err != nil {
return fmt.Errorf("call openai api: %w", err)
}
@@ -207,9 +208,10 @@ func (c *Client) ChatCompletionStream(ctx context.Context, payload interface{},
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+c.config.APIKey)
+ applyCustomHeaders(req, c.config)
requestStart := time.Now()
- resp, err := c.httpClient.Do(req)
+ resp, err := customHeaderHTTPClient(c.httpClient, c.config).Do(req)
if err != nil {
return "", fmt.Errorf("call openai api: %w", err)
}
@@ -357,9 +359,10 @@ func (c *Client) ChatCompletionStreamWithToolCalls(
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+c.config.APIKey)
+ applyCustomHeaders(req, c.config)
requestStart := time.Now()
- resp, err := c.httpClient.Do(req)
+ resp, err := customHeaderHTTPClient(c.httpClient, c.config).Do(req)
if err != nil {
return "", nil, "", fmt.Errorf("call openai api: %w", err)
}
@@ -572,8 +575,9 @@ func (c *Client) ListModels(ctx context.Context) ([]string, error) {
return nil, fmt.Errorf("build openai models request: %w", err)
}
req.Header.Set("Authorization", "Bearer "+c.config.APIKey)
+ applyCustomHeaders(req, c.config)
- resp, err := c.httpClient.Do(req)
+ resp, err := customHeaderHTTPClient(c.httpClient, c.config).Do(req)
if err != nil {
return nil, fmt.Errorf("call openai models api: %w", err)
}
diff --git a/internal/openai/request_headers.go b/internal/openai/request_headers.go
new file mode 100644
index 00000000..9d9c42c8
--- /dev/null
+++ b/internal/openai/request_headers.go
@@ -0,0 +1,118 @@
+package openai
+
+import (
+ "context"
+ "net/http"
+ "strings"
+
+ "cyberstrike-ai/internal/config"
+)
+
+// sessionHeaderPlaceholder 是自定义请求头值里代表「当前对话 ID」的占位符。
+// 写入方式(配置文件或设置页)示例:
+//
+// headers:
+// x-opencode-session: %session_id%
+//
+// 实际下发时会替换为当前对话的 conversation id。
+// 注意:不要使用 {{...}} 语法,index.html 是 Go 模板,会被当作模板函数解析。
+const sessionHeaderPlaceholder = "%session_id%"
+
+type sessionIDContextKey struct{}
+
+// WithSessionID 把当前对话 ID 注入 ctx。handler 在任务开始时注入一次,
+// 后续 Eino ChatModel 与内置 Client 发出的 HTTP 请求都能在请求上下文里读到。
+func WithSessionID(ctx context.Context, sessionID string) context.Context {
+ if ctx == nil {
+ return nil
+ }
+ id := strings.TrimSpace(sessionID)
+ if id == "" {
+ return ctx
+ }
+ return context.WithValue(ctx, sessionIDContextKey{}, id)
+}
+
+// SessionIDFromContext 读取 ctx 中的对话 ID,未注入时返回空串。
+func SessionIDFromContext(ctx context.Context) string {
+ if ctx == nil {
+ return ""
+ }
+ v, _ := ctx.Value(sessionIDContextKey{}).(string)
+ return v
+}
+
+// renderHeaderValue 把值里的 %session_id% 替换为当前对话 ID。
+// 第二个返回值为 false 表示该头依赖会话 ID 但上下文里取不到,应当跳过下发,
+// 避免把字面量 "%session_id%" 发给上游造成脏数据。
+func renderHeaderValue(value, sessionID string) (string, bool) {
+ if !strings.Contains(value, sessionHeaderPlaceholder) {
+ return value, true
+ }
+ id := strings.TrimSpace(sessionID)
+ if id == "" {
+ return "", false
+ }
+ return strings.ReplaceAll(value, sessionHeaderPlaceholder, id), true
+}
+
+// normalizedCustomHeaders 返回规范化后的自定义请求头:
+// 去掉名称两端空白,丢弃空名称/空值,便于安全地写入 http.Header。
+func normalizedCustomHeaders(cfg *config.OpenAIConfig) map[string]string {
+ if cfg == nil || len(cfg.Headers) == 0 {
+ return nil
+ }
+ out := make(map[string]string, len(cfg.Headers))
+ for name, value := range cfg.Headers {
+ name = strings.TrimSpace(name)
+ if name == "" || strings.TrimSpace(value) == "" {
+ continue
+ }
+ out[name] = value
+ }
+ if len(out) == 0 {
+ return nil
+ }
+ return out
+}
+
+// applyCustomHeaders 把渠道配置的自定义请求头写入请求。
+// 同名的内置头(Authorization、Content-Type 等)会被配置值覆盖,
+// 因此只接受私有鉴权头的第三方 OpenAI 兼容网关也能正常调用。
+// 值中的 %session_id% 会替换为请求上下文里的当前对话 ID。
+func applyCustomHeaders(req *http.Request, cfg *config.OpenAIConfig) {
+ if req == nil || req.Header == nil {
+ return
+ }
+ headers := normalizedCustomHeaders(cfg)
+ if len(headers) == 0 {
+ return
+ }
+ sessionID := SessionIDFromContext(req.Context())
+ for name, value := range headers {
+ rendered, ok := renderHeaderValue(value, sessionID)
+ if !ok {
+ continue
+ }
+ req.Header.Set(name, rendered)
+ }
+}
+
+// headersRoundTripper 为经过 Eino ChatModel 的请求注入渠道自定义请求头。
+type headersRoundTripper struct {
+ base http.RoundTripper
+ cfg *config.OpenAIConfig
+}
+
+func (rt *headersRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+ base := http.DefaultTransport
+ if rt != nil && rt.base != nil {
+ base = rt.base
+ }
+ if rt == nil || req == nil {
+ return base.RoundTrip(req)
+ }
+ cloned := req.Clone(req.Context())
+ applyCustomHeaders(cloned, rt.cfg)
+ return base.RoundTrip(cloned)
+}
diff --git a/internal/openai/request_headers_test.go b/internal/openai/request_headers_test.go
new file mode 100644
index 00000000..32aedd89
--- /dev/null
+++ b/internal/openai/request_headers_test.go
@@ -0,0 +1,162 @@
+package openai
+
+import (
+ "context"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ "cyberstrike-ai/internal/config"
+)
+
+func TestApplyCustomHeadersOverridesBuiltinAndSkipsEmpty(t *testing.T) {
+ req, err := http.NewRequest(http.MethodPost, "http://example.com/v1/chat/completions", nil)
+ if err != nil {
+ t.Fatalf("new request: %v", err)
+ }
+ req.Header.Set("Authorization", "Bearer builtin")
+ applyCustomHeaders(req, &config.OpenAIConfig{Headers: map[string]string{
+ "Authorization": "Bearer custom",
+ "X-Api-Key": "secret",
+ "User-Agent": "cyberstrike-ai/1.0",
+ "X-Empty": "",
+ " ": "dropped",
+ }})
+ if got := req.Header.Get("Authorization"); got != "Bearer custom" {
+ t.Fatalf("Authorization = %q, want custom override", got)
+ }
+ if got := req.Header.Get("X-Api-Key"); got != "secret" {
+ t.Fatalf("X-Api-Key = %q", got)
+ }
+ if got := req.Header.Get("User-Agent"); got != "cyberstrike-ai/1.0" {
+ t.Fatalf("User-Agent = %q", got)
+ }
+ if got := req.Header.Get("X-Empty"); got != "" {
+ t.Fatalf("empty header value must be skipped, got %q", got)
+ }
+}
+
+func TestApplyCustomHeadersNilConfigIsNoop(t *testing.T) {
+ req, _ := http.NewRequest(http.MethodGet, "http://example.com/", nil)
+ applyCustomHeaders(req, nil)
+ if got := req.Header.Get("Authorization"); got != "" {
+ t.Fatalf("unexpected Authorization %q", got)
+ }
+}
+
+func TestHeadersRoundTripperInjectsHeaders(t *testing.T) {
+ var auth, provider string
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ auth = r.Header.Get("Authorization")
+ provider = r.Header.Get("X-Provider")
+ w.WriteHeader(http.StatusOK)
+ }))
+ defer srv.Close()
+
+ cfg := &config.OpenAIConfig{Headers: map[string]string{
+ "Authorization": "Bearer from-headers",
+ "X-Provider": "opencode",
+ }}
+ client := NewEinoHTTPClient(cfg, srv.Client())
+ req, _ := http.NewRequest(http.MethodPost, srv.URL+"/v1/chat/completions", nil)
+ resp, err := client.Do(req)
+ if err != nil {
+ t.Fatalf("do: %v", err)
+ }
+ resp.Body.Close()
+ if auth != "Bearer from-headers" {
+ t.Fatalf("Authorization = %q", auth)
+ }
+ if provider != "opencode" {
+ t.Fatalf("X-Provider = %q", provider)
+ }
+}
+
+func TestExpandHeaderMapEnv(t *testing.T) {
+ t.Setenv("TEST_CS_HEADER_TOKEN", "tok-123")
+ got := config.ExpandHeaderMap(map[string]string{
+ "X-Api-Key": "${TEST_CS_HEADER_TOKEN}",
+ "X-Default": "${TEST_CS_MISSING_VAR:-fallback}",
+ })
+ if got["X-Api-Key"] != "tok-123" {
+ t.Fatalf("X-Api-Key = %q", got["X-Api-Key"])
+ }
+ if got["X-Default"] != "fallback" {
+ t.Fatalf("X-Default = %q", got["X-Default"])
+ }
+ if config.ExpandHeaderMap(nil) != nil {
+ t.Fatalf("nil headers should stay nil")
+ }
+}
+
+func TestSessionHeaderPlaceholderRendering(t *testing.T) {
+ cfg := &config.OpenAIConfig{Headers: map[string]string{
+ "x-opencode-session": "%session_id%",
+ "X-Prefixed": "pfx-%session_id%",
+ "X-Fixed": "static",
+ }}
+
+ ctx := WithSessionID(context.Background(), "conv-abc-123")
+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://example.com/v1/chat/completions", nil)
+ if err != nil {
+ t.Fatalf("new request: %v", err)
+ }
+ applyCustomHeaders(req, cfg)
+ if got := req.Header.Get("x-opencode-session"); got != "conv-abc-123" {
+ t.Fatalf("session header = %q, want conv-abc-123", got)
+ }
+ if got := req.Header.Get("X-Prefixed"); got != "pfx-conv-abc-123" {
+ t.Fatalf("prefixed header = %q", got)
+ }
+ if got := req.Header.Get("X-Fixed"); got != "static" {
+ t.Fatalf("fixed header = %q", got)
+ }
+}
+
+func TestSessionHeaderSkippedWithoutSession(t *testing.T) {
+ cfg := &config.OpenAIConfig{Headers: map[string]string{
+ "x-opencode-session": "%session_id%",
+ "X-Fixed": "static",
+ }}
+ req, _ := http.NewRequest(http.MethodPost, "http://example.com/v1/chat/completions", nil)
+ applyCustomHeaders(req, cfg)
+ if got := req.Header.Get("x-opencode-session"); got != "" {
+ t.Fatalf("placeholder must be skipped without session, got %q", got)
+ }
+ if got := req.Header.Get("X-Fixed"); got != "static" {
+ t.Fatalf("fixed header must still be sent, got %q", got)
+ }
+}
+
+func TestSessionIDContextRoundTrip(t *testing.T) {
+ if got := SessionIDFromContext(context.Background()); got != "" {
+ t.Fatalf("empty context should yield empty id, got %q", got)
+ }
+ if got := SessionIDFromContext(WithSessionID(context.Background(), " ")); got != "" {
+ t.Fatalf("blank id must be ignored, got %q", got)
+ }
+ ctx := WithSessionID(context.Background(), " conv-1 ")
+ if got := SessionIDFromContext(ctx); got != "conv-1" {
+ t.Fatalf("id = %q, want conv-1", got)
+ }
+}
+
+func TestRenderHeaderValueCases(t *testing.T) {
+ cases := []struct {
+ value string
+ sid string
+ want string
+ ok bool
+ }{
+ {"static", "s1", "static", true},
+ {"%session_id%", "s1", "s1", true},
+ {"a-%session_id%-b", "s1", "a-s1-b", true},
+ {"%session_id%", "", "", false},
+ }
+ for _, c := range cases {
+ got, ok := renderHeaderValue(c.value, c.sid)
+ if ok != c.ok || got != c.want {
+ t.Fatalf("renderHeaderValue(%q,%q) = (%q,%v), want (%q,%v)", c.value, c.sid, got, ok, c.want, c.ok)
+ }
+ }
+}
diff --git a/web/static/js/settings-header-boundaries.test.cjs b/web/static/js/settings-header-boundaries.test.cjs
new file mode 100644
index 00000000..e8d414d6
--- /dev/null
+++ b/web/static/js/settings-header-boundaries.test.cjs
@@ -0,0 +1,23 @@
+const {test}=require('node:test');
+const assert=require('node:assert/strict');
+const fs=require('node:fs');
+const vm=require('node:vm');
+const source=fs.readFileSync('web/static/js/settings.js','utf8');
+const code=source.slice(source.indexOf('function collectHitlAuditModelEffectiveConfig()'),source.indexOf('async function testHitlAuditModelConnection()'));
+function collect(overrides={},savedHeaders){
+ const fields={'openai-provider':'openai','openai-api-key':'********','openai-base-url':'https://main.invalid','openai-model':'main',...overrides};
+ const c={document:{getElementById:id=>({value:fields[id]||''})},selectedAIChannelId:'main',normalizeAIChannelId:x=>x,currentConfig:{ai:{channels:{main:{headers:{Authorization:'********','X-Label':'label'}}}},hitl:{audit_model:{headers:savedHeaders}}}};
+ vm.createContext(c);vm.runInContext(code,c);return JSON.parse(JSON.stringify(c.collectHitlAuditModelEffectiveConfig()));
+}
+test('audit shares headers only when it inherits model identity',()=>{
+ assert.equal(collect().headers.Authorization,'********');
+ assert.equal(collect({'hitl-audit-model-name':'small'}).headers.Authorization,'********');
+ for(const [id,value] of [['hitl-audit-model-provider','openai'],['hitl-audit-model-base-url','https://audit.invalid'],['hitl-audit-model-api-key','********']])assert.deepEqual(collect({[id]:value}).headers,{});
+});
+test('explicit audit headers belong to audit configuration',()=>{
+ assert.deepEqual(collect({'hitl-audit-model-base-url':'https://audit.invalid'},{'X-Api-Key':'********'}).headers,{'X-Api-Key':'********'});
+});
+test('empty audit headers follow the same identity policy as omitted headers',()=>{
+ assert.deepEqual(collect({},{}).headers,collect().headers);
+ assert.deepEqual(collect({'hitl-audit-model-api-key':'audit-key'},{}).headers,{});
+});
diff --git a/web/static/js/settings.js b/web/static/js/settings.js
index fca5c069..52a837ec 100644
--- a/web/static/js/settings.js
+++ b/web/static/js/settings.js
@@ -2666,6 +2666,31 @@ function ensureAIConfigShape(cfg) {
return normalizeAIConfigProviderProfiles({ default_channel: def, channels });
}
+// parseCustomHeadersInput 把「每行一条 KEY=VALUE」的文本解析为请求头对象。
+// 空行与 # 开头的行会被忽略;键或值为空的行直接跳过。
+function parseCustomHeadersInput() {
+ const el = document.getElementById('openai-custom-headers');
+ if (!el) return {};
+ const out = {};
+ String(el.value || '').split(/\r?\n/).forEach((line) => {
+ const trimmed = line.trim();
+ if (!trimmed || trimmed.charAt(0) === '#') return;
+ const idx = trimmed.indexOf('=');
+ if (idx <= 0) return;
+ const key = trimmed.slice(0, idx).trim();
+ const value = trimmed.slice(idx + 1).trim();
+ if (!key || !value) return;
+ out[key] = value;
+ });
+ return out;
+}
+
+// formatCustomHeaders 把请求头对象写回「每行一条 KEY=VALUE」的文本。
+function formatCustomHeaders(headers) {
+ if (!headers || typeof headers !== 'object') return '';
+ return Object.keys(headers).sort().map((k) => k + '=' + headers[k]).join('\n');
+}
+
function readAIChannelFromMainForm(id) {
const prev = currentConfig?.ai?.channels?.[id] || {};
const maxCompletionTokens = parseInt(document.getElementById('openai-max-completion-tokens')?.value, 10) || 32768;
@@ -2678,6 +2703,7 @@ function readAIChannelFromMainForm(id) {
model: document.getElementById('openai-model')?.value.trim() || '',
max_total_tokens: parseInt(document.getElementById('openai-max-total-tokens')?.value, 10) || 120000,
max_completion_tokens: maxCompletionTokens,
+ headers: parseCustomHeadersInput(),
reasoning: {
...(prev.reasoning || {}),
mode: document.getElementById('openai-reasoning-mode')?.value || 'auto',
@@ -2710,6 +2736,8 @@ function writeAIChannelToMainForm(id) {
if (maxTokensEl) maxTokensEl.value = ch.max_total_tokens || 120000;
const maxCompletionTokensEl = document.getElementById('openai-max-completion-tokens');
if (maxCompletionTokensEl) maxCompletionTokensEl.value = ch.max_completion_tokens || 32768;
+ const customHeadersEl = document.getElementById('openai-custom-headers');
+ if (customHeadersEl) customHeadersEl.value = formatCustomHeaders(ch.headers);
const r = ch.reasoning || {};
const modeEl = document.getElementById('openai-reasoning-mode');
if (modeEl) {
@@ -2814,7 +2842,8 @@ function bindAIChannelEditorPreviewSync() {
'openai-provider',
'openai-api-key',
'openai-base-url',
- 'openai-model'
+ 'openai-model',
+ 'openai-custom-headers'
];
ids.forEach((fieldId) => {
const el = document.getElementById(fieldId);
@@ -3256,7 +3285,8 @@ async function probeSelectedAIChannels() {
channel_id: id,
base_url: ch.base_url || '',
api_key: ch.api_key || '',
- model: ch.model || ''
+ model: ch.model || '',
+ headers: ch.headers || {}
})
});
const result = await response.json().catch(() => ({}));
@@ -3769,11 +3799,19 @@ function collectHitlAuditModelEffectiveConfig() {
base_url: document.getElementById('openai-base-url')?.value.trim() || '',
model: document.getElementById('openai-model')?.value.trim() || ''
};
+ const auditProvider = document.getElementById('hitl-audit-model-provider')?.value || '';
+ const auditKey = document.getElementById('hitl-audit-model-api-key')?.value.trim() || '';
+ const overriddenBaseUrl = document.getElementById('hitl-audit-model-base-url')?.value.trim() || '';
+ const mainChannelId = normalizeAIChannelId(selectedAIChannelId || currentConfig?.ai?.default_channel || 'default');
+ const mainHeaders = currentConfig?.ai?.channels?.[mainChannelId]?.headers || {};
+ const auditHeaders = currentConfig?.hitl?.audit_model?.headers || {};
return {
provider: document.getElementById('hitl-audit-model-provider')?.value || main.provider,
- base_url: document.getElementById('hitl-audit-model-base-url')?.value.trim() || main.base_url,
+ base_url: overriddenBaseUrl || main.base_url,
api_key: document.getElementById('hitl-audit-model-api-key')?.value.trim() || main.api_key,
- model: document.getElementById('hitl-audit-model-name')?.value.trim() || main.model
+ model: document.getElementById('hitl-audit-model-name')?.value.trim() || main.model,
+ // 审计模型留空即复用主渠道,自定义请求头必须一起跟随,否则私有鉴权头的供应商测试必然失败。
+ headers: Object.keys(auditHeaders).length ? auditHeaders : ((overriddenBaseUrl || auditProvider || auditKey) ? {} : mainHeaders)
};
}
@@ -3952,7 +3990,8 @@ async function testOpenAIConnection() {
channel_id: channelId,
base_url: baseUrl,
api_key: apiKey,
- model: model
+ model: model,
+ headers: currentConfig?.ai?.channels?.[channelId]?.headers || {}
})
});
diff --git a/web/templates/index.html b/web/templates/index.html
index b23fe3f2..a41354ca 100644
--- a/web/templates/index.html
+++ b/web/templates/index.html
@@ -3813,6 +3813,19 @@
允许对话页覆盖推理选项
+
+
+
+ 自定义请求头
+ 每行一条 KEY=VALUE;值支持 ${ENV_VAR}、${ENV_VAR:-默认值} 与 %session_id%(自动填当前对话 ID);同名头会覆盖内置 Authorization。
+
+
+
+
+
+ 用于要求私有鉴权头、版本头或组织头的第三方 OpenAI 兼容供应商(例如 opencode 等聚合网关)。留空表示不附加。
+
+