@pippit-dev/cli 1.0.14 → 1.0.16

package/README.md

@@ -273,6 +273,49 @@ pippit-tool-cli generate-video \
 
 命令输出 `thread_id`、`run_id` 和 `web_thread_link`。提交生视频 HTTP 请求时，参考图、参考视频和参考音频会使用上传接口返回的 `pippit_asset_id`，并分别写入 `video_part_tool_param.images`、`video_part_tool_param.videos` 和 `video_part_tool_param.audios`。图片最多 9 张，支持 `.jpg`、`.jpeg`、`.png`、`.gif`、`.bmp`、`.webp`、`.svg`；视频最多 3 个，支持 `.mp4`、`.avi`、`.mov`、`.wmv`、`.flv`、`.webm`、`.mkv`、`.m4v`；音频最多 3 个，仅支持 `.mp3`、`.wav`。普通用户支持模型 `Seedance_2.0_mini_lite`；`seedance2.0_vision`、`seedance2.0_fast_vision` 和 `Seedance_2.0_mini` 为 VIP 专属模型。CLI 会在提交前校验 prompt、素材数量和文件后缀；模型、比例、分辨率等语义校验由服务端处理。
 
+首尾帧生视频时，按首帧、尾帧的顺序传入两次 `--image`，并设置 `--generate-type 1`：
+
+```bash
+pippit-tool-cli generate-video \
+  --prompt "让镜头从首帧平滑过渡到尾帧" \
+  --image "~/images/first.jpg" \
+  --image "~/images/last.jpg" \
+  --duration 5 \
+  --ratio "16:9" \
+  --model "Seedance_2.0_mini" \
+  --resolution "720p" \
+  --generate-type 1
+```
+
+`--generate-type` 可选，填写后原样写入 `video_part_tool_param.generate_type`；值 `1` 表示首尾帧生成。CLI 保持图片上传和请求中的输入顺序，不在本地校验该参数的枚举值，具体能力与约束由服务端决定。
+
+## 视频处理工具 CLI
+
+`video-super-resolution` 会上传一个本地视频并提交视频超分任务：
+
+```bash
+pippit-tool-cli video-super-resolution \
+  --video "~/videos/source.mp4" \
+  --output-resolution "1080p" \
+  --tool-version "standard"
+```
+
+`--output-resolution` 必填，当前服务端支持 `720p`、`1080p`、`2k`、`4k`。`--tool-version` 可选，当前服务端支持 `standard`、`professional_v1`、`professional_v2`；省略时由服务端使用 `standard`。CLI 不重复校验这些枚举值，具体能力与约束由服务端决定。
+
+`erase-video-subtitle` 会上传一个本地视频并提交擦字幕任务：
+
+```bash
+pippit-tool-cli erase-video-subtitle \
+  --video "~/videos/with-subtitle.mp4"
+```
+
+两个命令都会把 `agent_name` 固定为 `pippit_video_part_agent`。上传接口返回的 `pippit_asset_id` 不会写入顶层 `asset_ids` 或普通参考视频列表，而是分别写入以下服务端专属参数：
+
+- 超分：`video_part_tool_param.mini_tool_param.tool_param.video_super_resolution_tool_param.video.pippit_asset_id`
+- 擦字幕：`video_part_tool_param.mini_tool_param.tool_param.erase_video_subtitle_tool_param.video.pippit_asset_id`
+
+两个命令都输出 `thread_id`、`run_id` 和 `web_thread_link`。拿到任务 ID 后，可继续使用 `query-result` 查询并下载结果。
+
 查询并下载生图/生视频结果：
 
 ```bash

package/checksums.txt

@@ -1,6 +1,6 @@
-7e8b88e21ebfd05357f0183c408bfbacaf6c583398e9ab8f3edd24063be911b1  pippit-tool-cli-1.0.14-darwin-amd64.tar.gz
-e514b59bb83b59130deb9cec6cb0f114fd11fe47921d7a65e2f697ad5d528e07  pippit-tool-cli-1.0.14-darwin-arm64.tar.gz
-436efcab90026d8e0d3e593943d8cbd473a5219017685c1099f09992a7034d4b  pippit-tool-cli-1.0.14-linux-amd64.tar.gz
-d4a7916d18a16b7b179db6251931796440e236a6d8d841e385bf02e4de9bca29  pippit-tool-cli-1.0.14-linux-arm64.tar.gz
-9688067ffd270653e81570ff2cd395e51d92f82248573c3682a3d7c3fd6cbb89  pippit-tool-cli-1.0.14-windows-amd64.zip
-98d211cd42c0d1a7b526f9a0cca7456d0e9acbf56a0f4da4c7dc1b2d25d457ff  pippit-tool-cli-1.0.14-windows-arm64.zip
+74b2f14a1d1c02ad9494f673f6a89aa4d04ce7b044858b844ec023751f9e9cdd  pippit-tool-cli-1.0.16-darwin-amd64.tar.gz
+d84cb1159556082fb2e8eac85b6057a486dc2da35e3799f78f7a3bf80f3189e4  pippit-tool-cli-1.0.16-darwin-arm64.tar.gz
+e7fc7e01d8a3a3a30263ba335d89effd294b8e4c965664994a6177fb6ef95c9f  pippit-tool-cli-1.0.16-linux-amd64.tar.gz
+197d60edff7e28ca0c8125c08f6bdd9b77844b4f7b6016207de8212e53300cfe  pippit-tool-cli-1.0.16-linux-arm64.tar.gz
+9895851ce36cd390c5841bf9ba3098e5f71a0b48f0cfb628e51a64b695dd692d  pippit-tool-cli-1.0.16-windows-amd64.zip
+c55f1d861640f8e6a5a5efa0d2cc30888658c47aaa09c30e1c94cc8fc4173a1d  pippit-tool-cli-1.0.16-windows-arm64.zip

package/cmd/generate_video/generate_video.go

@@ -13,6 +13,7 @@ import (
 func NewCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
 	opts := &internalgen.Options{}
 	var durationSec int
+	var generateType int64
 
 	cmd := &cobra.Command{
 		Use:   "generate-video",
@@ -22,6 +23,9 @@ func NewCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command
 			if cmd.Flags().Changed("duration") {
 				opts.DurationSec = &durationSec
 			}
+			if cmd.Flags().Changed("generate-type") {
+				opts.GenerateType = &generateType
+			}
 
 			result, err := internalgen.Run(cmd.Context(), opts, runner)
 			if err != nil {
@@ -46,5 +50,6 @@ func NewCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command
 	flags.StringVar(&opts.Ratio, "ratio", "", "video ratio, such as 9:16, 16:9, 3:4, 4:3")
 	flags.StringVar(&opts.Model, "model", "", "video model; normal users: Seedance_2.0_mini_lite; VIP-only: seedance2.0_vision, seedance2.0_fast_vision, Seedance_2.0_mini")
 	flags.StringVar(&opts.Resolution, "resolution", "", "video resolution, such as 720p, 1080p")
+	flags.Int64Var(&generateType, "generate-type", 0, "generation type passed to the service; set 1 for first-and-last-frame generation and provide two --image values in first-frame, last-frame order")
 	return cmd
 }

package/cmd/generate_video_test.go

@@ -72,6 +72,9 @@ func TestGenerateVideo(t *testing.T) {
 			if param["ratio"] != "9:16" || param["model"] != "seedance2.0_vision" || param["resolution"] != "720p" {
 				t.Fatalf("param = %#v, want ratio/model/resolution", param)
 			}
+			if param["generate_type"] != float64(1) {
+				t.Fatalf("generate_type = %v, want 1", param["generate_type"])
+			}
 			assertAssetRefs(t, param["images"], []string{"image_asset_1", "image_asset_2"})
 			assertAssetRefs(t, param["videos"], []string{"video_asset_1", "video_asset_2"})
 			assertAssetRefs(t, param["audios"], []string{"audio_asset_1"})
@@ -108,6 +111,7 @@ func TestGenerateVideo(t *testing.T) {
 		"--ratio", "9:16",
 		"--model", "seedance2.0_vision",
 		"--resolution", "720p",
+		"--generate-type", "1",
 	})
 
 	if err := root.Execute(); err != nil {
@@ -124,6 +128,21 @@ func TestGenerateVideoSkipsSemanticValidation(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/api/biz/v1/skill/submit_run":
+			data, err := io.ReadAll(r.Body)
+			if err != nil {
+				t.Fatalf("read body: %v", err)
+			}
+			var body map[string]any
+			if err := sonic.Unmarshal(data, &body); err != nil {
+				t.Fatalf("decode body: %v", err)
+			}
+			param, ok := body["video_part_tool_param"].(map[string]any)
+			if !ok {
+				t.Fatalf("video_part_tool_param = %#v, want object", body["video_part_tool_param"])
+			}
+			if param["generate_type"] != float64(99) {
+				t.Fatalf("generate_type = %v, want 99", param["generate_type"])
+			}
 			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"run":{"thread_id":"thread_123","run_id":"run_456"}}}`))
 		default:
 			t.Fatalf("unexpected path %s", r.URL.Path)
@@ -140,6 +159,7 @@ func TestGenerateVideoSkipsSemanticValidation(t *testing.T) {
 		"--ratio", "1:1",
 		"--model", "bad_model",
 		"--resolution", "bad_resolution",
+		"--generate-type", "99",
 	})
 
 	if err := root.Execute(); err != nil {

package/cmd/root.go

@@ -11,6 +11,7 @@ import (
 	"github.com/Pippit-dev/pippit-cli/cmd/generate_video"
 	"github.com/Pippit-dev/pippit-cli/cmd/short_drama"
 	updatecmd "github.com/Pippit-dev/pippit-cli/cmd/update"
+	"github.com/Pippit-dev/pippit-cli/cmd/video_tool"
 	"github.com/Pippit-dev/pippit-cli/internal/common"
 	"github.com/Pippit-dev/pippit-cli/internal/config"
 	"github.com/Pippit-dev/pippit-cli/internal/version"
@@ -33,7 +34,7 @@ func newRootCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Comm
 	root := &cobra.Command{
 		Use:           "pippit-tool-cli",
 		Short:         "Pippit CLI",
-		Long:          "Pippit CLI generates videos and images, submits short-drama workflows, downloads generated assets, and updates the installed CLI package.",
+		Long:          "Pippit CLI generates and processes videos and images, submits short-drama workflows, downloads generated assets, and updates the installed CLI package.",
 		Version:       version.Current(),
 		SilenceUsage:  true,
 		SilenceErrors: true,
@@ -49,6 +50,8 @@ func newRootCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Comm
 	root.AddCommand(generate_image.NewCommand(stdout, stderr, runner))
 	root.AddCommand(generate_video.NewCommand(stdout, stderr, runner))
 	root.AddCommand(generate_video.NewQueryResultCommand(stdout, stderr, runner))
+	root.AddCommand(video_tool.NewSuperResolutionCommand(stdout, stderr, runner))
+	root.AddCommand(video_tool.NewEraseSubtitleCommand(stdout, stderr, runner))
 	root.AddCommand(short_drama.NewCommand(stdout, stderr, runner))
 	root.AddCommand(updatecmd.NewCommand(stdout, stderr))
 	localizeFlagErrors(root)

package/cmd/short_drama_test.go

@@ -124,7 +124,8 @@ func TestRootHelpListsSupportedCommands(t *testing.T) {
 	}
 	got := stdout.String()
 	for _, want := range []string{
-		"Pippit CLI generates videos",
+		"Pippit CLI generates and processes videos",
+		"erase-video-subtitle",
 		"generate-video",
 		"download-result",
 		"get-thread",
@@ -132,6 +133,7 @@ func TestRootHelpListsSupportedCommands(t *testing.T) {
 		"query-result",
 		"short-drama",
 		"update",
+		"video-super-resolution",
 		"--version",
 	} {
 		if !strings.Contains(got, want) {

package/cmd/video_tool/video_tool.go

@@ -0,0 +1,63 @@
+package video_tool
+
+import (
+	"io"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	internaltool "github.com/Pippit-dev/pippit-cli/internal/video_tool"
+	"github.com/spf13/cobra"
+)
+
+// NewSuperResolutionCommand builds the video-super-resolution command.
+func NewSuperResolutionCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	opts := &internaltool.SuperResolutionOptions{}
+	cmd := &cobra.Command{
+		Use:   "video-super-resolution",
+		Short: "Improve the resolution of one video",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			result, err := internaltool.RunSuperResolution(cmd.Context(), opts, runner)
+			if err != nil {
+				_ = common.AppendDailyErrorLog("video-super-resolution", err, map[string]string{
+					"video_path":        opts.VideoPath,
+					"tool_version":      opts.ToolVersion,
+					"output_resolution": opts.OutputResolution,
+				})
+				return err
+			}
+			return common.WriteJSON(stdout, result)
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	flags := cmd.Flags()
+	flags.StringVar(&opts.VideoPath, "video", "", "local input video path")
+	flags.StringVar(&opts.OutputResolution, "output-resolution", "", "output resolution passed to the service: 720p, 1080p, 2k, or 4k")
+	flags.StringVar(&opts.ToolVersion, "tool-version", "", "optional tool version passed to the service: standard, professional_v1, or professional_v2")
+	return cmd
+}
+
+// NewEraseSubtitleCommand builds the erase-video-subtitle command.
+func NewEraseSubtitleCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	opts := &internaltool.EraseSubtitleOptions{}
+	cmd := &cobra.Command{
+		Use:   "erase-video-subtitle",
+		Short: "Erase subtitles from one video",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			result, err := internaltool.RunEraseSubtitle(cmd.Context(), opts, runner)
+			if err != nil {
+				_ = common.AppendDailyErrorLog("erase-video-subtitle", err, map[string]string{
+					"video_path": opts.VideoPath,
+				})
+				return err
+			}
+			return common.WriteJSON(stdout, result)
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	flags := cmd.Flags()
+	flags.StringVar(&opts.VideoPath, "video", "", "local input video path")
+	return cmd
+}

package/cmd/video_tool_test.go

@@ -0,0 +1,258 @@
+package cmd
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/bytedance/sonic"
+)
+
+func TestVideoSuperResolution(t *testing.T) {
+	var uploaded bool
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Header.Get("Authorization") != "Bearer test-token" {
+			t.Fatalf("Authorization = %q, want test bearer token", r.Header.Get("Authorization"))
+		}
+		switch r.URL.Path {
+		case "/api/biz/v1/skill/upload_file":
+			assertSingleUploadedVideo(t, r, "source.mp4")
+			uploaded = true
+			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"pippit_asset_id":"video_asset_1"}}`))
+		case "/api/biz/v1/skill/submit_run":
+			if !uploaded {
+				t.Fatal("submit called before upload")
+			}
+			body := decodeRequestBody(t, r)
+			assertVideoToolBaseRequest(t, body, "提升视频清晰度")
+			miniTool := videoMiniToolParam(t, body)
+			if miniTool["tool_name"] != "video_super_resolution" {
+				t.Fatalf("tool_name = %v, want video_super_resolution", miniTool["tool_name"])
+			}
+			toolParam := requiredObject(t, miniTool, "tool_param")
+			superResolution := requiredObject(t, toolParam, "video_super_resolution_tool_param")
+			if superResolution["tool_version"] != "professional_v1" {
+				t.Fatalf("tool_version = %v, want professional_v1", superResolution["tool_version"])
+			}
+			if superResolution["output_resolution"] != "2k" {
+				t.Fatalf("output_resolution = %v, want 2k", superResolution["output_resolution"])
+			}
+			assertNestedVideoAsset(t, superResolution, "video_asset_1")
+			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"run":{"thread_id":"thread_sr","run_id":"run_sr"},"web_thread_link":"https://xyq.example/thread_sr"}}`))
+		default:
+			t.Fatalf("unexpected path %s", r.URL.Path)
+		}
+	}))
+	defer server.Close()
+
+	video := writeTestVideo(t, "source.mp4")
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{
+		"video-super-resolution",
+		"--video", video,
+		"--output-resolution", "2k",
+		"--tool-version", "professional_v1",
+	})
+
+	if err := root.Execute(); err != nil {
+		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
+	}
+	got := decodeJSON(t, stdout.Bytes())
+	if got["thread_id"] != "thread_sr" || got["run_id"] != "run_sr" {
+		t.Fatalf("output = %#v, want super-resolution thread and run IDs", got)
+	}
+}
+
+func TestEraseVideoSubtitle(t *testing.T) {
+	var uploaded bool
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/biz/v1/skill/upload_file":
+			assertSingleUploadedVideo(t, r, "subtitle.mov")
+			uploaded = true
+			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"pippit_asset_id":"video_asset_2"}}`))
+		case "/api/biz/v1/skill/submit_run":
+			if !uploaded {
+				t.Fatal("submit called before upload")
+			}
+			body := decodeRequestBody(t, r)
+			assertVideoToolBaseRequest(t, body, "擦除视频字幕")
+			miniTool := videoMiniToolParam(t, body)
+			if miniTool["tool_name"] != "erase_video_subtitle" {
+				t.Fatalf("tool_name = %v, want erase_video_subtitle", miniTool["tool_name"])
+			}
+			toolParam := requiredObject(t, miniTool, "tool_param")
+			eraseSubtitle := requiredObject(t, toolParam, "erase_video_subtitle_tool_param")
+			if _, ok := eraseSubtitle["tool_version"]; ok {
+				t.Fatalf("tool_version must be omitted: %#v", eraseSubtitle)
+			}
+			assertNestedVideoAsset(t, eraseSubtitle, "video_asset_2")
+			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"run":{"thread_id":"thread_erase","run_id":"run_erase"}}}`))
+		default:
+			t.Fatalf("unexpected path %s", r.URL.Path)
+		}
+	}))
+	defer server.Close()
+
+	video := writeTestVideo(t, "subtitle.mov")
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{
+		"erase-video-subtitle",
+		"--video", video,
+	})
+
+	if err := root.Execute(); err != nil {
+		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
+	}
+	got := decodeJSON(t, stdout.Bytes())
+	if got["thread_id"] != "thread_erase" || got["run_id"] != "run_erase" {
+		t.Fatalf("output = %#v, want erase-subtitle thread and run IDs", got)
+	}
+}
+
+func TestEraseVideoSubtitleDoesNotExposeToolVersion(t *testing.T) {
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, "http://127.0.0.1")
+	root.SetArgs([]string{
+		"erase-video-subtitle",
+		"--video", "source.mp4",
+		"--tool-version", "custom_version",
+	})
+
+	err := root.Execute()
+	if err == nil || !strings.Contains(err.Error(), "未知参数: --tool-version") {
+		t.Fatalf("Execute() error = %v, want unknown --tool-version", err)
+	}
+}
+
+func TestVideoToolErrorLogsIncludeVideoPath(t *testing.T) {
+	tests := []struct {
+		name string
+		args func(string) []string
+	}{
+		{
+			name: "super resolution",
+			args: func(path string) []string {
+				return []string{"video-super-resolution", "--video", path, "--output-resolution", "1080p"}
+			},
+		},
+		{
+			name: "erase subtitle",
+			args: func(path string) []string {
+				return []string{"erase-video-subtitle", "--video", path}
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			clearDailyErrorLog(t)
+			videoPath := filepath.Join(t.TempDir(), "missing.mp4")
+			var stdout, stderr bytes.Buffer
+			root := newTestRootCommand(t, &stdout, &stderr, "http://127.0.0.1")
+			root.SetArgs(tt.args(videoPath))
+
+			if err := root.Execute(); err == nil {
+				t.Fatal("Execute() error = nil, want missing video error")
+			}
+			entries := readDailyErrorLog(t)
+			if len(entries) != 1 {
+				t.Fatalf("log entries = %d, want 1: %#v", len(entries), entries)
+			}
+			fields, ok := entries[0]["fields"].(map[string]any)
+			if !ok {
+				t.Fatalf("fields = %#v, want object", entries[0]["fields"])
+			}
+			if fields["video_path"] != videoPath {
+				t.Fatalf("video_path = %v, want %s", fields["video_path"], videoPath)
+			}
+		})
+	}
+}
+
+func assertSingleUploadedVideo(t *testing.T, r *http.Request, wantName string) {
+	t.Helper()
+	if r.Method != http.MethodPost {
+		t.Fatalf("upload method = %s, want POST", r.Method)
+	}
+	if err := r.ParseMultipartForm(1 << 20); err != nil {
+		t.Fatalf("ParseMultipartForm(): %v", err)
+	}
+	files := r.MultipartForm.File["file"]
+	if len(files) != 1 || files[0].Filename != wantName {
+		t.Fatalf("uploaded files = %#v, want one %s", files, wantName)
+	}
+}
+
+func decodeRequestBody(t *testing.T, r *http.Request) map[string]any {
+	t.Helper()
+	data, err := io.ReadAll(r.Body)
+	if err != nil {
+		t.Fatalf("read body: %v", err)
+	}
+	var body map[string]any
+	if err := sonic.Unmarshal(data, &body); err != nil {
+		t.Fatalf("decode body: %v", err)
+	}
+	return body
+}
+
+func assertVideoToolBaseRequest(t *testing.T, body map[string]any, wantMessage string) {
+	t.Helper()
+	if body["agent_name"] != "pippit_video_part_agent" {
+		t.Fatalf("agent_name = %v, want video part agent", body["agent_name"])
+	}
+	if body["message"] != wantMessage {
+		t.Fatalf("message = %v, want %s", body["message"], wantMessage)
+	}
+	if _, ok := body["asset_ids"]; ok {
+		t.Fatalf("asset_ids must be omitted: %#v", body)
+	}
+}
+
+func videoMiniToolParam(t *testing.T, body map[string]any) map[string]any {
+	t.Helper()
+	videoPart := requiredObject(t, body, "video_part_tool_param")
+	for _, unwanted := range []string{"prompt", "videos", "model", "ratio", "resolution", "duration_sec"} {
+		if _, ok := videoPart[unwanted]; ok {
+			t.Fatalf("video_part_tool_param.%s must be omitted: %#v", unwanted, videoPart)
+		}
+	}
+	return requiredObject(t, videoPart, "mini_tool_param")
+}
+
+func assertNestedVideoAsset(t *testing.T, toolParam map[string]any, wantAssetID string) {
+	t.Helper()
+	video := requiredObject(t, toolParam, "video")
+	if video["pippit_asset_id"] != wantAssetID {
+		t.Fatalf("pippit_asset_id = %v, want %s", video["pippit_asset_id"], wantAssetID)
+	}
+	if len(video) != 1 {
+		t.Fatalf("video = %#v, want only pippit_asset_id", video)
+	}
+}
+
+func requiredObject(t *testing.T, parent map[string]any, key string) map[string]any {
+	t.Helper()
+	value, ok := parent[key].(map[string]any)
+	if !ok {
+		t.Fatalf("%s = %#v, want object", key, parent[key])
+	}
+	return value
+}
+
+func writeTestVideo(t *testing.T, name string) string {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), name)
+	if err := os.WriteFile(path, []byte("video-data"), 0o644); err != nil {
+		t.Fatalf("WriteFile(%s): %v", path, err)
+	}
+	return path
+}

package/internal/common/media.go

@@ -0,0 +1,23 @@
+package common
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+)
+
+var (
+	allowedVideoExtensionList = []string{".mp4", ".avi", ".mov", ".wmv", ".flv", ".webm", ".mkv", ".m4v"}
+	allowedVideoExtensions    = StringSet(allowedVideoExtensionList)
+)
+
+// ValidateVideoExtensions validates local video paths against the CLI-supported suffixes.
+func ValidateVideoExtensions(paths []string) error {
+	for _, path := range paths {
+		ext := strings.ToLower(filepath.Ext(strings.TrimSpace(path)))
+		if _, ok := allowedVideoExtensions[ext]; !ok {
+			return fmt.Errorf("不支持的视频文件后缀 %q，文件：%q；支持的后缀：%s", ext, path, strings.Join(allowedVideoExtensionList, ", "))
+		}
+	}
+	return nil
+}

package/internal/common/media_test.go

@@ -0,0 +1,17 @@
+package common
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestValidateVideoExtensions(t *testing.T) {
+	if err := ValidateVideoExtensions([]string{"source.MP4", "reference.webm"}); err != nil {
+		t.Fatalf("ValidateVideoExtensions() error = %v, want nil", err)
+	}
+
+	err := ValidateVideoExtensions([]string{"source.txt"})
+	if err == nil || !strings.Contains(err.Error(), `不支持的视频文件后缀 ".txt"`) {
+		t.Fatalf("ValidateVideoExtensions() error = %v, want extension validation", err)
+	}
+}

package/internal/common/submit_run.go

@@ -1,6 +1,21 @@
 package common
 
-import "github.com/Pippit-dev/pippit-cli/internal/config"
+import (
+	"context"
+	"fmt"
+
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+)
+
+// AgentNameVideoPart is the video-part agent used by direct video capabilities.
+const AgentNameVideoPart = "pippit_video_part_agent"
+
+// SubmitRunResult is the shared successful submit_run output.
+type SubmitRunResult struct {
+	ThreadID      string `json:"thread_id"`
+	RunID         string `json:"run_id"`
+	WebThreadLink string `json:"web_thread_link"`
+}
 
 // SubmitRunResponse is the shared response envelope returned by submit_run.
 type SubmitRunResponse struct {
@@ -20,6 +35,35 @@ type SubmitRunResponseRun struct {
 	RunID    string `json:"run_id"`
 }
 
+// SubmitRun sends a submit_run request and validates its shared response envelope.
+func SubmitRun(ctx context.Context, command string, body any, runner *Runner) (*SubmitRunResult, error) {
+	if runner == nil || runner.Client == nil {
+		return nil, fmt.Errorf("%s 运行器客户端缺失", command)
+	}
+	var resp SubmitRunResponse
+	if err := runner.Client.SendRequest(ctx, SubmitRunPath(runner), body, &resp); err != nil {
+		return nil, fmt.Errorf("提交 %s 请求失败: %w", command, err)
+	}
+	if resp.Ret != "0" {
+		if resp.Errmsg == "" {
+			resp.Errmsg = "未知错误"
+		}
+		return nil, NewLogIDError(fmt.Sprintf("%s 请求返回失败: ret=%s errmsg=%s", command, resp.Ret, resp.Errmsg), resp.LogID)
+	}
+	if resp.Data.Run.ThreadID == "" {
+		return nil, fmt.Errorf("%s 响应缺少 data.run.thread_id", command)
+	}
+	if resp.Data.Run.RunID == "" {
+		return nil, fmt.Errorf("%s 响应缺少 data.run.run_id", command)
+	}
+
+	return &SubmitRunResult{
+		ThreadID:      resp.Data.Run.ThreadID,
+		RunID:         resp.Data.Run.RunID,
+		WebThreadLink: resp.Data.WebThreadLink,
+	}, nil
+}
+
 // SubmitRunPath returns the configured submit_run endpoint path.
 func SubmitRunPath(runner *Runner) string {
 	if runner != nil && runner.Config != nil && runner.Config.Paths != nil && runner.Config.Paths.SubmitRun != "" {

package/internal/common/submit_run_test.go

@@ -0,0 +1,28 @@
+package common
+
+import (
+	"context"
+	"strings"
+	"testing"
+)
+
+func TestSubmitRunReturnsSharedResult(t *testing.T) {
+	result, err := SubmitRun(context.Background(), "generate-video", map[string]any{"message": "test"}, &Runner{
+		Client: getThreadFakeClient{response: `{"ret":"0","errmsg":"","data":{"run":{"thread_id":"thread_123","run_id":"run_456"},"web_thread_link":"https://example.com/thread_123"}}`},
+	})
+	if err != nil {
+		t.Fatalf("SubmitRun() error = %v", err)
+	}
+	if result.ThreadID != "thread_123" || result.RunID != "run_456" || result.WebThreadLink != "https://example.com/thread_123" {
+		t.Fatalf("SubmitRun() result = %#v", result)
+	}
+}
+
+func TestSubmitRunBusinessErrorIncludesLogID(t *testing.T) {
+	_, err := SubmitRun(context.Background(), "video-super-resolution", nil, &Runner{
+		Client: getThreadFakeClient{response: `{"ret":"16008","errmsg":"提交Run任务失败","log_id":"log_123"}`},
+	})
+	if err == nil || !strings.Contains(err.Error(), "video-super-resolution 请求返回失败") || !strings.Contains(err.Error(), "log_id=log_123") {
+		t.Fatalf("SubmitRun() error = %v, want command and log_id", err)
+	}
+}

package/internal/common/video_part.go

@@ -0,0 +1,44 @@
+package common
+
+// MediaAsset references one uploaded Pippit media asset in submit_run requests.
+type MediaAsset struct {
+	PippitAssetID string `json:"pippit_asset_id"`
+}
+
+// VideoPartToolParam is the shared request payload for video-part capabilities.
+type VideoPartToolParam struct {
+	Images        []*MediaAsset       `json:"images,omitempty"`
+	Prompt        *string             `json:"prompt,omitempty"`
+	DurationSec   *int                `json:"duration_sec,omitempty"`
+	Ratio         string              `json:"ratio,omitempty"`
+	Videos        []*MediaAsset       `json:"videos,omitempty"`
+	Audios        []*MediaAsset       `json:"audios,omitempty"`
+	Model         string              `json:"model,omitempty"`
+	Resolution    string              `json:"resolution,omitempty"`
+	GenerateType  *int64              `json:"generate_type,omitempty"`
+	MiniToolParam *VideoMiniToolParam `json:"mini_tool_param,omitempty"`
+}
+
+// VideoMiniToolParam identifies a video mini tool and carries its request payload.
+type VideoMiniToolParam struct {
+	ToolName  string                `json:"tool_name"`
+	ToolParam *VideoMiniToolPayload `json:"tool_param"`
+}
+
+// VideoMiniToolPayload contains the request payload for one selected video mini tool.
+type VideoMiniToolPayload struct {
+	VideoSuperResolutionToolParam *VideoSuperResolutionToolParam `json:"video_super_resolution_tool_param,omitempty"`
+	EraseVideoSubtitleToolParam   *EraseVideoSubtitleToolParam   `json:"erase_video_subtitle_tool_param,omitempty"`
+}
+
+// VideoSuperResolutionToolParam is the request payload for video super-resolution.
+type VideoSuperResolutionToolParam struct {
+	ToolVersion      string      `json:"tool_version,omitempty"`
+	Video            *MediaAsset `json:"video"`
+	OutputResolution string      `json:"output_resolution"`
+}
+
+// EraseVideoSubtitleToolParam is the request payload for subtitle removal.
+type EraseVideoSubtitleToolParam struct {
+	Video *MediaAsset `json:"video"`
+}

package/internal/generate_video/generate_video.go

@@ -3,7 +3,6 @@ package generate_video
 import (
 	"context"
 	"fmt"
-	"os"
 	"path/filepath"
 	"strings"
 
@@ -11,7 +10,6 @@ import (
 )
 
 const (
-	agentNameVideoPart = "pippit_video_part_agent"
 	maxReferenceImages = 9
 	maxReferenceVideos = 3
 	maxReferenceAudios = 3
@@ -19,46 +17,26 @@ const (
 
 var (
 	allowedImageExtensionList = []string{".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".svg"}
-	allowedVideoExtensionList = []string{".mp4", ".avi", ".mov", ".wmv", ".flv", ".webm", ".mkv", ".m4v"}
 	allowedAudioExtensionList = []string{".mp3", ".wav"}
-	allowedImageExtensions    = makeExtensionSet(allowedImageExtensionList)
-	allowedVideoExtensions    = makeExtensionSet(allowedVideoExtensionList)
-	allowedAudioExtensions    = makeExtensionSet(allowedAudioExtensionList)
+	allowedImageExtensions    = common.StringSet(allowedImageExtensionList)
+	allowedAudioExtensions    = common.StringSet(allowedAudioExtensionList)
 )
 
 // Options is the stable command-facing request shape for generate-video.
 type Options struct {
-	Prompt      string
-	ImagePaths  []string
-	VideoPaths  []string
-	AudioPaths  []string
-	DurationSec *int
-	Ratio       string
-	Model       string
-	Resolution  string
-}
-
-type mediaAsset struct {
-	PippitAssetID string `json:"pippit_asset_id"`
-}
-
-type videoPartToolParam struct {
-	Images      []mediaAsset `json:"images,omitempty"`
-	Prompt      string       `json:"prompt"`
-	DurationSec *int         `json:"duration_sec,omitempty"`
-	Ratio       string       `json:"ratio,omitempty"`
-	Videos      []mediaAsset `json:"videos,omitempty"`
-	Audios      []mediaAsset `json:"audios,omitempty"`
-	Model       string       `json:"model,omitempty"`
-	Resolution  string       `json:"resolution,omitempty"`
+	Prompt       string
+	ImagePaths   []string
+	VideoPaths   []string
+	AudioPaths   []string
+	DurationSec  *int
+	Ratio        string
+	Model        string
+	Resolution   string
+	GenerateType *int64
 }
 
 // Result is the JSON envelope printed by `pippit-tool-cli generate-video`.
-type Result struct {
-	ThreadID      string `json:"thread_id"`
-	RunID         string `json:"run_id"`
-	WebThreadLink string `json:"web_thread_link"`
-}
+type Result = common.SubmitRunResult
 
 func Run(ctx context.Context, opts *Options, runner *common.Runner) (*Result, error) {
 	if runner == nil || runner.Client == nil {
@@ -82,29 +60,7 @@ func Run(ctx context.Context, opts *Options, runner *common.Runner) (*Result, er
 	}
 
 	body := buildSubmitRunBody(opts, imageAssetIDs, videoAssetIDs, audioAssetIDs)
-
-	var resp common.SubmitRunResponse
-	if err := runner.Client.SendRequest(ctx, common.SubmitRunPath(runner), body, &resp); err != nil {
-		return nil, fmt.Errorf("提交 generate-video 请求失败: %w", err)
-	}
-	if resp.Ret != "0" {
-		if resp.Errmsg == "" {
-			resp.Errmsg = "未知错误"
-		}
-		return nil, common.NewLogIDError(fmt.Sprintf("generate-video 请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg), resp.LogID)
-	}
-	if resp.Data.Run.ThreadID == "" {
-		return nil, fmt.Errorf("generate-video 响应缺少 data.run.thread_id")
-	}
-	if resp.Data.Run.RunID == "" {
-		return nil, fmt.Errorf("generate-video 响应缺少 data.run.run_id")
-	}
-
-	return &Result{
-		ThreadID:      resp.Data.Run.ThreadID,
-		RunID:         resp.Data.Run.RunID,
-		WebThreadLink: resp.Data.WebThreadLink,
-	}, nil
+	return common.SubmitRun(ctx, "generate-video", body, runner)
 }
 
 func ValidateOptions(opts *Options) error {
@@ -126,7 +82,7 @@ func ValidateOptions(opts *Options) error {
 	if err := validateMediaExtensions("图片", opts.ImagePaths, allowedImageExtensions, allowedImageExtensionList); err != nil {
 		return err
 	}
-	if err := validateMediaExtensions("视频", opts.VideoPaths, allowedVideoExtensions, allowedVideoExtensionList); err != nil {
+	if err := common.ValidateVideoExtensions(opts.VideoPaths); err != nil {
 		return err
 	}
 	if err := validateMediaExtensions("音频", opts.AudioPaths, allowedAudioExtensions, allowedAudioExtensionList); err != nil {
@@ -145,18 +101,10 @@ func validateMediaExtensions(kind string, paths []string, allowed map[string]str
 	return nil
 }
 
-func makeExtensionSet(list []string) map[string]struct{} {
-	set := make(map[string]struct{}, len(list))
-	for _, ext := range list {
-		set[ext] = struct{}{}
-	}
-	return set
-}
-
 func uploadMediaList(ctx context.Context, paths []string, runner *common.Runner) ([]string, error) {
 	assetIDs := make([]string, 0, len(paths))
 	for _, path := range paths {
-		expanded, err := expandPath(path)
+		expanded, err := common.ExpandPath(path)
 		if err != nil {
 			return nil, err
 		}
@@ -170,46 +118,33 @@ func uploadMediaList(ctx context.Context, paths []string, runner *common.Runner)
 }
 
 func buildSubmitRunBody(opts *Options, imageAssetIDs []string, videoAssetIDs []string, audioAssetIDs []string) map[string]any {
-	param := videoPartToolParam{
-		Images:      assetRefs(imageAssetIDs),
-		Prompt:      strings.TrimSpace(opts.Prompt),
-		DurationSec: opts.DurationSec,
-		Ratio:       strings.TrimSpace(opts.Ratio),
-		Videos:      assetRefs(videoAssetIDs),
-		Audios:      assetRefs(audioAssetIDs),
-		Model:       strings.TrimSpace(opts.Model),
-		Resolution:  strings.TrimSpace(opts.Resolution),
+	prompt := strings.TrimSpace(opts.Prompt)
+	param := common.VideoPartToolParam{
+		Images:       assetRefs(imageAssetIDs),
+		Prompt:       &prompt,
+		DurationSec:  opts.DurationSec,
+		Ratio:        strings.TrimSpace(opts.Ratio),
+		Videos:       assetRefs(videoAssetIDs),
+		Audios:       assetRefs(audioAssetIDs),
+		Model:        strings.TrimSpace(opts.Model),
+		Resolution:   strings.TrimSpace(opts.Resolution),
+		GenerateType: opts.GenerateType,
 	}
 
 	return map[string]any{
-		"agent_name":            agentNameVideoPart,
-		"message":               strings.TrimSpace(opts.Prompt),
+		"agent_name":            common.AgentNameVideoPart,
+		"message":               prompt,
 		"video_part_tool_param": param,
 	}
 }
 
-func assetRefs(assetIDs []string) []mediaAsset {
+func assetRefs(assetIDs []string) []*common.MediaAsset {
 	if len(assetIDs) == 0 {
 		return nil
 	}
-	refs := make([]mediaAsset, 0, len(assetIDs))
+	refs := make([]*common.MediaAsset, 0, len(assetIDs))
 	for _, assetID := range assetIDs {
-		refs = append(refs, mediaAsset{PippitAssetID: assetID})
+		refs = append(refs, &common.MediaAsset{PippitAssetID: assetID})
 	}
 	return refs
 }
-
-func expandPath(path string) (string, error) {
-	path = strings.TrimSpace(path)
-	if path == "~" {
-		return os.UserHomeDir()
-	}
-	if strings.HasPrefix(path, "~/") || strings.HasPrefix(path, `~\`) {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return "", fmt.Errorf("解析用户主目录失败: %w", err)
-		}
-		return filepath.Join(home, path[2:]), nil
-	}
-	return path, nil
-}

package/internal/generate_video/generate_video_test.go

@@ -0,0 +1,17 @@
+package generate_video
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestBuildSubmitRunBodyPreservesEmptyPrompt(t *testing.T) {
+	body := buildSubmitRunBody(&Options{}, nil, nil, nil)
+	got, err := json.Marshal(body["video_part_tool_param"])
+	if err != nil {
+		t.Fatalf("json.Marshal() error = %v", err)
+	}
+	if string(got) != `{"prompt":""}` {
+		t.Fatalf("video_part_tool_param = %s, want explicit empty prompt", got)
+	}
+}

package/internal/video_tool/video_tool.go

@@ -0,0 +1,130 @@
+package video_tool
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+)
+
+const (
+	toolVideoSuperResolution = "video_super_resolution"
+	toolEraseVideoSubtitle   = "erase_video_subtitle"
+	messageSuperResolution   = "提升视频清晰度"
+	messageEraseSubtitle     = "擦除视频字幕"
+)
+
+// SuperResolutionOptions is the command-facing request shape for video-super-resolution.
+type SuperResolutionOptions struct {
+	VideoPath        string
+	ToolVersion      string
+	OutputResolution string
+}
+
+// EraseSubtitleOptions is the command-facing request shape for erase-video-subtitle.
+type EraseSubtitleOptions struct {
+	VideoPath string
+}
+
+// Result is the JSON envelope printed by both video tool commands.
+type Result = common.SubmitRunResult
+
+// RunSuperResolution uploads one video and submits a video super-resolution run.
+func RunSuperResolution(ctx context.Context, opts *SuperResolutionOptions, runner *common.Runner) (*Result, error) {
+	if runner == nil || runner.Client == nil {
+		return nil, fmt.Errorf("video-super-resolution 运行器客户端缺失")
+	}
+	if err := ValidateSuperResolutionOptions(opts); err != nil {
+		return nil, err
+	}
+
+	assetID, err := uploadVideo(ctx, opts.VideoPath, runner)
+	if err != nil {
+		return nil, err
+	}
+	return common.SubmitRun(ctx, "video-super-resolution", buildSuperResolutionSubmitRunBody(opts, assetID), runner)
+}
+
+// RunEraseSubtitle uploads one video and submits a subtitle-erasing run.
+func RunEraseSubtitle(ctx context.Context, opts *EraseSubtitleOptions, runner *common.Runner) (*Result, error) {
+	if runner == nil || runner.Client == nil {
+		return nil, fmt.Errorf("erase-video-subtitle 运行器客户端缺失")
+	}
+	if err := ValidateEraseSubtitleOptions(opts); err != nil {
+		return nil, err
+	}
+
+	assetID, err := uploadVideo(ctx, opts.VideoPath, runner)
+	if err != nil {
+		return nil, err
+	}
+	return common.SubmitRun(ctx, "erase-video-subtitle", buildEraseSubtitleSubmitRunBody(assetID), runner)
+}
+
+// ValidateSuperResolutionOptions validates only command shape; semantic enums remain service-owned.
+func ValidateSuperResolutionOptions(opts *SuperResolutionOptions) error {
+	if opts == nil || strings.TrimSpace(opts.VideoPath) == "" {
+		return fmt.Errorf("缺少必填参数 --video")
+	}
+	if strings.TrimSpace(opts.OutputResolution) == "" {
+		return fmt.Errorf("缺少必填参数 --output-resolution")
+	}
+	return common.ValidateVideoExtensions([]string{opts.VideoPath})
+}
+
+// ValidateEraseSubtitleOptions validates the command shape.
+func ValidateEraseSubtitleOptions(opts *EraseSubtitleOptions) error {
+	if opts == nil || strings.TrimSpace(opts.VideoPath) == "" {
+		return fmt.Errorf("缺少必填参数 --video")
+	}
+	return common.ValidateVideoExtensions([]string{opts.VideoPath})
+}
+
+func uploadVideo(ctx context.Context, path string, runner *common.Runner) (string, error) {
+	expanded, err := common.ExpandPath(path)
+	if err != nil {
+		return "", err
+	}
+	result, err := common.UploadFile(ctx, common.UploadFileOptions{Path: expanded}, runner)
+	if err != nil {
+		return "", fmt.Errorf("上传视频失败: %w", err)
+	}
+	return result.AssetID, nil
+}
+
+func buildSuperResolutionSubmitRunBody(opts *SuperResolutionOptions, assetID string) map[string]any {
+	return map[string]any{
+		"agent_name": common.AgentNameVideoPart,
+		"message":    messageSuperResolution,
+		"video_part_tool_param": common.VideoPartToolParam{
+			MiniToolParam: &common.VideoMiniToolParam{
+				ToolName: toolVideoSuperResolution,
+				ToolParam: &common.VideoMiniToolPayload{
+					VideoSuperResolutionToolParam: &common.VideoSuperResolutionToolParam{
+						ToolVersion:      strings.TrimSpace(opts.ToolVersion),
+						Video:            &common.MediaAsset{PippitAssetID: assetID},
+						OutputResolution: strings.TrimSpace(opts.OutputResolution),
+					},
+				},
+			},
+		},
+	}
+}
+
+func buildEraseSubtitleSubmitRunBody(assetID string) map[string]any {
+	return map[string]any{
+		"agent_name": common.AgentNameVideoPart,
+		"message":    messageEraseSubtitle,
+		"video_part_tool_param": common.VideoPartToolParam{
+			MiniToolParam: &common.VideoMiniToolParam{
+				ToolName: toolEraseVideoSubtitle,
+				ToolParam: &common.VideoMiniToolPayload{
+					EraseVideoSubtitleToolParam: &common.EraseVideoSubtitleToolParam{
+						Video: &common.MediaAsset{PippitAssetID: assetID},
+					},
+				},
+			},
+		},
+	}
+}

package/internal/video_tool/video_tool_test.go

@@ -0,0 +1,54 @@
+package video_tool
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestValidateSuperResolutionOptions(t *testing.T) {
+	tests := []struct {
+		name         string
+		opts         *SuperResolutionOptions
+		wantContains string
+	}{
+		{name: "valid", opts: &SuperResolutionOptions{VideoPath: "source.mp4", OutputResolution: "1080p"}},
+		{name: "missing video", opts: &SuperResolutionOptions{OutputResolution: "1080p"}, wantContains: "--video"},
+		{name: "missing output resolution", opts: &SuperResolutionOptions{VideoPath: "source.mp4"}, wantContains: "--output-resolution"},
+		{name: "unsupported extension", opts: &SuperResolutionOptions{VideoPath: "source.txt", OutputResolution: "1080p"}, wantContains: "不支持的视频文件后缀"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := ValidateSuperResolutionOptions(tt.opts)
+			if tt.wantContains == "" {
+				if err != nil {
+					t.Fatalf("ValidateSuperResolutionOptions() error = %v, want nil", err)
+				}
+				return
+			}
+			if err == nil || !strings.Contains(err.Error(), tt.wantContains) {
+				t.Fatalf("ValidateSuperResolutionOptions() error = %v, want containing %q", err, tt.wantContains)
+			}
+		})
+	}
+}
+
+func TestValidateEraseSubtitleOptions(t *testing.T) {
+	if err := ValidateEraseSubtitleOptions(&EraseSubtitleOptions{VideoPath: "source.webm"}); err != nil {
+		t.Fatalf("ValidateEraseSubtitleOptions() error = %v, want nil", err)
+	}
+	err := ValidateEraseSubtitleOptions(&EraseSubtitleOptions{})
+	if err == nil || !strings.Contains(err.Error(), "--video") {
+		t.Fatalf("ValidateEraseSubtitleOptions() error = %v, want --video validation", err)
+	}
+}
+
+func TestSuperResolutionSemanticValuesRemainServiceOwned(t *testing.T) {
+	if err := ValidateSuperResolutionOptions(&SuperResolutionOptions{
+		VideoPath:        "source.mp4",
+		ToolVersion:      "future_version",
+		OutputResolution: "future_resolution",
+	}); err != nil {
+		t.Fatalf("ValidateSuperResolutionOptions() error = %v, want service-owned enum validation", err)
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pippit-dev/cli",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "Pippit CLI",
   "bin": {
     "pippit-tool-cli": "scripts/run.js"

package/skills/xyq-nest-skill/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: xyq-skill
-description: 通过小云雀的 AI 能力进行综合创作，支持生成和编辑图片/视频，并在用户明确要求图片或视频模型直出、指定图片或视频模型或直接调用 CLI 时使用 pippit-tool-cli generate-image / generate-video。覆盖文生图、文生视频、图生视频、视频编辑、风格转换、视频续写、视频复刻、TVC、宣传片、音乐 MV、产品广告、分镜和教育短视频等场景。当用户提到小云雀、xyq、上传参考图/视频/mp3或wav音频、查看生成进度时也应触发。短剧生成、续写、改写、人物设定和分集创作应使用 xyq-short-drama-skill，不在本技能中执行。
+description: 通过小云雀的 AI 能力进行综合创作，支持生成和编辑图片/视频，并在用户明确要求图片或视频模型直出、指定图片或视频模型或直接调用 CLI 时使用 pippit-tool-cli generate-image / generate-video；用户要求视频超分、提升视频清晰度、擦字幕或去字幕时，使用 video-super-resolution / erase-video-subtitle。覆盖文生图、文生视频、图生视频、首尾帧生视频、视频编辑、风格转换、视频续写、视频复刻、TVC、宣传片、音乐 MV、产品广告、分镜和教育短视频等场景。当用户提到小云雀、xyq、上传参考图/视频/mp3或wav音频、查看生成进度时也应触发。短剧生成、续写、改写、人物设定和分集创作应使用 xyq-short-drama-skill，不在本技能中执行。
 user-invocable: true
 metadata:
   {
@@ -17,7 +17,7 @@ metadata:
   }
 ---
 
-# 小云雀创作与图片/视频模型直出
+# 小云雀创作、图片/视频模型直出与视频处理
 
 通过 小云雀的API 创建会话、发送消息（生图、生视频、编辑视频等）、上传图片/视频/mp3或wav音频文件，并查询会话消息进展。
 
@@ -26,9 +26,10 @@ metadata:
 **平台核心能力：**
 - **生成**：文生图、文生视频、图生视频、视频续写
 - **编辑**：局部修改、元素替换、镜头调整、风格迁移
+- **视频处理**：视频超分、提升视频清晰度、擦字幕
 - **复杂创作**：复刻已有视频风格做 TVC/宣传片、用音乐生成 MV、产品展示片制作
 
-除“图片/视频模型直出”外，创作和编辑需求通过发送自然语言消息来完成，后端 Agent 会自主编排工作流。复杂任务耗时较长，需耐心轮询。
+除“图片/视频模型直出”和“视频超分/擦字幕”外，创作和编辑需求通过发送自然语言消息来完成，后端 Agent 会自主编排工作流。复杂任务耗时较长，需耐心轮询。
 
 ## 执行路由（必须先判断）
 
@@ -71,6 +72,7 @@ pippit-tool-cli query-result \
 
 - 用户明确说“视频模型直出”、“直接调模型”或“直接调用 CLI”。
 - 用户指定了具体视频模型（如 Seedance），并希望单次直接生成视频。
+- 用户明确要求“首尾帧生视频”、指定首帧和尾帧，或要求从第一张图过渡到第二张图。
 - 上游流程已明确将任务标记为 direct-model / 模型直出。
 
 执行原则：
@@ -78,13 +80,20 @@ pippit-tool-cli query-result \
 1. 执行前用 `command -v pippit-tool-cli` 确认 CLI 可用；不可用时报告阻塞，不要悄悄降级到会话 API。
 2. 真实提交会消耗 credits；如果用户本轮尚未明确确认生成，按“用户确认与反问”规则征得明确确认后再运行。
 3. 保留用户原始 prompt，不要自行扩写、润色、翻译或增加风格词。
-4. 只添加用户已经给出的 `--model`、`--duration`、`--ratio`、`--resolution`、`--image`、`--video`、`--audio` 参数；未给参数交给 CLI 默认值。
-5. `generate-video` 返回后，保存 `thread_id`、`run_id`，并立即向用户展示 `web_thread_link`。
-6. 每隔 10 秒调用 `query-result`，直到 `completed=true`。出现 `error_message` 时停止并报告；成功时展示并下载 `videos[].output_path`。
+4. 只添加用户已经给出的 `--model`、`--duration`、`--ratio`、`--resolution`、`--image`、`--video`、`--audio`、`--generate-type` 参数；未给参数交给 CLI 默认值。
+5. 首尾帧请求固定传 `--generate-type 1`，并按首帧、尾帧顺序传入两次 `--image`，不得重排。用户未明确两张图片的角色或缺少任一张时，先询问用户；不要在 skill 侧维护额外的 `generate_type` 枚举 allowlist，其他值原样交给服务端处理。
+6. `generate-video` 返回后，保存 `thread_id`、`run_id`，并立即向用户展示 `web_thread_link`。
+7. 每隔 10 秒调用 `query-result`，直到 `completed=true`。出现 `error_message` 时停止并报告；成功时展示并下载 `videos[].output_path`。
 
 ```bash
 pippit-tool-cli generate-video --prompt "用户原始描述"
 
+pippit-tool-cli generate-video \
+  --prompt "用户原始描述" \
+  --image FIRST_FRAME_PATH \
+  --image LAST_FRAME_PATH \
+  --generate-type 1
+
 pippit-tool-cli query-result \
   --thread-id THREAD_ID \
   --run-id RUN_ID \
@@ -93,11 +102,40 @@ pippit-tool-cli query-result \
 
 `--image` 最多重复 9 次，`--video` 和 `--audio` 最多各重复 3 次。
 
-### 路由 C：小云雀后端 Agent 编排
+### 路由 C：视频超分和擦字幕
+
+用户明确要求视频超分、提升视频清晰度、擦字幕或去字幕时，直接调用对应的 `pippit-tool-cli` 视频处理命令，不要改走 `submit_run.py`：
+
+- 视频超分、提升视频清晰度：`video-super-resolution`
+- 擦字幕、去字幕：`erase-video-subtitle`
+
+执行原则：
+
+1. 执行前用 `command -v pippit-tool-cli` 确认 CLI 可用；不可用时报告阻塞，不要悄悄降级到会话 API。
+2. 真实提交会消耗 credits；如果用户本轮尚未明确确认处理，按“用户确认与反问”规则征得明确确认后再运行。
+3. 把用户提供的本地视频路径和处理参数直接交给对应 CLI；缺少必填输入时先询问用户。
+4. 命令返回后，保存 `thread_id`、`run_id`，并立即向用户展示 `web_thread_link`。
+5. 每隔 10 秒调用 `query-result`，直到 `completed=true`。出现 `error_message` 时停止并报告；成功时展示并下载 `videos[].output_path`。
+
+```bash
+pippit-tool-cli video-super-resolution \
+  --video VIDEO_PATH \
+  --output-resolution OUTPUT_RESOLUTION
+
+pippit-tool-cli erase-video-subtitle \
+  --video VIDEO_PATH
+
+pippit-tool-cli query-result \
+  --thread-id THREAD_ID \
+  --run-id RUN_ID \
+  --download-dir OUTPUT_DIR
+```
+
+### 路由 D：小云雀后端 Agent 编排
 
-需要意图确认、脚本/分镜拆解、MV、TVC、局部编辑、复杂参考素材编排，或者用户未明确要求模型直出时，继续使用本技能内置的 `submit_run.py` / `get_thread.py` 会话工作流。
+需要意图确认、脚本/分镜拆解、MV、TVC、局部编辑、复杂参考素材编排，或者用户未明确要求模型直出时，继续使用本技能内置的 `submit_run.py` / `get_thread.py` 会话工作流；明确的首尾帧请求走路由 B，明确的视频超分和擦字幕请求走路由 C。
 
-### 路由 D：短剧工作流
+### 路由 E：短剧工作流
 
 用户要求短剧生成、续写、改写、剧情扩展、人物设定、分集草稿或短剧会话文件处理时，停止本技能流程并转交 `xyq-short-drama-skill`，不要用 `submit_run.py`、`generate-image` 或 `generate-video` 假装执行完整短剧流程。
 
@@ -122,6 +160,7 @@ pippit-tool-cli query-result \
 4. **下载结果** - 将会话中生成的图片/视频批量下载到本地，支持指定输出目录和文件名前缀。
 5. **图片模型直出** - 使用 `pippit-tool-cli generate-image` 直接调用图片模型，使用 `query-result` 查询并下载图片结果。
 6. **视频模型直出** - 使用 `pippit-tool-cli generate-video` 直接调用视频模型，使用 `query-result` 查询并下载视频结果。
+7. **视频处理** - 使用 `pippit-tool-cli video-super-resolution` 或 `erase-video-subtitle` 处理本地视频，使用 `query-result` 查询并下载视频结果。
 
 
 ## 前置要求
@@ -132,7 +171,7 @@ export XYQ_ACCESS_KEY="your-access-key"
 
 可选：`XYQ_OPENAPI_BASE` 或 `XYQ_BASE_URL`，默认 `https://xyq.jianying.com`。
 
-会话 API 路由无需安装额外依赖，仅使用 Python 标准库。图片/视频模型直出路由额外要求 `pippit-tool-cli` 在 `PATH` 中可用。
+会话 API 路由无需安装额外依赖，仅使用 Python 标准库。图片/视频模型直出和视频处理路由额外要求 `pippit-tool-cli` 在 `PATH` 中可用。
 
 ## 使用方法
 
@@ -215,7 +254,18 @@ python3 {baseDir}/scripts/download_results.py --urls URL1 URL2 URL3 --output-dir
 6. completed=true 后展示并下载 images[].output_path；出现 error_message 时停止并报告
 ```
 
-### 场景 3：用户提供图片/视频/音频要求编辑修改或作为参考（如"参考这个视频做一个新的"、"用这首歌做MV"）
+### 场景 3：用户明确要求视频模型直出（含首尾帧）
+
+```
+1. command -v pippit-tool-cli  →  确认 CLI 可用
+2. 普通视频模型直出：pippit-tool-cli generate-video --prompt "用户原始描述" [仅添加用户已给出的其他参数]
+3. 首尾帧直出：确认两张图片的首帧/尾帧角色，按顺序执行 generate-video --image FIRST_FRAME_PATH --image LAST_FRAME_PATH --generate-type 1
+4. 拿到 thread_id、run_id 和 web_thread_link，立即展示 web_thread_link
+5. 每隔 10 秒调用 query-result --thread-id THREAD_ID --run-id RUN_ID --download-dir OUTPUT_DIR
+6. completed=true 后展示并下载 videos[].output_path；出现 error_message 时停止并报告
+```
+
+### 场景 4：用户提供图片/视频/音频要求编辑修改或作为参考（如"参考这个视频做一个新的"、"用这首歌做MV"）
 
 ```
 1. upload_file.py /path/to/video.mp4  →  拿到 asset_id1
@@ -226,7 +276,7 @@ python3 {baseDir}/scripts/download_results.py --urls URL1 URL2 URL3 --output-dir
 
 用户给了文件路径 + 编辑指令 = 先上传文件，再把编辑指令和 所有asset_id 一起发送。
 
-### 场景 4：用户提供参考图/视频/音频要求生成新内容
+### 场景 5：用户提供参考图/视频/音频要求生成新内容
 
 ```
 1. upload_file.py /path/to/ref1.png  →  拿到 asset_id1
@@ -237,13 +287,23 @@ python3 {baseDir}/scripts/download_results.py --urls URL1 URL2 URL3 --output-dir
 6. 后续同场景 1 的步骤 2-6
 ```
 
-### 场景 5：在已有会话中追加新需求
+### 场景 6：在已有会话中追加新需求
 
 ```
 1. submit_run.py --message "新的描述" --thread-id THREAD_ID  →  拿到 thread_id、run_id、web_thread_link
 2. 后续同场景 1 的步骤 2-6
 ```
 
+### 场景 7：用户要求视频超分或擦字幕
+
+```
+1. command -v pippit-tool-cli  →  确认 CLI 可用
+2. 根据用户意图调用 video-super-resolution 或 erase-video-subtitle，并传入用户提供的本地视频路径和处理参数
+3. 拿到 thread_id、run_id 和 web_thread_link，立即展示 web_thread_link
+4. 每隔 10 秒调用 query-result --thread-id THREAD_ID --run-id RUN_ID --download-dir OUTPUT_DIR
+5. completed=true 后展示并下载 videos[].output_path；出现 error_message 时停止并报告
+```
+
 ### 轮询策略
 
 - **间隔**：每 10 秒查询一次
@@ -314,12 +374,12 @@ python3 {baseDir}/scripts/download_results.py --urls URL1 URL2 URL3 --output-dir
 
 ## 核心原则：用户侧不做创作，只做传话
 
-你（用户侧 Agent）的职责是**搬运工**，不是创作者。会话 API 路由由后端 Agent 负责理解需求、拆解分镜、编排工作流、选模型、写 prompt；图片/视频模型直出路由把用户原始参数传给 CLI。你要做的是：
+你（用户侧 Agent）的职责是**搬运工**，不是创作者。会话 API 路由由后端 Agent 负责理解需求、拆解分镜、编排工作流、选模型、写 prompt；图片/视频模型直出和视频处理路由把用户原始参数传给 CLI。你要做的是：
 
-1. **准备素材**：会话 API 路由用 `upload_file.py` 把本地文件转为 asset_id；图片/视频模型直出路由把本地路径直接交给 CLI 的 `--image` / `--video` / `--audio` 参数
-2. **提交任务**：先按“执行路由”判断；图片模型直出调用 `pippit-tool-cli generate-image`，视频模型直出调用 `pippit-tool-cli generate-video`，其余任务把用户的原始描述 + asset_id 原封不动发给 `submit_run.py`
+1. **准备素材**：会话 API 路由用 `upload_file.py` 把本地文件转为 asset_id；图片/视频模型直出和视频处理路由把本地路径直接交给对应 CLI；首尾帧任务固定传 `--generate-type 1` 并保持首帧、尾帧顺序
+2. **提交任务**：先按“执行路由”判断；图片模型直出调用 `pippit-tool-cli generate-image`，视频模型直出调用 `pippit-tool-cli generate-video`，视频超分和擦字幕调用对应的视频处理命令，其余任务把用户的原始描述 + asset_id 原封不动发给 `submit_run.py`
 3. **传话**：根据 `get_thread.py` 返回的消息列表，展示过程中的意图询问、创作信息等
-4. **取件**：会话 API 路由用 `get_thread.py` 轮询，图片/视频模型直出路由用 `query-result` 轮询 → 检查结果 → 下载产物 → 结果展示给用户
+4. **取件**：会话 API 路由用 `get_thread.py` 轮询，图片/视频模型直出和视频处理路由用 `query-result` 轮询 → 检查结果 → 下载产物 → 结果展示给用户
 
 **绝对不要做的事：**
 - 不要替用户扩写、润色、翻译 prompt（用户说"帮我推演分镜"，就直接传"帮我推演分镜"，不要自己先写个分镜表再逐条发）
@@ -355,4 +415,4 @@ python3 {baseDir}/scripts/download_results.py --urls URL1 URL2 URL3 --output-dir
 - 查询会话时可用 --after-seq 做增量拉取，便于轮询新消息（含 assistant 回复与生图/生视频结果）
 - 上传文件仅支持图片（image/*）、视频（video/*）和 `.mp3/.wav` 音频文件，其他类型会被拒绝，文件大小须在 200MB 以下
 - 生成过程中将过程中的创作信息展示给用户；任务完成后给出**产物结果（图片/视频）URL链接**和下载的**本地文件列表**。
-- 图片/视频模型直出任务必须保留 `generate-image` / `generate-video` 返回的 `thread_id` / `run_id`，并用 `query-result` 取回最终图片或视频。
+- 图片/视频模型直出和视频处理任务必须保留 CLI 返回的 `thread_id` / `run_id`，并用 `query-result` 取回最终图片或视频。