@pippit-dev/cli 1.0.1 → 1.0.2

package/internal/common/error_log.go

@@ -1,6 +1,8 @@
 package common
 
 import (
+	"errors"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -21,6 +23,42 @@ type errorLogEntry struct {
 	Error   string            `json:"error"`
 }
 
+type logIDCarrier interface {
+	LogID() string
+}
+
+type LogIDError struct {
+	Message string
+	ID      string
+}
+
+func NewLogIDError(message string, logID string) error {
+	return &LogIDError{
+		Message: strings.TrimSpace(message),
+		ID:      strings.TrimSpace(logID),
+	}
+}
+
+func (e *LogIDError) Error() string {
+	if e == nil {
+		return ""
+	}
+	if e.ID == "" {
+		return e.Message
+	}
+	if e.Message == "" {
+		return fmt.Sprintf("log_id=%s", e.ID)
+	}
+	return fmt.Sprintf("%s log_id=%s", e.Message, e.ID)
+}
+
+func (e *LogIDError) LogID() string {
+	if e == nil {
+		return ""
+	}
+	return strings.TrimSpace(e.ID)
+}
+
 // AppendDailyErrorLog appends one CLI error record to ~/.pippit_tool_cli/logs/yyyy-mm-dd.log.
 func AppendDailyErrorLog(command string, err error, fields map[string]string) error {
 	if err == nil {
@@ -38,7 +76,7 @@ func AppendDailyErrorLog(command string, err error, fields map[string]string) er
 	entry := errorLogEntry{
 		Time:    now.Format(time.RFC3339),
 		Command: strings.TrimSpace(command),
-		Fields:  cleanErrorLogFields(fields),
+		Fields:  cleanErrorLogFields(addLogIDField(fields, err)),
 		Error:   err.Error(),
 	}
 	data, marshalErr := sonic.Marshal(entry)
@@ -55,6 +93,29 @@ func AppendDailyErrorLog(command string, err error, fields map[string]string) er
 	return writeErr
 }
 
+func addLogIDField(fields map[string]string, err error) map[string]string {
+	logID := logIDFromError(err)
+	if logID == "" {
+		return fields
+	}
+	next := make(map[string]string, len(fields)+1)
+	for key, value := range fields {
+		next[key] = value
+	}
+	if strings.TrimSpace(next["log_id"]) == "" {
+		next["log_id"] = logID
+	}
+	return next
+}
+
+func logIDFromError(err error) string {
+	var carrier logIDCarrier
+	if errors.As(err, &carrier) {
+		return strings.TrimSpace(carrier.LogID())
+	}
+	return ""
+}
+
 func dailyErrorLogPath(now time.Time) (string, error) {
 	home, err := os.UserHomeDir()
 	if err != nil {

package/internal/common/error_log_test.go

@@ -59,3 +59,33 @@ func TestAppendDailyErrorLog(t *testing.T) {
 		t.Fatalf("access_key should be omitted from log fields: %#v", fields)
 	}
 }
+
+func TestAppendDailyErrorLogAddsLogID(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
+
+	err := AppendDailyErrorLog("query-result", NewLogIDError("request failed", "log_123"), map[string]string{
+		"thread_id": "thread_123",
+	})
+	if err != nil {
+		t.Fatalf("AppendDailyErrorLog(): %v", err)
+	}
+
+	path := filepath.Join(home, ".pippit_tool_cli", "logs", time.Now().Format("2006-01-02")+".log")
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("ReadFile(%s): %v", path, err)
+	}
+	var entry map[string]any
+	if err := sonic.Unmarshal([]byte(strings.TrimSpace(string(data))), &entry); err != nil {
+		t.Fatalf("decode log line: %v\n%s", err, string(data))
+	}
+	fields, ok := entry["fields"].(map[string]any)
+	if !ok {
+		t.Fatalf("fields = %#v, want object", entry["fields"])
+	}
+	if fields["log_id"] != "log_123" {
+		t.Fatalf("log_id = %v, want log_123", fields["log_id"])
+	}
+}

package/internal/common/get_thread.go

@@ -2,61 +2,75 @@ package common
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 
 	"github.com/Pippit-dev/pippit-cli/internal/config"
 )
 
-const getThreadVersionV2 = "v2"
+const GetThreadVersionV2 = "v2"
 
 // GetThreadOptions is the stable command-facing request shape for thread lookup.
 type GetThreadOptions struct {
 	ThreadID string `json:"thread_id"`
 	RunID    string `json:"run_id,omitempty"`
+	Version  string `json:"version,omitempty"`
 }
 
 // GetThreadResult is the parsed get_thread response used by `pippit-tool-cli get-thread`.
 type GetThreadResult struct {
 	ReadableText string `json:"readable_text"`
+	RawData      []byte `json:"-"`
 }
 
 type getThreadResponse struct {
-	Ret    string `json:"ret"`
-	Errmsg string `json:"errmsg"`
-	Data   struct {
-		ReadableText string `json:"readable_text"`
-	} `json:"data"`
+	Ret    string          `json:"ret"`
+	Errmsg string          `json:"errmsg"`
+	LogID  string          `json:"log_id"`
+	Data   json.RawMessage `json:"data"`
 }
 
 func GetThread(ctx context.Context, opts *GetThreadOptions, runner *Runner) (*GetThreadResult, error) {
 	if runner == nil || runner.Client == nil {
-		return nil, fmt.Errorf("get_thread runner client is required")
+		return nil, fmt.Errorf("get_thread 运行器客户端缺失")
 	}
 
 	body := map[string]any{
 		"thread_id": opts.ThreadID,
-		"version":   getThreadVersionV2,
 	}
 	if opts.RunID != "" {
 		body["run_id"] = opts.RunID
 	}
+	if opts.Version != "" {
+		body["version"] = opts.Version
+	}
 
 	var resp getThreadResponse
 	if err := runner.Client.SendRequest(ctx, getThreadPath(runner), body, &resp); err != nil {
-		return nil, fmt.Errorf("get_thread request failed: %w", err)
+		return nil, fmt.Errorf("获取线程请求失败: %w", err)
 	}
 	if resp.Ret != "0" {
 		if resp.Errmsg == "" {
-			resp.Errmsg = "unknown error"
+			resp.Errmsg = "未知错误"
 		}
-		return nil, fmt.Errorf("get_thread failed: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
+		return nil, NewLogIDError(fmt.Sprintf("获取线程请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg), resp.LogID)
+	}
+	if len(resp.Data) == 0 {
+		return nil, fmt.Errorf("get_thread 响应缺少 data")
 	}
-	if resp.Data.ReadableText == "" {
-		return nil, fmt.Errorf("get_thread response missing data.readable_text")
+	readable := struct {
+		ReadableText string `json:"readable_text"`
+	}{}
+	if opts.Version == GetThreadVersionV2 {
+		_ = json.Unmarshal(resp.Data, &readable)
+		if readable.ReadableText == "" {
+			return nil, fmt.Errorf("get_thread v2 响应缺少 data.readable_text")
+		}
 	}
 
 	return &GetThreadResult{
-		ReadableText: resp.Data.ReadableText,
+		ReadableText: readable.ReadableText,
+		RawData:      resp.Data,
 	}, nil
 }
 

package/internal/common/get_thread_test.go

@@ -0,0 +1,74 @@
+package common
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/bytedance/sonic"
+)
+
+type getThreadFakeClient struct {
+	response string
+}
+
+func (c getThreadFakeClient) SendRequest(_ context.Context, _ string, _ any, out any) error {
+	return sonic.Unmarshal([]byte(c.response), out)
+}
+
+func (c getThreadFakeClient) SendRequestWithHeaders(ctx context.Context, path string, body any, _ map[string]string, out any) error {
+	return c.SendRequest(ctx, path, body, out)
+}
+
+func (c getThreadFakeClient) SendMultipartRequest(context.Context, string, map[string]string, MultipartFile, any) error {
+	return nil
+}
+
+func TestGetThreadAllowsStructuredDataWithoutVersion(t *testing.T) {
+	result, err := GetThread(context.Background(), &GetThreadOptions{
+		ThreadID: "thread_123",
+		RunID:    "run_456",
+	}, &Runner{
+		Client: getThreadFakeClient{response: `{"ret":"0","errmsg":"","data":{"thread":{"thread_id":"thread_123","run_list":[{"run_id":"run_456","state":3}]}}}`},
+	})
+	if err != nil {
+		t.Fatalf("GetThread() error = %v", err)
+	}
+	if result.ReadableText != "" {
+		t.Fatalf("ReadableText = %q, want empty for non-v2 response", result.ReadableText)
+	}
+	if !strings.Contains(string(result.RawData), `"thread"`) {
+		t.Fatalf("RawData = %s, want structured thread data", string(result.RawData))
+	}
+}
+
+func TestGetThreadRequiresRetZero(t *testing.T) {
+	_, err := GetThread(context.Background(), &GetThreadOptions{
+		ThreadID: "thread_123",
+		RunID:    "run_456",
+	}, &Runner{
+		Client: getThreadFakeClient{response: `{"errmsg":"","data":{"thread":{"thread_id":"thread_123"}}}`},
+	})
+	if err == nil {
+		t.Fatal("GetThread() error = nil, want missing ret validation")
+	}
+	if !strings.Contains(err.Error(), "获取线程请求返回失败: ret=") {
+		t.Fatalf("error = %q, want missing ret validation", err)
+	}
+}
+
+func TestGetThreadV2RequiresReadableText(t *testing.T) {
+	_, err := GetThread(context.Background(), &GetThreadOptions{
+		ThreadID: "thread_123",
+		RunID:    "run_456",
+		Version:  GetThreadVersionV2,
+	}, &Runner{
+		Client: getThreadFakeClient{response: `{"ret":"0","errmsg":"","data":{"thread":{"thread_id":"thread_123"}}}`},
+	})
+	if err == nil {
+		t.Fatal("GetThread() error = nil, want v2 readable_text validation")
+	}
+	if !strings.Contains(err.Error(), "get_thread v2 响应缺少 data.readable_text") {
+		t.Fatalf("error = %q, want readable_text validation", err)
+	}
+}

package/{cmd → internal/common}/json.go

@@ -1,4 +1,4 @@
-package cmd
+package common
 
 import (
 	"fmt"
@@ -7,7 +7,8 @@ import (
 	"github.com/bytedance/sonic"
 )
 
-func writeJSON(w io.Writer, v any) error {
+// WriteJSON writes v as one JSON line.
+func WriteJSON(w io.Writer, v any) error {
 	data, err := sonic.Marshal(v)
 	if err != nil {
 		return err

package/internal/common/list_thread_file.go

@@ -51,7 +51,7 @@ type threadFileResponse struct {
 
 func ListThreadFile(ctx context.Context, opts *ListThreadFileOptions, runner *Runner) (*ListThreadFileResult, error) {
 	if runner == nil || runner.Client == nil {
-		return nil, fmt.Errorf("list_thread_file runner client is required")
+		return nil, fmt.Errorf("list_thread_file 运行器客户端缺失")
 	}
 
 	body := map[string]any{
@@ -66,13 +66,13 @@ func ListThreadFile(ctx context.Context, opts *ListThreadFileOptions, runner *Ru
 
 	var resp listThreadFileResponse
 	if err := runner.Client.SendRequest(ctx, listThreadFilePath(runner), body, &resp); err != nil {
-		return nil, fmt.Errorf("list_thread_file request failed: %w", err)
+		return nil, fmt.Errorf("获取线程文件列表请求失败: %w", err)
 	}
 	if resp.Ret != "0" {
 		if resp.Errmsg == "" {
-			resp.Errmsg = "unknown error"
+			resp.Errmsg = "未知错误"
 		}
-		return nil, fmt.Errorf("list_thread_file failed: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
+		return nil, fmt.Errorf("获取线程文件列表请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
 	}
 
 	files := make([]*ThreadFile, 0, len(resp.Data.Files))
@@ -101,9 +101,9 @@ func listThreadFileMessage(total int64, pageNum int) string {
 	}
 	var message string
 	if total >= MaxListThreadFilePageSize {
-		message = fmt.Sprintf("total reached %d; query the next page with --page-num %d", MaxListThreadFilePageSize, pageNum+1)
+		message = fmt.Sprintf("文件总数已达到 %d；请使用 --page-num %d 查询下一页", MaxListThreadFilePageSize, pageNum+1)
 	} else {
-		message = fmt.Sprintf("total is below %d; continue querying with current --page-num %d", MaxListThreadFilePageSize, pageNum)
+		message = fmt.Sprintf("文件总数小于 %d；继续使用当前 --page-num %d 查询", MaxListThreadFilePageSize, pageNum)
 	}
 	return fmt.Sprintf("%s\n- %s\n%s", start, message, end)
 }

package/internal/common/submit_run.go

@@ -0,0 +1,29 @@
+package common
+
+import "github.com/Pippit-dev/pippit-cli/internal/config"
+
+// SubmitRunResponse is the shared response envelope returned by submit_run.
+type SubmitRunResponse struct {
+	Ret    string                `json:"ret"`
+	Errmsg string                `json:"errmsg"`
+	LogID  string                `json:"log_id"`
+	Data   SubmitRunResponseData `json:"data"`
+}
+
+type SubmitRunResponseData struct {
+	WebThreadLink string               `json:"web_thread_link"`
+	Run           SubmitRunResponseRun `json:"run"`
+}
+
+type SubmitRunResponseRun struct {
+	ThreadID string `json:"thread_id"`
+	RunID    string `json:"run_id"`
+}
+
+// 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 != "" {
+		return runner.Config.Paths.SubmitRun
+	}
+	return config.SubmitRunPath
+}

package/internal/common/upload_file.go

@@ -2,6 +2,7 @@ package common
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"mime"
 	"os"
@@ -17,7 +18,7 @@ type UploadFileOptions struct {
 	FileName string `json:"file_name"`
 }
 
-// UploadFileResult is the JSON envelope printed by `pippit-tool-cli upload-file`.
+// UploadFileResult is the JSON envelope printed by `pippit-tool-cli short-drama +upload-file`.
 type UploadFileResult struct {
 	AssetID string `json:"asset_id"`
 }
@@ -35,36 +36,39 @@ type uploadFileResponse struct {
 
 const uploadFileFieldName = "file"
 
-var allowedUploadExtensions = map[string]bool{
-	".doc":  true,
-	".docx": true,
-	".txt":  true,
-}
-
 func UploadFile(ctx context.Context, opts UploadFileOptions, runner *Runner) (*UploadFileResult, error) {
 	if err := ctx.Err(); err != nil {
-		return nil, err
+		if errors.Is(err, context.Canceled) {
+			return nil, fmt.Errorf("上传文件已取消")
+		}
+		if errors.Is(err, context.DeadlineExceeded) {
+			return nil, fmt.Errorf("上传文件超时")
+		}
+		return nil, fmt.Errorf("上传文件上下文异常: %w", err)
 	}
 	if runner == nil || runner.Client == nil {
-		return nil, fmt.Errorf("upload_file runner client is required")
+		return nil, fmt.Errorf("上传文件运行器客户端缺失")
 	}
 
 	path := strings.TrimSpace(opts.Path)
 	if path == "" {
-		return nil, fmt.Errorf("upload file path is required")
+		return nil, fmt.Errorf("上传文件路径不能为空")
 	}
 	info, err := os.Stat(path)
 	if err != nil {
-		return nil, fmt.Errorf("stat upload file: %w", err)
+		if os.IsNotExist(err) {
+			return nil, fmt.Errorf("上传文件不存在: %s", path)
+		}
+		if os.IsPermission(err) {
+			return nil, fmt.Errorf("没有权限读取上传文件: %s", path)
+		}
+		return nil, fmt.Errorf("获取上传文件信息失败: %w", err)
 	}
 	if info.IsDir() {
-		return nil, fmt.Errorf("upload path %q is a directory", path)
+		return nil, fmt.Errorf("上传路径 %q 是目录，请指定文件", path)
 	}
 
 	ext := strings.ToLower(filepath.Ext(path))
-	if !allowedUploadExtensions[ext] {
-		return nil, fmt.Errorf("unsupported file extension %q; only .doc, .docx, and .txt uploads are supported", ext)
-	}
 	fileName := filepath.Base(path)
 	contentType := mime.TypeByExtension(ext)
 
@@ -75,13 +79,13 @@ func UploadFile(ctx context.Context, opts UploadFileOptions, runner *Runner) (*U
 		FileName:    fileName,
 		ContentType: contentType,
 	}, &resp); err != nil {
-		return nil, fmt.Errorf("upload_file request failed: %w", err)
+		return nil, fmt.Errorf("上传文件请求失败: %w", err)
 	}
 	if resp.Ret != "0" {
 		if resp.Errmsg == "" {
-			resp.Errmsg = "unknown error"
+			resp.Errmsg = "未知错误"
 		}
-		return nil, fmt.Errorf("upload_file failed: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
+		return nil, fmt.Errorf("上传文件请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg)
 	}
 
 	assetID := strings.TrimSpace(resp.Data.PippitAssetID)
@@ -89,7 +93,7 @@ func UploadFile(ctx context.Context, opts UploadFileOptions, runner *Runner) (*U
 		assetID = strings.TrimSpace(resp.Data.AssetID)
 	}
 	if assetID == "" {
-		return nil, fmt.Errorf("upload_file response missing pippit_asset_id")
+		return nil, fmt.Errorf("上传文件响应缺少 pippit_asset_id")
 	}
 
 	return &UploadFileResult{

package/internal/config/config.go

@@ -8,7 +8,7 @@ import (
 
 const (
 	DefaultBaseURL              = "https://xyq.jianying.com"
-	DefaultHTTPTimeout          = 30 * time.Second
+	DefaultHTTPTimeout          = 30 * time.Minute
 	DefaultAuthTTL              = 30 * time.Second
 	DefaultOAuthClientKey       = "mock-cli"
 	DefaultOAuthBaseURL         = "https://passport.bytedance.com"

package/internal/generate_video/generate_video.go

@@ -0,0 +1,199 @@
+package generate_video
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+)
+
+const (
+	agentNameVideoPart = "pippit_video_part_agent"
+	maxReferenceImages = 9
+	maxReferenceVideos = 3
+)
+
+var (
+	allowedImageExtensionList = []string{".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".svg"}
+	allowedVideoExtensionList = []string{".mp4", ".avi", ".mov", ".wmv", ".flv", ".webm", ".mkv", ".m4v"}
+	allowedImageExtensions    = makeExtensionSet(allowedImageExtensionList)
+	allowedVideoExtensions    = makeExtensionSet(allowedVideoExtensionList)
+)
+
+// Options is the stable command-facing request shape for generate-video.
+type Options struct {
+	Prompt      string
+	ImagePaths  []string
+	VideoPaths  []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"`
+	Model       string       `json:"model,omitempty"`
+	Resolution  string       `json:"resolution,omitempty"`
+}
+
+// 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"`
+}
+
+func Run(ctx context.Context, opts *Options, runner *common.Runner) (*Result, error) {
+	if runner == nil || runner.Client == nil {
+		return nil, fmt.Errorf("generate-video 运行器客户端缺失")
+	}
+	if err := ValidateOptions(opts); err != nil {
+		return nil, err
+	}
+
+	imageAssetIDs, err := uploadMediaList(ctx, opts.ImagePaths, runner)
+	if err != nil {
+		return nil, fmt.Errorf("上传图片失败: %w", err)
+	}
+	videoAssetIDs, err := uploadMediaList(ctx, opts.VideoPaths, runner)
+	if err != nil {
+		return nil, fmt.Errorf("上传视频失败: %w", err)
+	}
+
+	body := buildSubmitRunBody(opts, imageAssetIDs, videoAssetIDs)
+
+	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
+}
+
+func ValidateOptions(opts *Options) error {
+	if opts == nil {
+		return fmt.Errorf("缺少必填参数 --prompt")
+	}
+	if strings.TrimSpace(opts.Prompt) == "" {
+		return fmt.Errorf("缺少必填参数 --prompt")
+	}
+	if len(opts.ImagePaths) > maxReferenceImages {
+		return fmt.Errorf("参考图片最多支持 %d 个，当前传入 %d 个", maxReferenceImages, len(opts.ImagePaths))
+	}
+	if len(opts.VideoPaths) > maxReferenceVideos {
+		return fmt.Errorf("参考视频最多支持 %d 个，当前传入 %d 个", maxReferenceVideos, len(opts.VideoPaths))
+	}
+	if err := validateMediaExtensions("图片", opts.ImagePaths, allowedImageExtensions, allowedImageExtensionList); err != nil {
+		return err
+	}
+	if err := validateMediaExtensions("视频", opts.VideoPaths, allowedVideoExtensions, allowedVideoExtensionList); err != nil {
+		return err
+	}
+	return nil
+}
+
+func validateMediaExtensions(kind string, paths []string, allowed map[string]struct{}, allowedList []string) error {
+	for _, path := range paths {
+		ext := strings.ToLower(filepath.Ext(strings.TrimSpace(path)))
+		if _, ok := allowed[ext]; !ok {
+			return fmt.Errorf("不支持的%s文件后缀 %q，文件：%q；支持的后缀：%s", kind, ext, path, strings.Join(allowedList, ", "))
+		}
+	}
+	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)
+		if err != nil {
+			return nil, err
+		}
+		result, err := common.UploadFile(ctx, common.UploadFileOptions{Path: expanded}, runner)
+		if err != nil {
+			return nil, err
+		}
+		assetIDs = append(assetIDs, result.AssetID)
+	}
+	return assetIDs, nil
+}
+
+func buildSubmitRunBody(opts *Options, imageAssetIDs []string, videoAssetIDs []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),
+		Model:       strings.TrimSpace(opts.Model),
+		Resolution:  strings.TrimSpace(opts.Resolution),
+	}
+
+	return map[string]any{
+		"agent_name":            agentNameVideoPart,
+		"message":               strings.TrimSpace(opts.Prompt),
+		"video_part_tool_param": param,
+	}
+}
+
+func assetRefs(assetIDs []string) []mediaAsset {
+	if len(assetIDs) == 0 {
+		return nil
+	}
+	refs := make([]mediaAsset, 0, len(assetIDs))
+	for _, assetID := range assetIDs {
+		refs = append(refs, 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
+}