feat: add OpenAI video provider failover

.gitignore

@@ -35,4 +35,9 @@ data/
 .test
 token_estimator_test.go
 skills-lock.json
+generated-videos/
+docs/*.local.md
+tmp/
+test-*.mp4
+web/**/pnpm-lock.yaml
 .playwright-mcp

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.ChannelTypeListenHub:
+		apiType = constant.APITypeListenHub
 	}
 	if apiType == -1 {
 		return constant.APITypeOpenAI, false

common/endpoint_type.go

@@ -28,8 +28,10 @@ func GetEndpointTypesByChannelType(channelType int, modelName string) []constant
 		endpointTypes = []constant.EndpointType{constant.EndpointTypeOpenAI}
 	case constant.ChannelTypeXai:
 		endpointTypes = []constant.EndpointType{constant.EndpointTypeOpenAI, constant.EndpointTypeOpenAIResponse}
-	case constant.ChannelTypeSora:
+	case constant.ChannelTypeSora, constant.ChannelTypeOpenAIVideo:
 		endpointTypes = []constant.EndpointType{constant.EndpointTypeOpenAIVideo}
+	case constant.ChannelTypeListenHub:
+		endpointTypes = []constant.EndpointType{constant.EndpointTypeImageGeneration}
 	default:
 		if IsOpenAIResponseOnlyModel(modelName) {
 			endpointTypes = []constant.EndpointType{constant.EndpointTypeOpenAIResponse}

common/model.go

@@ -10,10 +10,26 @@ var (
 		"o4-mini-deep-research",
 	}
 	ImageGenerationModels = []string{
+		"dall-e",
 		"dall-e-3",
 		"dall-e-2",
 		"gpt-image-1",
+		"gpt-image-2",
+		"gpt-image-2(线路xf)",
+		"gr-image-2",
 		"prefix:imagen-",
+		"gemini-2.5-flash-image",
+		"gemini-2.5-flash-image-preview",
+		"gemini-3-pro-image-preview",
+		"gemini-3.1-flash-image-preview",
+		"gemini_3.0_pro_image_preview",
+		"gemini_3.1_flash_image_preview",
+		"nano-banana",
+		"nano-banana-hd",
+		"nano-banana-pro",
+		"baidu/ernie-image-turbo",
+		"qwen/qwen-image",
+		"tongyi-mai/z-image",
 		"flux-",
 		"flux.1-",
 	}

common/model_test.go

@@ -0,0 +1,41 @@
+package common
+
+import (
+	"testing"
+
+	"github.com/QuantumNous/new-api/constant"
+)
+
+func TestIsImageGenerationModelIncludesConfiguredImageModels(t *testing.T) {
+	models := []string{
+		"gpt-image-2(线路XF)",
+		"gr-image-2",
+		"gemini-2.5-flash-image",
+		"gemini-2.5-flash-image-preview",
+		"gemini-3-pro-image-preview",
+		"gemini-3.1-flash-image-preview",
+		"nano-banana",
+		"nano-banana-hd",
+		"nano-banana-pro",
+	}
+
+	for _, model := range models {
+		t.Run(model, func(t *testing.T) {
+			if !IsImageGenerationModel(model) {
+				t.Fatalf("IsImageGenerationModel(%q) = false, want true", model)
+			}
+		})
+	}
+}
+
+func TestImageModelsEnableImageGenerationEndpoint(t *testing.T) {
+	endpoints := GetEndpointTypesByChannelType(constant.ChannelTypeOpenAIVideo, "gr-image-2")
+	if len(endpoints) == 0 || endpoints[0] != constant.EndpointTypeImageGeneration {
+		t.Fatalf("OpenAI video image model endpoints = %#v, want image generation first", endpoints)
+	}
+
+	endpoints = GetEndpointTypesByChannelType(constant.ChannelTypeOpenAI, "nano-banana-pro")
+	if len(endpoints) == 0 || endpoints[0] != constant.EndpointTypeImageGeneration {
+		t.Fatalf("OpenAI image model endpoints = %#v, want image generation first", endpoints)
+	}
+}

constant/api_type.go

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

constant/channel.go

@@ -55,6 +55,8 @@ const (
 	ChannelTypeSora           = 55
 	ChannelTypeReplicate      = 56
 	ChannelTypeCodex          = 57
+	ChannelTypeOpenAIVideo    = 58
+	ChannelTypeListenHub      = 59
 	ChannelTypeDummy          // this one is only for count, do not add any channel after this
 
 )
@@ -115,9 +117,11 @@ var ChannelBaseURLs = []string{
 	"https://api.vidu.cn",                       //52
 	"https://llm.submodel.ai",                   //53
 	"https://ark.cn-beijing.volces.com",         //54
-	"https://api.openai.com",                    //55
-	"https://api.replicate.com",                 //56
-	"https://chatgpt.com",                       //57
+	"https://api.openai.com",                    // 55
+	"https://api.replicate.com",                 // 56
+	"https://chatgpt.com",                       // 57
+	"",                                          // 58
+	"https://api.marswave.ai/openapi",           // 59
 }
 
 var ChannelTypeNames = map[int]string{
@@ -175,6 +179,8 @@ var ChannelTypeNames = map[int]string{
 	ChannelTypeSora:           "Sora",
 	ChannelTypeReplicate:      "Replicate",
 	ChannelTypeCodex:          "Codex",
+	ChannelTypeOpenAIVideo:    "OpenAIVideo",
+	ChannelTypeListenHub:      "ListenHub",
 }
 
 func GetChannelTypeName(channelType int) string {

constant/context_key.go

@@ -26,6 +26,7 @@ const (
 	ContextKeyChannelCreateTime        ContextKey = "channel_create_time"
 	ContextKeyChannelBaseUrl           ContextKey = "base_url"
 	ContextKeyChannelType              ContextKey = "channel_type"
+	ContextKeyChannelOther             ContextKey = "channel_other"
 	ContextKeyChannelSetting           ContextKey = "channel_setting"
 	ContextKeyChannelOtherSetting      ContextKey = "channel_other_setting"
 	ContextKeyChannelParamOverride     ContextKey = "param_override"

controller/channel-billing.go

@@ -361,6 +361,24 @@ func updateChannelBalance(channel *model.Channel) (float64, error) {
 	if channel.GetBaseURL() == "" {
 		channel.BaseURL = &baseURL
 	}
+	// 优先按 base_url/Other hint 走余额 provider（覆盖中转站，不依赖 channel.Type）
+	if result, handled, err := queryBalanceByProvider(channel); handled {
+		if err != nil {
+			return 0, err
+		}
+		switch result.Kind {
+		case BalanceKindConsoleOnly:
+			return 0, fmt.Errorf("该上游不支持 API 余额查询，仅 web 控制台可查")
+		case BalanceKindSpendOnly:
+			// 拿不到钱包余额，返回累计消费供展示；保持为正避免被余额<=0 自动禁用误伤
+			if result.Used > 0 {
+				return result.Used, nil
+			}
+			return 1, nil
+		default:
+			return result.Remaining, nil
+		}
+	}
 	switch channel.Type {
 	case constant.ChannelTypeOpenAI:
 		if channel.GetBaseURL() != "" {
@@ -444,10 +462,16 @@ func UpdateChannelBalance(c *gin.Context) {
 		common.ApiError(c, err)
 		return
 	}
+	info := channel.GetOtherInfo()
 	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "",
-		"balance": balance,
+		"success":   true,
+		"message":   "",
+		"balance":   balance,
+		"kind":      info["balance_kind"],
+		"unit":      info["balance_unit"],
+		"used":      info["balance_used"],
+		"remaining": info["balance_remaining"],
+		"provider":  info["balance_provider"],
 	})
 }
 

controller/channel.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"strconv"
 	"strings"
@@ -190,6 +191,13 @@ func buildFetchModelsHeaders(channel *model.Channel, key string) (http.Header, e
 	switch channel.Type {
 	case constant.ChannelTypeAnthropic:
 		headers = GetClaudeAuthHeader(key)
+	case constant.ChannelTypeOpenAIVideo:
+		if isXBSoraModelsAPI(channel.GetBaseURL()) {
+			headers = http.Header{}
+			headers.Set("X-API-Key", key)
+		} else {
+			headers = GetAuthHeader(key)
+		}
 	default:
 		headers = GetAuthHeader(key)
 	}
@@ -212,6 +220,93 @@ func buildFetchModelsHeaders(channel *model.Channel, key string) (http.Header, e
 	return headers, nil
 }
 
+func isXBSoraModelsAPI(baseURL string) bool {
+	baseURL = strings.ToLower(strings.TrimRight(strings.TrimSpace(baseURL), "/"))
+	return strings.Contains(baseURL, "xb-sora2") ||
+		strings.Contains(baseURL, "xbsora2") ||
+		strings.Contains(baseURL, "xb-sora") ||
+		strings.Contains(baseURL, "xbsora") ||
+		strings.HasSuffix(baseURL, "/api/v1") ||
+		strings.HasSuffix(baseURL, "/v1")
+}
+
+func xbSoraModelsURL(baseURL string) string {
+	baseURL = strings.TrimRight(strings.TrimSpace(baseURL), "/")
+	if strings.HasSuffix(baseURL, "/api/v1") || strings.HasSuffix(baseURL, "/v1") {
+		return baseURL + "/models"
+	}
+	return baseURL + "/api/v1/models"
+}
+
+func parseXBSoraModelIDs(body []byte) ([]string, error) {
+	var result map[string]any
+	if err := common.Unmarshal(body, &result); err != nil {
+		return nil, err
+	}
+	if !xbSoraFetchCodeOK(result["code"]) {
+		return nil, fmt.Errorf("xb-sora2 models fetch failed: %s", xbSoraFetchMessage(result))
+	}
+	models := findXBSoraModelIDs(result, 0)
+	if len(models) == 0 {
+		return nil, fmt.Errorf("xb-sora2 models response contains no models")
+	}
+	return models, nil
+}
+
+func findXBSoraModelIDs(value any, depth int) []string {
+	if depth > 4 {
+		return nil
+	}
+	switch v := value.(type) {
+	case map[string]any:
+		if models, ok := v["models"].([]any); ok {
+			ids := make([]string, 0, len(models))
+			for _, item := range models {
+				model, ok := item.(map[string]any)
+				if !ok {
+					continue
+				}
+				id, _ := model["id"].(string)
+				if strings.TrimSpace(id) != "" {
+					ids = append(ids, id)
+				}
+			}
+			return ids
+		}
+		if data, ok := v["data"]; ok {
+			return findXBSoraModelIDs(data, depth+1)
+		}
+	}
+	return nil
+}
+
+func xbSoraFetchCodeOK(code any) bool {
+	switch v := code.(type) {
+	case nil:
+		return true
+	case int:
+		return v == 0 || v == http.StatusOK
+	case int64:
+		return v == 0 || v == http.StatusOK
+	case float64:
+		return v == 0 || v == http.StatusOK
+	case string:
+		v = strings.TrimSpace(v)
+		return v == "" || v == "0" || v == "0000" || v == "200"
+	default:
+		return false
+	}
+}
+
+func xbSoraFetchMessage(result map[string]any) string {
+	for _, key := range []string{"message", "msg", "error"} {
+		if message, ok := result[key].(string); ok && strings.TrimSpace(message) != "" {
+			return message
+		}
+	}
+	return "unknown error"
+}
+
 func FetchUpstreamModels(c *gin.Context) {
 	id, err := strconv.Atoi(c.Param("id"))
 	if err != nil {
@@ -1056,6 +1151,10 @@ func FetchModels(c *gin.Context) {
 
 	client := &http.Client{}
 	url := fmt.Sprintf("%s/v1/models", baseURL)
+	useXBSoraModelsAPI := req.Type == constant.ChannelTypeOpenAIVideo && isXBSoraModelsAPI(baseURL)
+	if useXBSoraModelsAPI {
+		url = xbSoraModelsURL(baseURL)
+	}
 
 	request, err := http.NewRequest("GET", url, nil)
 	if err != nil {
@@ -1066,7 +1165,11 @@ func FetchModels(c *gin.Context) {
 		return
 	}
 
-	request.Header.Set("Authorization", "Bearer "+key)
+	if useXBSoraModelsAPI {
+		request.Header.Set("X-API-Key", key)
+	} else {
+		request.Header.Set("Authorization", "Bearer "+key)
+	}
 
 	response, err := client.Do(request)
 	if err != nil {
@@ -1086,6 +1189,30 @@ func FetchModels(c *gin.Context) {
 	}
 	defer response.Body.Close()
 
+	if useXBSoraModelsAPI {
+		body, err := io.ReadAll(response.Body)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"success": false,
+				"message": err.Error(),
+			})
+			return
+		}
+		models, err := parseXBSoraModelIDs(body)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"success": false,
+				"message": err.Error(),
+			})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{
+			"success": true,
+			"data":    models,
+		})
+		return
+	}
+
 	var result struct {
 		Data []struct {
 			ID string `json:"id"`