feat: add OpenAI video provider failover

.gitignore

@@ -35,3 +35,4 @@ data/
 .test
 token_estimator_test.go
 skills-lock.json
+generated-videos/

common/endpoint_type.go

@@ -28,7 +28,7 @@ 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}
 	default:
 		if IsOpenAIResponseOnlyModel(modelName) {

common/model.go

@@ -13,7 +13,10 @@ var (
 		"dall-e-3",
 		"dall-e-2",
 		"gpt-image-1",
+		"gpt-image-2",
 		"prefix:imagen-",
+		"gemini_3.0_pro_image_preview",
+		"gemini_3.1_flash_image_preview",
 		"flux-",
 		"flux.1-",
 	}

constant/channel.go

@@ -55,6 +55,7 @@ const (
 	ChannelTypeSora           = 55
 	ChannelTypeReplicate      = 56
 	ChannelTypeCodex          = 57
+	ChannelTypeOpenAIVideo    = 58
 	ChannelTypeDummy          // this one is only for count, do not add any channel after this
 
 )
@@ -115,9 +116,10 @@ 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
 }
 
 var ChannelTypeNames = map[int]string{
@@ -175,6 +177,7 @@ var ChannelTypeNames = map[int]string{
 	ChannelTypeSora:           "Sora",
 	ChannelTypeReplicate:      "Replicate",
 	ChannelTypeCodex:          "Codex",
+	ChannelTypeOpenAIVideo:    "OpenAIVideo",
 }
 
 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.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"strconv"
 	"strings"
@@ -174,6 +175,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)
 	}
@@ -196,6 +204,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 {
@@ -1032,6 +1127,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 {
@@ -1042,7 +1141,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 {
@@ -1062,6 +1165,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"`

controller/channel_upstream_update.go

@@ -293,6 +293,12 @@ func fetchChannelUpstreamModelIDs(channel *model.Channel) ([]string, error) {
 	switch channel.Type {
 	case constant.ChannelTypeAli:
 		url = fmt.Sprintf("%s/compatible-mode/v1/models", baseURL)
+	case constant.ChannelTypeOpenAIVideo:
+		if isXBSoraModelsAPI(baseURL) {
+			url = xbSoraModelsURL(baseURL)
+		} else {
+			url = fmt.Sprintf("%s/v1/models", baseURL)
+		}
 	case constant.ChannelTypeZhipu_v4:
 		if plan, ok := constant.ChannelSpecialBases[baseURL]; ok && plan.OpenAIBaseURL != "" {
 			url = fmt.Sprintf("%s/models", plan.OpenAIBaseURL)
@@ -331,6 +337,14 @@ func fetchChannelUpstreamModelIDs(channel *model.Channel) ([]string, error) {
 		return nil, err
 	}
 
+	if channel.Type == constant.ChannelTypeOpenAIVideo && isXBSoraModelsAPI(baseURL) {
+		models, err := parseXBSoraModelIDs(body)
+		if err != nil {
+			return nil, err
+		}
+		return normalizeModelNames(models), nil
+	}
+
 	var result OpenAIModelsResponse
 	if err := common.Unmarshal(body, &result); err != nil {
 		return nil, err

controller/task_video.go

@@ -81,8 +81,11 @@ func updateVideoSingleTask(ctx context.Context, adaptor channel.TaskAdaptor, cha
 		key = privateData.Key
 	}
 	resp, err := adaptor.FetchTask(baseURL, key, map[string]any{
-		"task_id": taskId,
-		"action":  task.Action,
+		"task_id":             task.GetUpstreamTaskID(),
+		"action":              task.Action,
+		"channel_other":       channel.Other,
+		"origin_model_name":   task.Properties.OriginModelName,
+		"upstream_model_name": task.Properties.UpstreamModelName,
 	}, proxy)
 	if err != nil {
 		return fmt.Errorf("fetchTask failed for task %s: %w", taskId, err)

controller/video_proxy.go

@@ -109,12 +109,27 @@ func VideoProxy(c *gin.Context) {
 	case constant.ChannelTypeOpenAI, constant.ChannelTypeSora:
 		videoURL = fmt.Sprintf("%s/v1/videos/%s/content", baseURL, task.GetUpstreamTaskID())
 		req.Header.Set("Authorization", "Bearer "+channel.Key)
+	case constant.ChannelTypeOpenAIVideo:
+		videoURL = task.GetResultURL()
+		if isHongniaoVideoChannel(baseURL, channel.Other) {
+			req.Header.Set("X-API-Key", channel.Key)
+		}
 	default:
 		// Video URL is stored in PrivateData.ResultURL (fallback to FailReason for old data)
 		videoURL = task.GetResultURL()
 	}
 
 	videoURL = strings.TrimSpace(videoURL)
+	skipSSRFValidation := false
+	if channel.Type == constant.ChannelTypeOpenAIVideo && strings.HasPrefix(videoURL, "runway:") {
+		filePath := strings.TrimSpace(strings.TrimPrefix(videoURL, "runway:"))
+		if !strings.HasPrefix(filePath, "/files/") {
+			videoProxyError(c, http.StatusBadGateway, "server_error", "Invalid Runway file URL")
+			return
+		}
+		videoURL = strings.TrimRight(baseURL, "/") + filePath
+		skipSSRFValidation = true
+	}
 	if videoURL == "" {
 		logger.LogError(c.Request.Context(), fmt.Sprintf("Video URL is empty for task %s", taskID))
 		videoProxyError(c, http.StatusBadGateway, "server_error", "Failed to fetch video content")
@@ -130,10 +145,12 @@ func VideoProxy(c *gin.Context) {
 	}
 
 	fetchSetting := system_setting.GetFetchSetting()
-	if err := common.ValidateURLWithFetchSetting(videoURL, fetchSetting.EnableSSRFProtection, fetchSetting.AllowPrivateIp, fetchSetting.DomainFilterMode, fetchSetting.IpFilterMode, fetchSetting.DomainList, fetchSetting.IpList, fetchSetting.AllowedPorts, fetchSetting.ApplyIPFilterForDomain); err != nil {
-		logger.LogError(c.Request.Context(), fmt.Sprintf("Video URL blocked for task %s: %v", taskID, err))
-		videoProxyError(c, http.StatusForbidden, "server_error", fmt.Sprintf("request blocked: %v", err))
-		return
+	if !skipSSRFValidation {
+		if err := common.ValidateURLWithFetchSetting(videoURL, fetchSetting.EnableSSRFProtection, fetchSetting.AllowPrivateIp, fetchSetting.DomainFilterMode, fetchSetting.IpFilterMode, fetchSetting.DomainList, fetchSetting.IpList, fetchSetting.AllowedPorts, fetchSetting.ApplyIPFilterForDomain); err != nil {
+			logger.LogError(c.Request.Context(), fmt.Sprintf("Video URL blocked for task %s: %v", taskID, err))
+			videoProxyError(c, http.StatusForbidden, "server_error", fmt.Sprintf("request blocked: %v", err))
+			return
+		}
 	}
 
 	req.URL, err = url.Parse(videoURL)
@@ -171,6 +188,15 @@ func VideoProxy(c *gin.Context) {
 	}
 }
 
+func isHongniaoVideoChannel(baseURL, channelOther string) bool {
+	baseURL = strings.ToLower(strings.TrimSpace(baseURL))
+	channelOther = strings.ToLower(strings.TrimSpace(channelOther))
+	return strings.Contains(baseURL, "open.hongniaoai.com") ||
+		strings.Contains(channelOther, "hongniao") ||
+		strings.Contains(channelOther, "xb-sora") ||
+		strings.Contains(channelOther, "xbsora")
+}
+
 func writeVideoDataURL(c *gin.Context, dataURL string) error {
 	parts := strings.SplitN(dataURL, ",", 2)
 	if len(parts) != 2 {