feat: 视频生成接口新增 Seedance（火山 ARK）原生请求/响应兼容入口

common/gin.go

@@ -19,6 +19,7 @@ import (
 
 const KeyRequestBody = "key_request_body"
 const KeyBodyStorage = "key_body_storage"
+const KeySeedanceOfficialAPI = "seedance_official_api"
 
 var ErrRequestBodyTooLarge = errors.New("request body too large")
 

controller/seedance.go

@@ -0,0 +1,24 @@
+package controller
+
+import (
+	"net/http"
+
+	"github.com/QuantumNous/new-api/common"
+	"github.com/QuantumNous/new-api/relay"
+	"github.com/gin-gonic/gin"
+)
+
+func RelaySeedanceTask(c *gin.Context) {
+	c.Set(common.KeySeedanceOfficialAPI, true)
+	RelayTask(c)
+}
+
+func RelaySeedanceTaskFetch(c *gin.Context) {
+	c.Set(common.KeySeedanceOfficialAPI, true)
+	respBody, taskErr := relay.SeedanceTaskFetch(c)
+	if taskErr != nil {
+		respondTaskError(c, taskErr)
+		return
+	}
+	c.Data(http.StatusOK, "application/json", respBody)
+}

middleware/seedance_adapter.go

@@ -0,0 +1,23 @@
+package middleware
+
+import (
+	"net/http"
+
+	"github.com/QuantumNous/new-api/common"
+	relayconstant "github.com/QuantumNous/new-api/relay/constant"
+
+	"github.com/gin-gonic/gin"
+)
+
+func SeedanceRequestConvert() func(c *gin.Context) {
+	return func(c *gin.Context) {
+		c.Set(common.KeySeedanceOfficialAPI, true)
+
+		if c.Request.Method == http.MethodPost {
+			c.Request.URL.Path = "/v1/video/generations"
+			c.Set("relay_mode", relayconstant.RelayModeVideoSubmit)
+		}
+
+		c.Next()
+	}
+}

middleware/seedance_adapter_test.go

@@ -0,0 +1,65 @@
+package middleware
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/QuantumNous/new-api/common"
+	relayconstant "github.com/QuantumNous/new-api/relay/constant"
+	"github.com/gin-gonic/gin"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSeedanceRequestConvertSubmit(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	router := gin.New()
+	router.Use(SeedanceRequestConvert())
+	router.POST("/seedance/api/v3/contents/generations/tasks", func(c *gin.Context) {
+		require.True(t, c.GetBool(common.KeySeedanceOfficialAPI))
+		require.Equal(t, "/v1/video/generations", c.Request.URL.Path)
+		require.Equal(t, relayconstant.RelayModeVideoSubmit, c.GetInt("relay_mode"))
+		c.Status(http.StatusNoContent)
+	})
+
+	req := httptest.NewRequest(http.MethodPost, "/seedance/api/v3/contents/generations/tasks", nil)
+	recorder := httptest.NewRecorder()
+	router.ServeHTTP(recorder, req)
+
+	require.Equal(t, http.StatusNoContent, recorder.Code)
+}
+
+func TestSeedanceRequestConvertFetchByID(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	router := gin.New()
+	router.Use(SeedanceRequestConvert())
+	router.GET("/seedance/api/v3/contents/generations/tasks/:task_id", func(c *gin.Context) {
+		require.True(t, c.GetBool(common.KeySeedanceOfficialAPI))
+		require.Equal(t, "/seedance/api/v3/contents/generations/tasks/task_public", c.Request.URL.Path)
+		require.Equal(t, "task_public", c.Param("task_id"))
+		c.Status(http.StatusNoContent)
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/seedance/api/v3/contents/generations/tasks/task_public", nil)
+	recorder := httptest.NewRecorder()
+	router.ServeHTTP(recorder, req)
+
+	require.Equal(t, http.StatusNoContent, recorder.Code)
+}
+
+func TestSeedanceRequestConvertFetchList(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	router := gin.New()
+	router.Use(SeedanceRequestConvert())
+	router.GET("/seedance/api/v3/contents/generations/tasks", func(c *gin.Context) {
+		require.True(t, c.GetBool(common.KeySeedanceOfficialAPI))
+		require.Equal(t, "/seedance/api/v3/contents/generations/tasks", c.Request.URL.Path)
+		c.Status(http.StatusNoContent)
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/seedance/api/v3/contents/generations/tasks", nil)
+	recorder := httptest.NewRecorder()
+	router.ServeHTTP(recorder, req)
+
+	require.Equal(t, http.StatusNoContent, recorder.Code)
+}

relay/channel/task/doubao/adaptor.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"net/http"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/QuantumNous/new-api/common"
@@ -115,6 +116,29 @@ func (a *TaskAdaptor) Init(info *relaycommon.RelayInfo) {
 
 // ValidateRequestAndSetAction parses body, validates fields and sets default action.
 func (a *TaskAdaptor) ValidateRequestAndSetAction(c *gin.Context, info *relaycommon.RelayInfo) (taskErr *dto.TaskError) {
+	if c.GetBool(common.KeySeedanceOfficialAPI) {
+		var body map[string]interface{}
+		if err := common.UnmarshalBodyReusable(c, &body); err != nil {
+			return service.TaskErrorWrapperLocal(err, "invalid_request", http.StatusBadRequest)
+		}
+
+		modelName, _ := body["model"].(string)
+		if strings.TrimSpace(modelName) == "" {
+			return service.TaskErrorWrapperLocal(fmt.Errorf("field model is required"), "missing_model", http.StatusBadRequest)
+		}
+		if _, ok := body["content"]; !ok {
+			return service.TaskErrorWrapperLocal(fmt.Errorf("field content is required"), "missing_content", http.StatusBadRequest)
+		}
+
+		info.Action = constant.TaskActionGenerate
+		c.Set("task_request", relaycommon.TaskSubmitReq{
+			Model:    modelName,
+			Prompt:   seedanceTextPrompt(body),
+			Metadata: body,
+		})
+		return nil
+	}
+
 	// Accept only POST /v1/video/generations as "generate" action.
 	return relaycommon.ValidateBasicTaskRequest(c, info, constant.TaskActionGenerate)
 }
@@ -177,6 +201,30 @@ func hasVideoInMetadata(metadata map[string]interface{}) bool {
 
 // BuildRequestBody converts request into Doubao specific format.
 func (a *TaskAdaptor) BuildRequestBody(c *gin.Context, info *relaycommon.RelayInfo) (io.Reader, error) {
+	if c.GetBool(common.KeySeedanceOfficialAPI) {
+		storage, err := common.GetBodyStorage(c)
+		if err != nil {
+			return nil, err
+		}
+		cachedBody, err := storage.Bytes()
+		if err != nil {
+			return nil, err
+		}
+
+		var bodyMap map[string]interface{}
+		if err := common.Unmarshal(cachedBody, &bodyMap); err != nil {
+			return bytes.NewReader(cachedBody), nil
+		}
+		if info.UpstreamModelName != "" {
+			bodyMap["model"] = info.UpstreamModelName
+		}
+		data, err := common.Marshal(bodyMap)
+		if err != nil {
+			return nil, err
+		}
+		return bytes.NewReader(data), nil
+	}
+
 	req, err := relaycommon.GetTaskRequest(c)
 	if err != nil {
 		return nil, err
@@ -224,6 +272,13 @@ func (a *TaskAdaptor) DoResponse(c *gin.Context, resp *http.Response, info *rela
 		return
 	}
 
+	if c.GetBool(common.KeySeedanceOfficialAPI) {
+		c.JSON(http.StatusOK, gin.H{
+			"id": dResp.ID,
+		})
+		return dResp.ID, responseBody, nil
+	}
+
 	ov := dto.NewOpenAIVideo()
 	ov.ID = info.PublicTaskID
 	ov.TaskID = info.PublicTaskID
@@ -303,6 +358,27 @@ func (a *TaskAdaptor) convertToRequestPayload(req *relaycommon.TaskSubmitReq) (*
 	return &r, nil
 }
 
+func seedanceTextPrompt(body map[string]interface{}) string {
+	content, ok := body["content"].([]interface{})
+	if !ok {
+		return ""
+	}
+	for _, item := range content {
+		itemMap, ok := item.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		if itemMap["type"] != "text" {
+			continue
+		}
+		text, _ := itemMap["text"].(string)
+		if strings.TrimSpace(text) != "" {
+			return text
+		}
+	}
+	return ""
+}
+
 func (a *TaskAdaptor) ParseTaskResult(respBody []byte) (*relaycommon.TaskInfo, error) {
 	resTask := responseTask{}
 	if err := common.Unmarshal(respBody, &resTask); err != nil {
@@ -332,6 +408,10 @@ func (a *TaskAdaptor) ParseTaskResult(respBody []byte) (*relaycommon.TaskInfo, e
 		taskResult.Status = model.TaskStatusFailure
 		taskResult.Progress = "100%"
 		taskResult.Reason = resTask.Error.Message
+	case "expired", "cancelled":
+		taskResult.Status = model.TaskStatusFailure
+		taskResult.Progress = "100%"
+		taskResult.Reason = resTask.Status
 	default:
 		// Unknown status, treat as processing
 		taskResult.Status = model.TaskStatusInProgress

relay/channel/task/doubao/adaptor_test.go

@@ -0,0 +1,78 @@
+package doubao
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/QuantumNous/new-api/common"
+	relaycommon "github.com/QuantumNous/new-api/relay/common"
+	"github.com/gin-gonic/gin"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSeedanceOfficialBuildRequestBodyPreservesNativeContent(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	recorder := httptest.NewRecorder()
+	ctx, _ := gin.CreateTestContext(recorder)
+	ctx.Set(common.KeySeedanceOfficialAPI, true)
+	ctx.Request = httptest.NewRequest(http.MethodPost, "/seedance/api/v3/contents/generations/tasks", bytes.NewBufferString(`{
+		"model":"doubao-seedance-1-5-pro",
+		"content":[
+			{"type":"image_url","image_url":{"url":"https://example.com/a.png"},"role":"first_frame"},
+			{"type":"text","text":"make a video"}
+		],
+		"duration":5,
+		"watermark":false
+	}`))
+	ctx.Request.Header.Set("Content-Type", "application/json")
+
+	adaptor := &TaskAdaptor{}
+	info := &relaycommon.RelayInfo{
+		ChannelMeta: &relaycommon.ChannelMeta{UpstreamModelName: "upstream-seedance-model"},
+	}
+
+	body, err := adaptor.BuildRequestBody(ctx, info)
+	require.NoError(t, err)
+
+	raw, err := io.ReadAll(body)
+	require.NoError(t, err)
+
+	var payload map[string]any
+	require.NoError(t, common.Unmarshal(raw, &payload))
+	assert.Equal(t, "upstream-seedance-model", payload["model"])
+	assert.Equal(t, float64(5), payload["duration"])
+	assert.Equal(t, false, payload["watermark"])
+
+	content, ok := payload["content"].([]any)
+	require.True(t, ok)
+	require.Len(t, content, 2)
+	first, ok := content[0].(map[string]any)
+	require.True(t, ok)
+	assert.Equal(t, "image_url", first["type"])
+	assert.Equal(t, "first_frame", first["role"])
+}
+
+func TestSeedanceOfficialDoResponseReturnsUpstreamTaskID(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	recorder := httptest.NewRecorder()
+	ctx, _ := gin.CreateTestContext(recorder)
+	ctx.Set(common.KeySeedanceOfficialAPI, true)
+
+	adaptor := &TaskAdaptor{}
+	resp := &http.Response{
+		Body: io.NopCloser(bytes.NewBufferString(`{"id":"cgt-upstream"}`)),
+	}
+	info := &relaycommon.RelayInfo{
+		TaskRelayInfo: &relaycommon.TaskRelayInfo{PublicTaskID: "task_public"},
+	}
+
+	taskID, taskData, taskErr := adaptor.DoResponse(ctx, resp, info)
+	require.Nil(t, taskErr)
+	assert.Equal(t, "cgt-upstream", taskID)
+	assert.JSONEq(t, `{"id":"cgt-upstream"}`, string(taskData))
+	assert.JSONEq(t, `{"id":"cgt-upstream"}`, recorder.Body.String())
+}

relay/relay_task_seedance_test.go

@@ -0,0 +1,54 @@
+package relay
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/QuantumNous/new-api/model"
+	"github.com/gin-gonic/gin"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSeedanceTaskIDFilters(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	recorder := httptest.NewRecorder()
+	ctx, _ := gin.CreateTestContext(recorder)
+	ctx.Request = httptest.NewRequest(
+		http.MethodGet,
+		"/seedance/api/v3/contents/generations/tasks?filter.task_ids=cgt-a,cgt-b&filter.task_ids=task_c&filter.task_ids[]=cgt-d",
+		nil,
+	)
+
+	require.Equal(t, []string{"cgt-a", "cgt-b", "task_c", "cgt-d"}, seedanceTaskIDFilters(ctx))
+}
+
+func TestSeedanceTaskResponseUsesUpstreamShape(t *testing.T) {
+	task := &model.Task{
+		TaskID:     "task_public",
+		Status:     model.TaskStatusSuccess,
+		SubmitTime: 1710000000,
+		UpdatedAt:  1710000100,
+		Properties: model.Properties{
+			OriginModelName: "doubao-seedance-1-5-pro",
+		},
+		PrivateData: model.TaskPrivateData{
+			UpstreamTaskID: "cgt-upstream",
+			ResultURL:      "https://example.com/video.mp4",
+		},
+		Data: json.RawMessage(`{"id":"cgt-upstream","status":"running","content":{},"service_tier":"default"}`),
+	}
+
+	resp := seedanceTaskResponse(task)
+	assert.Equal(t, "cgt-upstream", resp["id"])
+	assert.Equal(t, "doubao-seedance-1-5-pro", resp["model"])
+	assert.Equal(t, "succeeded", resp["status"])
+	assert.Equal(t, int64(1710000000), resp["created_at"])
+	assert.Equal(t, int64(1710000100), resp["updated_at"])
+
+	content, ok := resp["content"].(map[string]any)
+	require.True(t, ok)
+	assert.Equal(t, "https://example.com/video.mp4", content["video_url"])
+}