feat: add ark seedance video generation

.env.example

@@ -9,6 +9,10 @@ JWT_EXPIRE_HOURS=168
 # 后端监听端口
 PORT=8080
 
+# 公开访问地址，用于把本地上传的 Seedance 参考图/视频暴露给火山方舟拉取。
+# 线上部署时填写站点根地址，例如：https://your-domain.example.com
+# PUBLIC_BASE_URL=https://your-domain.example.com
+
 # 前端开发代理默认使用 http://127.0.0.1:8080，如后端开发端口不同，启动前端时可单独设置 API_BASE_URL。
 # API_BASE_URL=http://127.0.0.1:8080
 

config/config.go

@@ -17,6 +17,7 @@ type Config struct {
 	JWTExpireHours      int    `env:"JWT_EXPIRE_HOURS" envDefault:"168"`
 	StorageDriver       string `env:"STORAGE_DRIVER" envDefault:"sqlite"`
 	DatabaseDSN         string `env:"DATABASE_DSN" envDefault:"data/infinite-canvas.db"`
+	PublicBaseURL       string `env:"PUBLIC_BASE_URL"`
 	LinuxDoAuthorizeURL string `env:"LINUX_DO_AUTHORIZE_URL" envDefault:"https://connect.linux.do/oauth2/authorize"`
 	LinuxDoTokenURL     string `env:"LINUX_DO_TOKEN_URL" envDefault:"https://connect.linux.do/oauth2/token"`
 	LinuxDoUserInfoURL  string `env:"LINUX_DO_USERINFO_URL" envDefault:"https://connect.linux.do/api/user"`

handler/ai.go

@@ -49,6 +49,7 @@ func proxyAIGetRequest(w http.ResponseWriter, r *http.Request, path string) {
 		Fail(w, "AI 接口请求失败")
 		return
 	}
+	path = resolveAIProxyPath(channel.BaseURL, modelName, path)
 	request, err := http.NewRequest(http.MethodGet, service.BuildModelChannelURL(channel, path), nil)
 	if err != nil {
 		Fail(w, "AI 接口请求失败")
@@ -83,6 +84,7 @@ func proxyAIRequest(w http.ResponseWriter, r *http.Request, path string) {
 		Fail(w, "AI 接口请求失败")
 		return
 	}
+	path = resolveAIProxyPath(channel.BaseURL, modelName, path)
 	request, err := http.NewRequest(http.MethodPost, service.BuildModelChannelURL(channel, path), bytes.NewReader(body))
 	if err != nil {
 		log.Printf("AI proxy build request failed: url=%s err=%v", service.BuildModelChannelURL(channel, path), err)
@@ -117,12 +119,12 @@ func copyAIResponse(w http.ResponseWriter, request *http.Request, onFailure func
 	defer response.Body.Close()
 
 	if response.StatusCode >= http.StatusBadRequest {
-		payload, _ := io.ReadAll(io.LimitReader(response.Body, 4096))
+		_, _ = io.Copy(io.Discard, io.LimitReader(response.Body, 4096))
-		log.Printf("AI upstream error: url=%s status=%d body=%s", request.URL.String(), response.StatusCode, strings.TrimSpace(string(payload)))
+		log.Printf("AI upstream error: url=%s status=%d", request.URL.String(), response.StatusCode)
 		if onFailure != nil {
 			onFailure()
 		}
-		Fail(w, "AI 接口请求失败")
+		Fail(w, aiStatusMessage(response.StatusCode))
 		return
 	}
 
@@ -207,6 +209,36 @@ func readAIRequestCount(body []byte, contentType string) int {
 
 var errMissingModel = &aiError{"缺少模型名称"}
 
+func resolveAIProxyPath(baseURL string, modelName string, path string) string {
+	if !isArkSeedanceVideo(baseURL, modelName) {
+		return path
+	}
+	if path == "/videos" {
+		return "/contents/generations/tasks"
+	}
+	if strings.HasPrefix(path, "/videos/") && !strings.HasSuffix(path, "/content") {
+		return "/contents/generations/tasks/" + strings.TrimPrefix(path, "/videos/")
+	}
+	return path
+}
+
+func isArkSeedanceVideo(baseURL string, modelName string) bool {
+	base := strings.ToLower(baseURL)
+	model := strings.ToLower(modelName)
+	return strings.Contains(model, "seedance") || strings.Contains(model, "doubao-seedance") || strings.Contains(base, "/api/plan/v3")
+}
+
+func aiStatusMessage(statusCode int) string {
+	switch statusCode {
+	case http.StatusUnauthorized, http.StatusForbidden:
+		return "AI 接口鉴权失败，请检查 API Key、套餐权限或模型权限"
+	case http.StatusTooManyRequests:
+		return "AI 接口限流或额度不足，请稍后重试或检查额度"
+	default:
+		return "AI 接口请求失败"
+	}
+}
+
 type aiError struct {
 	message string
 }

handler/media_reference.go

@@ -0,0 +1,172 @@
+package handler
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/basketikun/infinite-canvas/config"
+	"github.com/google/uuid"
+)
+
+const referenceMediaMaxBytes = 80 << 20
+
+type referenceMediaUploadResult struct {
+	ID       string `json:"id"`
+	URL      string `json:"url"`
+	MimeType string `json:"mimeType"`
+	Bytes    int64  `json:"bytes"`
+}
+
+func UploadReferenceMedia(w http.ResponseWriter, r *http.Request) {
+	publicBaseURL := strings.TrimRight(strings.TrimSpace(config.Cfg.PublicBaseURL), "/")
+	if publicBaseURL == "" {
+		Fail(w, "未配置 PUBLIC_BASE_URL，无法把本地参考视频提供给火山方舟访问")
+		return
+	}
+	r.Body = http.MaxBytesReader(w, r.Body, referenceMediaMaxBytes+1)
+	if err := r.ParseMultipartForm(referenceMediaMaxBytes); err != nil {
+		Fail(w, "参考素材过大或上传格式不正确")
+		return
+	}
+	if r.MultipartForm != nil {
+		defer r.MultipartForm.RemoveAll()
+	}
+	file, header, err := r.FormFile("file")
+	if err != nil {
+		Fail(w, "请上传参考图片或视频")
+		return
+	}
+	defer file.Close()
+
+	mimeType, ext, ok := normalizeReferenceMediaType(header.Header.Get("Content-Type"), filepath.Ext(header.Filename))
+	if !ok {
+		Fail(w, "参考素材格式不支持，请使用 jpeg/png/webp/bmp/gif/heic/heif 图片或 mp4/mov 视频")
+		return
+	}
+	if err := os.MkdirAll(referenceMediaDir(), 0o755); err != nil {
+		Fail(w, "参考素材保存失败")
+		return
+	}
+	id := uuid.NewString() + ext
+	targetPath := filepath.Join(referenceMediaDir(), id)
+	target, err := os.OpenFile(targetPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o644)
+	if err != nil {
+		Fail(w, "参考素材保存失败")
+		return
+	}
+	bytes, copyErr := io.Copy(target, file)
+	closeErr := target.Close()
+	if copyErr != nil || closeErr != nil {
+		_ = os.Remove(targetPath)
+		Fail(w, "参考素材保存失败")
+		return
+	}
+	if bytes <= 0 || bytes > referenceMediaMaxBytes {
+		_ = os.Remove(targetPath)
+		Fail(w, "参考素材为空或超过大小限制")
+		return
+	}
+	OK(w, referenceMediaUploadResult{
+		ID:       id,
+		URL:      fmt.Sprintf("%s/api/media/references/%s", publicBaseURL, id),
+		MimeType: mimeType,
+		Bytes:    bytes,
+	})
+}
+
+func ReferenceMedia(w http.ResponseWriter, r *http.Request, id string) {
+	if id == "" || id != filepath.Base(id) || strings.Contains(id, "..") {
+		http.NotFound(w, r)
+		return
+	}
+	path := filepath.Join(referenceMediaDir(), id)
+	file, err := os.Open(path)
+	if err != nil {
+		http.NotFound(w, r)
+		return
+	}
+	defer file.Close()
+	info, err := file.Stat()
+	if err != nil || info.IsDir() {
+		http.NotFound(w, r)
+		return
+	}
+	if mimeType := mimeTypeByReferenceMediaExt(filepath.Ext(id)); mimeType != "" {
+		w.Header().Set("Content-Type", mimeType)
+	}
+	w.Header().Set("Cache-Control", "public, max-age=86400")
+	http.ServeContent(w, r, id, info.ModTime(), file)
+}
+
+func referenceMediaDir() string {
+	return filepath.Join("data", "reference-media")
+}
+
+func normalizeReferenceMediaType(contentType string, ext string) (string, string, bool) {
+	contentType = strings.ToLower(strings.TrimSpace(strings.Split(contentType, ";")[0]))
+	ext = strings.ToLower(strings.TrimSpace(ext))
+	if contentType == "" || contentType == "application/octet-stream" {
+		contentType = mimeTypeByReferenceMediaExt(ext)
+	}
+	if fixedExt := referenceMediaExtByMimeType(contentType); fixedExt != "" {
+		return contentType, fixedExt, true
+	}
+	if mimeType := mimeTypeByReferenceMediaExt(ext); mimeType != "" {
+		return mimeType, ext, true
+	}
+	return "", "", false
+}
+
+func referenceMediaExtByMimeType(mimeType string) string {
+	switch strings.ToLower(mimeType) {
+	case "image/jpeg", "image/jpg":
+		return ".jpg"
+	case "image/png":
+		return ".png"
+	case "image/webp":
+		return ".webp"
+	case "image/bmp":
+		return ".bmp"
+	case "image/gif":
+		return ".gif"
+	case "image/heic":
+		return ".heic"
+	case "image/heif":
+		return ".heif"
+	case "video/mp4":
+		return ".mp4"
+	case "video/quicktime", "video/mov":
+		return ".mov"
+	default:
+		return ""
+	}
+}
+
+func mimeTypeByReferenceMediaExt(ext string) string {
+	switch strings.ToLower(ext) {
+	case ".jpg", ".jpeg":
+		return "image/jpeg"
+	case ".png":
+		return "image/png"
+	case ".webp":
+		return "image/webp"
+	case ".bmp":
+		return "image/bmp"
+	case ".gif":
+		return "image/gif"
+	case ".heic":
+		return "image/heic"
+	case ".heif":
+		return "image/heif"
+	case ".mp4":
+		return "video/mp4"
+	case ".mov":
+		return "video/quicktime"
+	default:
+		return ""
+	}
+}

router/router.go

@@ -22,11 +22,15 @@ func New() *gin.Engine {
 	api.GET("/auth/linux-do/callback", gin.WrapF(handler.LinuxDoCallback))
 	api.GET("/auth/me", middleware.OptionalAuth, gin.WrapF(handler.CurrentUser))
 	api.GET("/settings", gin.WrapF(handler.Settings))
+	api.GET("/media/references/:id", func(c *gin.Context) {
+		handler.ReferenceMedia(c.Writer, c.Request, c.Param("id"))
+	})
 	v1 := api.Group("/v1", middleware.UserAuth)
 	v1.POST("/images/generations", gin.WrapF(handler.AIImagesGenerations))
 	v1.POST("/images/edits", gin.WrapF(handler.AIImagesEdits))
 	v1.POST("/chat/completions", gin.WrapF(handler.AIChatCompletions))
 	v1.POST("/videos", gin.WrapF(handler.AIVideos))
+	v1.POST("/media/references", gin.WrapF(handler.UploadReferenceMedia))
 	v1.GET("/videos/:id", func(c *gin.Context) {
 		handler.AIVideo(c.Writer, c.Request, c.Param("id"))
 	})

service/settings.go

@@ -180,7 +180,7 @@ func SelectModelChannel(modelName string) (model.ModelChannel, error) {
 
 func BuildModelChannelURL(channel model.ModelChannel, path string) string {
 	baseURL := strings.TrimRight(channel.BaseURL, "/")
-	if !strings.HasSuffix(baseURL, "/v1") {
+	if !strings.HasSuffix(baseURL, "/v1") && !strings.HasSuffix(baseURL, "/api/v3") && !strings.HasSuffix(baseURL, "/api/plan/v3") {
 		baseURL += "/v1"
 	}
 	return baseURL + path

web/src/services/api/image.ts

@@ -100,11 +100,17 @@ function parseImagePayload(payload: ImageApiResponse) {
 function readAxiosError(error: unknown, fallback: string) {
     if (axios.isAxiosError<{ error?: { message?: string }; msg?: string; code?: number }>(error)) {
         const responseData = error.response?.data;
-        return responseData?.msg || responseData?.error?.message || (error.response?.status ? `${fallback}：${error.response.status}` : fallback);
+        return responseData?.msg || responseData?.error?.message || readStatusError(error.response?.status, fallback);
     }
     return error instanceof Error ? error.message : fallback;
 }
 
+function readStatusError(status: number | undefined, fallback: string) {
+    if (status === 401 || status === 403) return "鉴权失败，请检查 API Key、套餐权限或模型权限";
+    if (status === 429) return "请求被限流或额度不足，请稍后重试";
+    return status ? `${fallback}：${status}` : fallback;
+}
+
 function parseStreamChunk(chunk: string, onDelta: (value: string) => void) {
     let deltaText = "";
     for (const eventBlock of chunk.split("\n\n")) {

web/src/services/api/video.ts

@@ -1,29 +1,66 @@
 import axios from "axios";
 
 import { dataUrlToFile } from "@/lib/image-utils";
+import { getMediaBlob, uploadMediaFile, type UploadedFile } from "@/services/file-storage";
 import { imageToDataUrl } from "@/services/image-storage";
 import { buildApiUrl, type AiConfig } from "@/stores/use-config-store";
 import { useUserStore } from "@/stores/use-user-store";
 import type { ReferenceImage } from "@/types/image";
+import type { ReferenceVideo } from "@/types/media";
 
 type VideoResponse = { id: string; status?: string; error?: { message?: string } };
 type ApiVideoResponse = VideoResponse | { code?: number; data?: VideoResponse | null; msg?: string };
+type SeedanceTask = {
+    id: string;
+    status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | "expired";
+    error?: { code?: string; message?: string } | null;
+    content?: { video_url?: string; last_frame_url?: string } | null;
+};
+type ApiEnvelope<T> = T | { code?: number; data?: T | null; msg?: string };
+type ReferenceMediaUploadResponse = { id: string; url: string; mimeType: string; bytes: number };
+
+export type VideoGenerationResult = { blob?: Blob; url?: string; mimeType?: string };
 
 function aiApiUrl(config: AiConfig, path: string) {
     return config.channelMode === "remote" ? `/api/v1${path}` : buildApiUrl(config.baseUrl, path);
 }
 
-function aiHeaders(config: AiConfig) {
+function aiHeaders(config: AiConfig, contentType?: string) {
     const token = useUserStore.getState().token;
-    return config.channelMode === "remote" ? (token ? { Authorization: `Bearer ${token}` } : undefined) : { Authorization: `Bearer ${config.apiKey}` };
+    return config.channelMode === "remote"
+        ? {
+              ...(token ? { Authorization: `Bearer ${token}` } : {}),
+              ...(contentType ? { "Content-Type": contentType } : {}),
+          }
+        : {
+              Authorization: `Bearer ${config.apiKey}`,
+              ...(contentType ? { "Content-Type": contentType } : {}),
+          };
 }
 
 function refreshRemoteUser(config: AiConfig) {
     if (config.channelMode === "remote") void useUserStore.getState().hydrateUser();
 }
 
-export async function requestVideoGeneration(config: AiConfig, prompt: string, references: ReferenceImage[] = []) {
+export async function requestVideoGeneration(config: AiConfig, prompt: string, references: ReferenceImage[] = [], videoReferences: ReferenceVideo[] = []): Promise<VideoGenerationResult> {
-    const model = config.model || config.videoModel;
+    const model = (config.model || config.videoModel).trim();
+    assertVideoConfig(config, model);
+    if (isSeedanceConfig(config, model)) {
+        return requestSeedanceGeneration(config, model, prompt, references, videoReferences);
+    }
+    if (videoReferences.length) {
+        throw new Error("当前视频接口不支持参考视频，请切换到 Seedance 2.0 / 火山 Agent Plan 模型，或移除参考视频");
+    }
+    return requestOpenAIVideoGeneration(config, model, prompt, references);
+}
+
+export async function storeGeneratedVideo(result: VideoGenerationResult): Promise<UploadedFile> {
+    if (result.blob) return uploadMediaFile(result.blob, "video");
+    if (result.url) return { url: result.url, storageKey: "", bytes: 0, mimeType: result.mimeType || "video/mp4" };
+    throw new Error("视频接口没有返回可播放的视频");
+}
+
+async function requestOpenAIVideoGeneration(config: AiConfig, model: string, prompt: string, references: ReferenceImage[]) {
     const body = new FormData();
     body.append("model", model);
     body.append("prompt", prompt);
@@ -36,26 +73,136 @@ export async function requestVideoGeneration(config: AiConfig, prompt: string, r
     try {
         const created = unwrapVideoResponse((await axios.post<ApiVideoResponse>(aiApiUrl(config, "/videos"), body, { headers: aiHeaders(config) })).data);
         if (!created.id) throw new Error("视频接口没有返回任务 ID");
-        for (;;) {
+        for (let attempt = 0; attempt < 120; attempt += 1) {
             const video = unwrapVideoResponse((await axios.get<ApiVideoResponse>(aiApiUrl(config, `/videos/${created.id}`), { headers: aiHeaders(config), params: config.channelMode === "remote" ? { model } : undefined })).data);
             if (video.status === "completed") break;
             if (video.status === "failed" || video.status === "cancelled") throw new Error(video.error?.message || "视频生成失败");
-            await new Promise((resolve) => setTimeout(resolve, 2500));
+            if (attempt === 119) throw new Error("视频生成超时，请稍后重试");
+            await delay(2500);
         }
         const content = await axios.get<Blob>(aiApiUrl(config, `/videos/${created.id}/content`), { headers: aiHeaders(config), params: config.channelMode === "remote" ? { model } : undefined, responseType: "blob" });
         await assertVideoBlob(content.data);
         refreshRemoteUser(config);
-        return content.data;
+        return { blob: content.data };
     } catch (error) {
         throw new Error(readAxiosError(error, "视频生成失败"));
     }
 }
 
+async function requestSeedanceGeneration(config: AiConfig, model: string, prompt: string, references: ReferenceImage[], videoReferences: ReferenceVideo[]) {
+    const content = await buildSeedanceContent(config, prompt, references, videoReferences);
+    if (!content.length) throw new Error("请输入视频提示词，或连接参考图片/视频");
+    const payload = {
+        model,
+        content,
+        ratio: normalizeSeedanceRatio(config.size),
+        resolution: normalizeVideoResolution(config.vquality),
+        duration: normalizeSeedanceDuration(config.videoSeconds),
+        watermark: false,
+    };
+
+    try {
+        const created = unwrapSeedanceTask((await axios.post<ApiEnvelope<SeedanceTask>>(seedanceApiUrl(config), payload, { headers: aiHeaders(config, "application/json") })).data);
+        if (!created.id) throw new Error("Seedance 接口没有返回任务 ID");
+        for (let attempt = 0; attempt < 120; attempt += 1) {
+            const task = unwrapSeedanceTask((await axios.get<ApiEnvelope<SeedanceTask>>(seedanceApiUrl(config, created.id), { headers: aiHeaders(config), params: config.channelMode === "remote" ? { model } : undefined })).data);
+            if (task.status === "succeeded") {
+                const url = task.content?.video_url;
+                if (!url) throw new Error("Seedance 任务成功但没有返回视频 URL");
+                refreshRemoteUser(config);
+                return videoResultFromUrl(url);
+            }
+            if (task.status === "failed" || task.status === "cancelled" || task.status === "expired") throw new Error(task.error?.message || `Seedance 视频生成${task.status === "expired" ? "超时" : "失败"}`);
+            if (attempt === 119) throw new Error("Seedance 视频生成超时，请稍后重试");
+            await delay(5000);
+        }
+        throw new Error("Seedance 视频生成超时，请稍后重试");
+    } catch (error) {
+        throw new Error(readAxiosError(error, "Seedance 视频生成失败"));
+    }
+}
+
+function seedanceApiUrl(config: AiConfig, taskId?: string) {
+    if (config.channelMode === "remote") return taskId ? `/api/v1/videos/${encodeURIComponent(taskId)}` : "/api/v1/videos";
+    return buildApiUrl(config.baseUrl, `/contents/generations/tasks${taskId ? `/${encodeURIComponent(taskId)}` : ""}`);
+}
+
+async function buildSeedanceContent(config: AiConfig, prompt: string, references: ReferenceImage[], videoReferences: ReferenceVideo[]) {
+    const content: Array<Record<string, unknown>> = [];
+    const text = prompt.trim();
+    if (text) content.push({ type: "text", text });
+    for (const image of references.slice(0, 7)) {
+        content.push({ type: "image_url", image_url: { url: await resolveSeedanceImageUrl(config, image) }, role: "reference_image" });
+    }
+    for (const video of videoReferences.slice(0, 3)) {
+        content.push({ type: "video_url", video_url: { url: await resolveSeedanceVideoUrl(video) }, role: "reference_video" });
+    }
+    return content;
+}
+
+async function resolveSeedanceImageUrl(config: AiConfig, image: ReferenceImage) {
+    const directUrl = image.url || image.dataUrl;
+    if (isPublicMediaUrl(directUrl) || directUrl.startsWith("asset://")) return directUrl;
+    const dataUrl = await imageToDataUrl(image);
+    if (!dataUrl) throw new Error("参考图读取失败，请换一张图片或重新上传");
+    if (config.channelMode === "remote") {
+        return uploadReferenceMedia(dataUrlToFile({ ...image, dataUrl }));
+    }
+    return dataUrl;
+}
+
+async function resolveSeedanceVideoUrl(video: ReferenceVideo) {
+    if (isPublicMediaUrl(video.url) || video.url.startsWith("asset://")) return video.url;
+    let blob: Blob | null = null;
+    if (video.storageKey) blob = await getMediaBlob(video.storageKey);
+    if (!blob && video.url?.startsWith("blob:")) blob = await (await fetch(video.url)).blob();
+    if (!blob) throw new Error("参考视频必须是公网 URL、素材 ID，或本地已保存的视频");
+    const file = new File([blob], video.name || "reference-video.mp4", { type: video.type || blob.type || "video/mp4" });
+    return uploadReferenceMedia(file);
+}
+
+async function uploadReferenceMedia(file: File) {
+    const token = useUserStore.getState().token;
+    if (!token) throw new Error("使用本地参考素材需要先登录，并在服务端配置 PUBLIC_BASE_URL");
+    const body = new FormData();
+    body.append("file", file, file.name);
+    const response = await axios.post<ApiEnvelope<ReferenceMediaUploadResponse>>("/api/v1/media/references", body, { headers: { Authorization: `Bearer ${token}` } });
+    const payload = unwrapEnvelope(response.data, "参考素材上传失败");
+    if (!payload.url) throw new Error("参考素材上传后没有返回公网 URL");
+    return payload.url;
+}
+
+async function videoResultFromUrl(url: string): Promise<VideoGenerationResult> {
+    try {
+        const response = await axios.get<Blob>(url, { responseType: "blob" });
+        await assertVideoBlob(response.data);
+        return { blob: response.data };
+    } catch {
+        return { url, mimeType: "video/mp4" };
+    }
+}
+
+function isSeedanceConfig(config: AiConfig, model: string) {
+    const value = `${model} ${config.baseUrl}`.toLowerCase();
+    return value.includes("seedance") || value.includes("doubao-seedance") || value.includes("ark.cn-beijing.volces.com/api/plan/v3");
+}
+
+function assertVideoConfig(config: AiConfig, model: string) {
+    if (!model) throw new Error("请先配置视频模型");
+    if (config.channelMode === "local" && !config.baseUrl.trim()) throw new Error("请先配置 Base URL");
+    if (config.channelMode === "local" && !config.apiKey.trim()) throw new Error("请先配置 API Key");
+}
+
 function normalizeVideoSeconds(value: string) {
     const seconds = Math.floor(Number(value) || 6);
     return String(Math.max(1, Math.min(20, seconds)));
 }
 
+function normalizeSeedanceDuration(value: string) {
+    const seconds = Math.floor(Number(value) || 5);
+    return Math.max(4, Math.min(15, seconds));
+}
+
 function normalizeVideoSize(value: string) {
     if (value === "auto") return null;
     const size = value || "1280x720";
@@ -63,6 +210,26 @@ function normalizeVideoSize(value: string) {
     return ["9:16", "2:3", "3:4"].includes(size) ? "720x1280" : "1280x720";
 }
 
+function normalizeSeedanceRatio(value: string) {
+    if (!value || value === "auto") return "adaptive";
+    if (["16:9", "4:3", "1:1", "3:4", "9:16", "21:9", "adaptive"].includes(value)) return value;
+    const match = value.match(/^(\d+)x(\d+)$/);
+    if (!match) return "adaptive";
+    const width = Number(match[1]);
+    const height = Number(match[2]);
+    if (!width || !height) return "adaptive";
+    const ratio = width / height;
+    const options = [
+        ["16:9", 16 / 9],
+        ["4:3", 4 / 3],
+        ["1:1", 1],
+        ["3:4", 3 / 4],
+        ["9:16", 9 / 16],
+        ["21:9", 21 / 9],
+    ] as const;
+    return options.reduce((best, item) => (Math.abs(item[1] - ratio) < Math.abs(best[1] - ratio) ? item : best), options[0])[0];
+}
+
 function normalizeVideoResolution(value: string) {
     if (value === "low") return "480p";
     if (value === "auto" || value === "high" || value === "medium") return "720p";
@@ -71,30 +238,53 @@ function normalizeVideoResolution(value: string) {
 }
 
 function unwrapVideoResponse(payload: ApiVideoResponse) {
-    if (!payload) throw new Error("接口没有返回视频任务");
+    return unwrapEnvelope(payload, "接口没有返回视频任务");
-    if ("code" in payload && typeof payload.code === "number") {
+}
+
+function unwrapSeedanceTask(payload: ApiEnvelope<SeedanceTask>) {
+    return unwrapEnvelope(payload, "Seedance 接口没有返回任务");
+}
+
+function unwrapEnvelope<T>(payload: ApiEnvelope<T>, emptyMessage: string): T {
+    if (!payload) throw new Error(emptyMessage);
+    if (typeof payload === "object" && "code" in payload && typeof payload.code === "number") {
         if (payload.code !== 0) throw new Error(payload.msg || "请求失败");
-        if (!payload.data) throw new Error("接口没有返回视频任务");
+        if (!payload.data) throw new Error(emptyMessage);
         return payload.data;
     }
-    return payload;
+    return payload as T;
 }
 
 function readAxiosError(error: unknown, fallback: string) {
     if (axios.isAxiosError<{ error?: { message?: string }; msg?: string; code?: number }>(error)) {
         const responseData = error.response?.data;
-        return responseData?.msg || responseData?.error?.message || (error.response?.status ? `${fallback}：${error.response.status}` : fallback);
+        return responseData?.msg || responseData?.error?.message || statusMessage(error.response?.status, fallback);
     }
     return error instanceof Error ? error.message : fallback;
 }
 
+function statusMessage(status: number | undefined, fallback: string) {
+    if (status === 401 || status === 403) return "鉴权失败，请检查 API Key、套餐权限或模型权限";
+    if (status === 429) return "请求被限流或额度不足，请稍后重试";
+    return status ? `${fallback}（${status}）` : fallback;
+}
+
 async function assertVideoBlob(blob: Blob) {
     if (!blob.type.includes("json")) return;
-    let payload: { code?: number; msg?: string };
+    let payload: { code?: number; msg?: string; error?: { message?: string } };
     try {
-        payload = JSON.parse(await blob.text()) as { code?: number; msg?: string };
+        payload = JSON.parse(await blob.text()) as { code?: number; msg?: string; error?: { message?: string } };
     } catch {
         return;
     }
     if (typeof payload.code === "number" && payload.code !== 0) throw new Error(payload.msg || "视频下载失败");
+    if (payload.error?.message) throw new Error(payload.error.message);
+}
+
+function isPublicMediaUrl(value: string) {
+    return /^https?:\/\//i.test(value || "");
+}
+
+function delay(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }

web/src/stores/use-config-store.ts

@@ -126,6 +126,6 @@ export function useEffectiveConfig() {
 
 export function buildApiUrl(baseUrl: string, path: string) {
     const normalizedBaseUrl = baseUrl.trim().replace(/\/+$/, "");
-    const apiBaseUrl = normalizedBaseUrl.endsWith("/v1") ? normalizedBaseUrl : `${normalizedBaseUrl}/v1`;
+    const apiBaseUrl = normalizedBaseUrl.endsWith("/v1") || normalizedBaseUrl.endsWith("/api/v3") || normalizedBaseUrl.endsWith("/api/plan/v3") ? normalizedBaseUrl : `${normalizedBaseUrl}/v1`;
     return `${apiBaseUrl}${path}`;
 }

web/src/types/media.ts

@@ -0,0 +1,7 @@
+export type ReferenceVideo = {
+    id: string;
+    name: string;
+    type: string;
+    url: string;
+    storageKey?: string;
+};