feat: 新增 VolcAdapter (58) 渠道——火山方舟原生 API 兼容代理

common/api_type.go

@@ -75,6 +75,8 @@ func ChannelType2APIType(channelType int) (int, bool) {
 		apiType = constant.APITypeReplicate
 	case constant.ChannelTypeCodex:
 		apiType = constant.APITypeCodex
+	case constant.ChannelTypeVolcAdapter:
+		apiType = constant.APITypeVolcAdapter
 	}
 	if apiType == -1 {
 		return constant.APITypeOpenAI, false

common/endpoint_defaults.go

@@ -25,6 +25,8 @@ var defaultEndpointInfoMap = map[constant.EndpointType]EndpointInfo{
 	constant.EndpointTypeJinaRerank:            {Path: "/v1/rerank", Method: "POST"},
 	constant.EndpointTypeImageGeneration:       {Path: "/v1/images/generations", Method: "POST"},
 	constant.EndpointTypeEmbeddings:            {Path: "/v1/embeddings", Method: "POST"},
+	constant.EndpointTypeVolcImage:             {Path: "/api/v3/images/generations", Method: "POST"},
+	constant.EndpointTypeVolcVideo:             {Path: "/api/v3/contents/generations/tasks", Method: "POST"},
 }
 
 // GetDefaultEndpointInfo 返回指定端点类型的默认信息以及是否存在

common/endpoint_type.go

@@ -24,6 +24,18 @@ func GetEndpointTypesByChannelType(channelType int, modelName string) []constant
 		fallthrough
 	case constant.ChannelTypeGemini:
 		endpointTypes = []constant.EndpointType{constant.EndpointTypeGemini, constant.EndpointTypeOpenAI}
+	case constant.ChannelTypeVolcAdapter:
+		if IsImageGenerationModel(modelName) {
+			return []constant.EndpointType{
+				constant.EndpointTypeVolcImage,
+				constant.EndpointTypeImageGeneration,
+				constant.EndpointTypeOpenAI,
+			}
+		}
+		return []constant.EndpointType{
+			constant.EndpointTypeVolcVideo,
+			constant.EndpointTypeOpenAIVideo,
+		}
 	case constant.ChannelTypeOpenRouter: // OpenRouter 只支持 OpenAI 端点
 		endpointTypes = []constant.EndpointType{constant.EndpointTypeOpenAI}
 	case constant.ChannelTypeXai:

common/endpoint_type_test.go

@@ -0,0 +1,129 @@
+package common
+
+import (
+	"testing"
+
+	"github.com/QuantumNous/new-api/constant"
+)
+
+func TestGetEndpointTypesByChannelType(t *testing.T) {
+	type testCase struct {
+		name        string
+		channelType int
+		modelName   string
+		// wantFirst is the expected first element of the returned slice.
+		wantFirst constant.EndpointType
+		// wantContains lists types that must appear anywhere in the result.
+		wantContains []constant.EndpointType
+		// wantAbsent lists types that must NOT appear in the result.
+		wantAbsent []constant.EndpointType
+		// exactSlice, if non-nil, asserts the entire slice matches exactly.
+		exactSlice []constant.EndpointType
+	}
+
+	cases := []testCase{
+		// --- VolcAdapter (ch 58): image-gen models → [volc-image, image-generation, openai] ---
+		{
+			name:        "VolcAdapter + seedream model → volc-image first",
+			channelType: constant.ChannelTypeVolcAdapter,
+			modelName:   "doubao-seedream-5-0-260128",
+			wantFirst:   constant.EndpointTypeVolcImage,
+			exactSlice: []constant.EndpointType{
+				constant.EndpointTypeVolcImage,
+				constant.EndpointTypeImageGeneration,
+				constant.EndpointTypeOpenAI,
+			},
+		},
+		// --- VolcAdapter (ch 58): video/non-image models → [volc-video, openai-video] ---
+		{
+			name:        "VolcAdapter + seedance model → volc-video first",
+			channelType: constant.ChannelTypeVolcAdapter,
+			modelName:   "doubao-seedance-2-0-260128",
+			wantFirst:   constant.EndpointTypeVolcVideo,
+			exactSlice: []constant.EndpointType{
+				constant.EndpointTypeVolcVideo,
+				constant.EndpointTypeOpenAIVideo,
+			},
+		},
+		// --- Regression: VolcEngine (45) with seedream must NOT include volc-image ---
+		{
+			name:        "VolcEngine (45) + seedream → no volc-image (only ch 58 gets volc-* types)",
+			channelType: constant.ChannelTypeVolcEngine,
+			modelName:   "doubao-seedream-5-0-260128",
+			// VolcEngine falls to default; seedream triggers image-generation prepend only.
+			wantContains: []constant.EndpointType{constant.EndpointTypeImageGeneration},
+			wantAbsent:   []constant.EndpointType{constant.EndpointTypeVolcImage},
+		},
+		// --- Regression: VolcEngine (45) + LLM → default openai ---
+		{
+			name:        "VolcEngine (45) + LLM model → default openai",
+			channelType: constant.ChannelTypeVolcEngine,
+			modelName:   "Doubao-pro-32k",
+			wantFirst:   constant.EndpointTypeOpenAI,
+			wantAbsent:  []constant.EndpointType{constant.EndpointTypeVolcImage, constant.EndpointTypeVolcVideo},
+		},
+		// --- Regression: DoubaoVideo (54) + seedance must NOT include volc-video ---
+		{
+			name:        "DoubaoVideo (54) + seedance → no volc-video (only ch 58 gets volc-* types)",
+			channelType: constant.ChannelTypeDoubaoVideo,
+			modelName:   "doubao-seedance-2-0-260128",
+			// DoubaoVideo falls to default; seedance is not an image model so openai is returned.
+			wantFirst:  constant.EndpointTypeOpenAI,
+			wantAbsent: []constant.EndpointType{constant.EndpointTypeVolcVideo},
+		},
+		// --- DoubaoVideo (54) + arbitrary → default openai ---
+		{
+			name:        "DoubaoVideo (54) + arbitrary model → default openai",
+			channelType: constant.ChannelTypeDoubaoVideo,
+			modelName:   "some-video-model",
+			wantFirst:   constant.EndpointTypeOpenAI,
+			wantAbsent:  []constant.EndpointType{constant.EndpointTypeVolcVideo, constant.EndpointTypeVolcImage},
+		},
+	}
+
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			got := GetEndpointTypesByChannelType(tc.channelType, tc.modelName)
+
+			if tc.exactSlice != nil {
+				if len(got) != len(tc.exactSlice) {
+					t.Fatalf("expected slice %v, got %v", tc.exactSlice, got)
+				}
+				for i, want := range tc.exactSlice {
+					if got[i] != want {
+						t.Errorf("index %d: want %q, got %q", i, want, got[i])
+					}
+				}
+				return
+			}
+
+			if tc.wantFirst != "" {
+				if len(got) == 0 || got[0] != tc.wantFirst {
+					t.Errorf("expected first element %q, got %v", tc.wantFirst, got)
+				}
+			}
+
+			contains := func(slice []constant.EndpointType, target constant.EndpointType) bool {
+				for _, v := range slice {
+					if v == target {
+						return true
+					}
+				}
+				return false
+			}
+
+			for _, want := range tc.wantContains {
+				if !contains(got, want) {
+					t.Errorf("expected %q to be present in %v", want, got)
+				}
+			}
+
+			for _, absent := range tc.wantAbsent {
+				if contains(got, absent) {
+					t.Errorf("expected %q to be absent from %v", absent, got)
+				}
+			}
+		})
+	}
+}

common/model.go

@@ -16,6 +16,7 @@ var (
 		"prefix:imagen-",
 		"flux-",
 		"flux.1-",
+		"seedream",
 	}
 	OpenAITextModels = []string{
 		"gpt-",

constant/api_type.go

@@ -36,5 +36,6 @@ const (
 	APITypeMiniMax
 	APITypeReplicate
 	APITypeCodex
+	APITypeVolcAdapter
 	APITypeDummy // this one is only for count, do not add any channel after this
 )

constant/channel.go

@@ -55,6 +55,7 @@ const (
 	ChannelTypeSora           = 55
 	ChannelTypeReplicate      = 56
 	ChannelTypeCodex          = 57
+	ChannelTypeVolcAdapter    = 58
 	ChannelTypeDummy          // this one is only for count, do not add any channel after this
 
 )
@@ -118,6 +119,7 @@ var ChannelBaseURLs = []string{
 	"https://api.openai.com",                    //55
 	"https://api.replicate.com",                 //56
 	"https://chatgpt.com",                       //57
+	"https://ark.cn-beijing.volces.com",         //58
 }
 
 var ChannelTypeNames = map[int]string{
@@ -175,6 +177,7 @@ var ChannelTypeNames = map[int]string{
 	ChannelTypeSora:           "Sora",
 	ChannelTypeReplicate:      "Replicate",
 	ChannelTypeCodex:          "Codex",
+	ChannelTypeVolcAdapter:    "VolcAdapter",
 }
 
 func GetChannelTypeName(channelType int) string {

constant/channel_test.go

@@ -0,0 +1,54 @@
+package constant
+
+import (
+	"testing"
+)
+
+func TestChannelTypeVolcAdapterRegistration(t *testing.T) {
+	// Verify the constant value is 58 (next available after ChannelTypeCodex=57).
+	if ChannelTypeVolcAdapter != 58 {
+		t.Errorf("expected ChannelTypeVolcAdapter=58, got %d", ChannelTypeVolcAdapter)
+	}
+
+	// ChannelTypeDummy in Go const blocks without iota repeats the previous explicit
+	// value, so Dummy == VolcAdapter == 58. This is the intended design: Dummy is a
+	// sentinel for "number of channel types" so loops use <= ChannelTypeDummy.
+	if ChannelTypeDummy != ChannelTypeVolcAdapter {
+		t.Errorf("expected ChannelTypeDummy == ChannelTypeVolcAdapter (%d), got %d",
+			ChannelTypeVolcAdapter, ChannelTypeDummy)
+	}
+}
+
+func TestChannelTypeVolcAdapterDisplayName(t *testing.T) {
+	name := GetChannelTypeName(ChannelTypeVolcAdapter)
+	if name != "VolcAdapter" {
+		t.Errorf("expected display name %q, got %q", "VolcAdapter", name)
+	}
+}
+
+func TestChannelTypeVolcAdapterBaseURL(t *testing.T) {
+	const wantURL = "https://ark.cn-beijing.volces.com"
+	if ChannelTypeVolcAdapter >= len(ChannelBaseURLs) {
+		t.Fatalf("ChannelBaseURLs too short: len=%d, ChannelTypeVolcAdapter=%d", len(ChannelBaseURLs), ChannelTypeVolcAdapter)
+	}
+	got := ChannelBaseURLs[ChannelTypeVolcAdapter]
+	if got != wantURL {
+		t.Errorf("expected base URL %q, got %q", wantURL, got)
+	}
+}
+
+// TestChannelBaseURLsLength verifies the ChannelBaseURLs slice covers all channel
+// types including ChannelTypeVolcAdapter, so no index-out-of-bounds can occur.
+func TestChannelBaseURLsLength(t *testing.T) {
+	// ChannelBaseURLs must have at least ChannelTypeVolcAdapter+1 entries (indices 0..ChannelTypeVolcAdapter).
+	if len(ChannelBaseURLs) < ChannelTypeVolcAdapter+1 {
+		t.Errorf("ChannelBaseURLs has %d entries but needs at least %d to cover ChannelTypeVolcAdapter=%d",
+			len(ChannelBaseURLs), ChannelTypeVolcAdapter+1, ChannelTypeVolcAdapter)
+	}
+}
+
+func TestChannelTypeVolcAdapterInNames(t *testing.T) {
+	if _, ok := ChannelTypeNames[ChannelTypeVolcAdapter]; !ok {
+		t.Errorf("ChannelTypeVolcAdapter (%d) not found in ChannelTypeNames map", ChannelTypeVolcAdapter)
+	}
+}

constant/endpoint_type.go

@@ -12,6 +12,8 @@ const (
 	EndpointTypeImageGeneration       EndpointType = "image-generation"
 	EndpointTypeEmbeddings            EndpointType = "embeddings"
 	EndpointTypeOpenAIVideo           EndpointType = "openai-video"
+	EndpointTypeVolcImage             EndpointType = "volc-image"
+	EndpointTypeVolcVideo             EndpointType = "volc-video"
 	//EndpointTypeMidjourney     EndpointType = "midjourney-proxy"
 	//EndpointTypeSuno           EndpointType = "suno-proxy"
 	//EndpointTypeKling          EndpointType = "kling"

controller/channel-test.go

@@ -117,8 +117,9 @@ func testChannel(channel *model.Channel, testModel string, endpointType string,
 			requestPath = "/v1/embeddings" // 修改请求路径
 		}
 
-		// VolcEngine 图像生成模型
-		if channel.Type == constant.ChannelTypeVolcEngine && strings.Contains(testModel, "seedream") {
+		// VolcEngine / VolcAdapter 图像生成模型
+		if (channel.Type == constant.ChannelTypeVolcEngine || channel.Type == constant.ChannelTypeVolcAdapter) &&
+			strings.Contains(testModel, "seedream") {
 			requestPath = "/v1/images/generations"
 		}
 

controller/model.go

@@ -14,6 +14,7 @@ import (
 	"github.com/QuantumNous/new-api/relay/channel/lingyiwanwu"
 	"github.com/QuantumNous/new-api/relay/channel/minimax"
 	"github.com/QuantumNous/new-api/relay/channel/moonshot"
+	"github.com/QuantumNous/new-api/relay/channel/task/volcadapter"
 	relaycommon "github.com/QuantumNous/new-api/relay/common"
 	"github.com/QuantumNous/new-api/relay/helper"
 	"github.com/QuantumNous/new-api/service"
@@ -79,6 +80,14 @@ func init() {
 			OwnedBy: minimax.ChannelName,
 		})
 	}
+	for _, modelName := range volcadapter.ModelList {
+		openAIModels = append(openAIModels, dto.OpenAIModels{
+			Id:      modelName,
+			Object:  "model",
+			Created: 1626777600,
+			OwnedBy: volcadapter.ChannelName,
+		})
+	}
 	for modelName, _ := range constant.MidjourneyModel2Action {
 		openAIModels = append(openAIModels, dto.OpenAIModels{
 			Id:      modelName,
@@ -104,6 +113,9 @@ func init() {
 		adaptor.Init(meta)
 		channelId2Models[i] = adaptor.GetModelList()
 	}
+	// VolcAdapter has its own curated model list (seedream + seedance) distinct from
+	// the underlying volcengine adaptor's LLM-focused list.
+	channelId2Models[constant.ChannelTypeVolcAdapter] = volcadapter.ModelList
 	openAIModels = lo.UniqBy(openAIModels, func(m dto.OpenAIModels) string {
 		return m.Id
 	})