@pippit-dev/cli 1.0.1 → 1.0.2

package/README.md

@@ -196,7 +196,7 @@ npx @pippit-dev/cli@latest install
 export XYQ_ACCESS_KEY="<access-key>"
 pippit-tool-cli --version
 pippit-tool-cli short-drama +submit-run --message "写一个赛博朋克短剧开头"
-pippit-tool-cli upload-file --path ./reference.doc
+pippit-tool-cli short-drama +upload-file --path ./reference.doc
 pippit-tool-cli get-thread --thread-id thread_123 --run-id run_456
 pippit-tool-cli list-thread-file --thread-id thread_123 --page-num 1 --page-size 200
 pippit-tool-cli download-result --output-path ./thread_123/results/result.mp4 --url URL --updated-at 1779716734
@@ -205,15 +205,45 @@ pippit-tool-cli download-result --output-path ./thread_123/results/result.mp4 --
 `+submit-run`: 输出 `thread_id`、`run_id` 和 `web_thread_link`；其中 `--message` 为必填参数。
 `get-thread`: 请求中带 `version=v2`，并输出 `readable_text`。
 `list-thread-file`: 输出会话文件列表、分页提示和可直接传给下载命令的 `file_path`。
-`upload-file`: 输出返回的 `asset_id`。 当前仅支持 `.doc`、`.docx` 和 `.txt` 文件。
+`+upload-file`: 输出返回的 `asset_id`。 当前仅支持 `.doc`、`.docx` 和 `.txt` 文件。
 `download-result`: 会把结果 URL 下载到 `--output-path` 指定的文件路径；传入 `--updated-at` 后，如果本地文件早于该时间戳会覆盖更新，否则跳过。
 
 短剧命令的错误日志会追加写入本地每日日志文件：`~/.pippit_tool_cli/logs/yyyy-mm-dd.log`。日志路径会基于当前用户主目录和系统路径分隔符生成，因此可在 macOS、Linux 和 Windows 上使用。
 
+## 生视频 CLI
+
+`generate-video` 会上传本地参考图片和视频，然后向视频片段 Agent 提交生视频请求：
+
+```bash
+pippit-tool-cli generate-video \
+  --prompt "做个小猫视频" \
+  --image "~/images/cat1.jpg" \
+  --image "~/images/cat2.jpg" \
+  --video "~/images/video1.mp4" \
+  --video "~/images/video2.mp4" \
+  --duration 5 \
+  --ratio "9:16" \
+  --model "seedance2.0_direct" \
+  --resolution "720p"
+```
+
+命令输出 `thread_id`、`run_id` 和 `web_thread_link`。提交生视频 HTTP 请求时，参考图和参考视频会使用上传接口返回的 `pippit_asset_id`。图片最多 9 张，支持 `.jpg`、`.jpeg`、`.png`、`.gif`、`.bmp`、`.webp`、`.svg`；视频最多 3 个，支持 `.mp4`、`.avi`、`.mov`、`.wmv`、`.flv`、`.webm`、`.mkv`、`.m4v`。普通用户支持模型 `seedance2.0_direct` 和 `seedance2.0_fast_direct`；VIP 用户额外支持 `seedance2.0_vision` 和 `seedance2.0_fast_vision`。模型、比例、分辨率、素材数量等参数的语义校验当前预留在后续实现。
+
+查询并下载生视频结果：
+
+```bash
+pippit-tool-cli query-result \
+  --thread-id "skill_xxx" \
+  --run-id "skill_xxx" \
+  --download-dir "./output"
+```
+
+`query-result` 会查询指定 Run；Run 完成后下载视频产物并输出本地结果路径，未完成时输出当前状态和重试提示。
+
 ## HTTP 客户端
 
 命令模块通过 `common.Runner` 发起服务调用。运行时配置，例如基础地址、HTTP 超时时间和接口路径，由 `internal/config` 加载，并在运行器中与 `common.Client` 组合使用。
 
 ## 鉴权
 
-`short-drama +submit-run`、`get-thread`、`list-thread-file`、`upload-file` 以及 `xyq-skill` Python 脚本都使用 `Authorization: Bearer <XYQ_ACCESS_KEY>` 鉴权。OAuth 命令代码仍保留在仓库中，但短剧运行时请求不使用 OAuth。
+`short-drama +submit-run`、`get-thread`、`list-thread-file`、`short-drama +upload-file` 以及 `xyq-skill` Python 脚本都使用 `Authorization: Bearer <XYQ_ACCESS_KEY>` 鉴权。OAuth 命令代码仍保留在仓库中，但短剧运行时请求不使用 OAuth。

package/checksums.txt

@@ -1,6 +1,6 @@
-95c7bf8bb745dc6e390a8e71ebf9c464769b29f819e3dd9d77d3539453d320b4  pippit-tool-cli-1.0.1-darwin-amd64.tar.gz
-2163023d193b8886518d9b0481ae6306ddfde01de1f6fb61bbbd40a140b75b67  pippit-tool-cli-1.0.1-darwin-arm64.tar.gz
-15962cc45394ee0b204efb88753929b0842c8ad8d74333fe84ba91fe3f3e1596  pippit-tool-cli-1.0.1-linux-amd64.tar.gz
-dbad696c1c212c6d14ef3e9788597d1751386ab7685111832b3ec8b82964bd57  pippit-tool-cli-1.0.1-linux-arm64.tar.gz
-8c298e5200d83d72ddb6c044d63183aa0104ef2b62fb1b0492d3652bfd103f8a  pippit-tool-cli-1.0.1-windows-amd64.zip
-eebeac5fccccbf63e4949efbf92ae2e3518e34b0758a1379cd0f4cc7328e5997  pippit-tool-cli-1.0.1-windows-arm64.zip
+2674fbc4cf095e321dcba42a0e7ed44ecb50c14236a07c97dbc522227c8819e1  pippit-tool-cli-1.0.2-darwin-amd64.tar.gz
+f58a8babc317bef904699938b69574bb26d28cf191fff5123be305be77e27c3b  pippit-tool-cli-1.0.2-darwin-arm64.tar.gz
+3b33fbf6bc66f77b54e1436c5e231f355fe10787d41fe1310b6575b36e7c7cee  pippit-tool-cli-1.0.2-linux-amd64.tar.gz
+f5e73a43c79d5d4a35872a05ad9d14c1260753042a004ef358c475e7e7c4e764  pippit-tool-cli-1.0.2-linux-arm64.tar.gz
+36f48c0db0f6524d43fd49d2e2cea014166c9dad85834f1cd498c2e8ebfeafd4  pippit-tool-cli-1.0.2-windows-amd64.zip
+b45999f5e9412a2d7728e538b9cedbb715f4ffc397c667e610bcb964311db8f0  pippit-tool-cli-1.0.2-windows-arm64.zip

package/cmd/download_result.go

@@ -44,7 +44,7 @@ func newDownloadResultCommand(stdout, stderr io.Writer, runner *common.Runner) *
 			if err != nil {
 				return err
 			}
-			return writeJSON(stdout, result)
+			return common.WriteJSON(stdout, result)
 		}),
 	}
 	cmd.SetOut(stdout)

package/cmd/generate_video/generate_video.go

@@ -0,0 +1,48 @@
+package generate_video
+
+import (
+	"io"
+	"strconv"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	internalgen "github.com/Pippit-dev/pippit-cli/internal/generate_video"
+	"github.com/spf13/cobra"
+)
+
+// NewCommand builds the generate-video command.
+func NewCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	opts := &internalgen.Options{}
+	var durationSec int
+
+	cmd := &cobra.Command{
+		Use:   "generate-video",
+		Short: "Generate a video with the video part agent",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if cmd.Flags().Changed("duration") {
+				opts.DurationSec = &durationSec
+			}
+
+			result, err := internalgen.Run(cmd.Context(), opts, runner)
+			if err != nil {
+				_ = common.AppendDailyErrorLog("generate-video", err, map[string]string{
+					"image_count": strconv.Itoa(len(opts.ImagePaths)),
+					"video_count": strconv.Itoa(len(opts.VideoPaths)),
+				})
+				return err
+			}
+			return common.WriteJSON(stdout, result)
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	flags := cmd.Flags()
+	flags.StringVar(&opts.Prompt, "prompt", "", "video generation prompt")
+	flags.StringArrayVar(&opts.ImagePaths, "image", nil, "local reference image path; repeat for multiple images, up to 9")
+	flags.StringArrayVar(&opts.VideoPaths, "video", nil, "local reference video path; repeat for multiple videos, up to 3")
+	flags.IntVar(&durationSec, "duration", 0, "video duration in seconds")
+	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: seedance2.0_direct, seedance2.0_fast_direct; VIP users: seedance2.0_direct, seedance2.0_fast_direct, seedance2.0_vision, seedance2.0_fast_vision")
+	flags.StringVar(&opts.Resolution, "resolution", "", "video resolution, such as 720p, 1080p")
+	return cmd
+}

package/cmd/generate_video/query_result.go

@@ -0,0 +1,58 @@
+package generate_video
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	internalgen "github.com/Pippit-dev/pippit-cli/internal/generate_video"
+	"github.com/spf13/cobra"
+)
+
+// NewQueryResultCommand builds the query-result command.
+func NewQueryResultCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	opts := &internalgen.QueryResultOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "query-result",
+		Short: "Query a generate-video run result and download completed videos",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			result, err := internalgen.QueryResult(cmd.Context(), opts, runner)
+			if err != nil {
+				_ = common.AppendDailyErrorLog("query-result", err, map[string]string{
+					"thread_id":    strings.TrimSpace(opts.ThreadID),
+					"run_id":       strings.TrimSpace(opts.RunID),
+					"download_dir": strings.TrimSpace(opts.DownloadDir),
+				})
+				return err
+			}
+			if !result.Completed {
+				_, err = fmt.Fprintf(stdout, "Run 尚未完成，当前状态：%d\n请稍后重试 query-result。\n", result.State)
+				return err
+			}
+			_, err = fmt.Fprintln(stdout, "Run 已完成，产物已下载：")
+			if err != nil {
+				return err
+			}
+			for i, path := range result.OutputPaths {
+				if _, err := fmt.Fprintln(stdout, path); err != nil {
+					return err
+				}
+				if i < len(result.DownloadURLs) && strings.TrimSpace(result.DownloadURLs[i]) != "" {
+					if _, err := fmt.Fprintf(stdout, "download_url: %s\n", result.DownloadURLs[i]); err != nil {
+						return err
+					}
+				}
+			}
+			return nil
+		},
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	cmd.Flags().StringVar(&opts.ThreadID, "thread-id", "", "thread_id from generate-video output")
+	cmd.Flags().StringVar(&opts.RunID, "run-id", "", "run_id from generate-video output")
+	cmd.Flags().StringVar(&opts.DownloadDir, "download-dir", "", "directory to download completed videos into")
+	return cmd
+}

package/cmd/generate_video_test.go

@@ -0,0 +1,468 @@
+package cmd
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/bytedance/sonic"
+)
+
+func TestGenerateVideo(t *testing.T) {
+	assetIDs := []string{"image_asset_1", "image_asset_2", "video_asset_1", "video_asset_2"}
+	uploadIndex := 0
+
+	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":
+			if r.Method != http.MethodPost {
+				t.Fatalf("upload method = %s, want POST", r.Method)
+			}
+			if uploadIndex >= len(assetIDs) {
+				t.Fatalf("unexpected upload %d", uploadIndex)
+			}
+			if err := r.ParseMultipartForm(1 << 20); err != nil {
+				t.Fatalf("ParseMultipartForm(): %v", err)
+			}
+			files := r.MultipartForm.File["file"]
+			if len(files) != 1 {
+				t.Fatalf("file parts = %d, want 1", len(files))
+			}
+			uploadIndex++
+			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"pippit_asset_id":"` + assetIDs[uploadIndex-1] + `"}}`))
+		case "/api/biz/v1/skill/submit_run":
+			if uploadIndex != len(assetIDs) {
+				t.Fatalf("submit called after %d uploads, want %d", uploadIndex, len(assetIDs))
+			}
+			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)
+			}
+			if body["agent_name"] != "pippit_video_part_agent" {
+				t.Fatalf("agent_name = %v, want video part agent", body["agent_name"])
+			}
+			if body["message"] != "做个小猫视频" {
+				t.Fatalf("message = %v, want submitted prompt", body["message"])
+			}
+			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["prompt"] != "做个小猫视频" {
+				t.Fatalf("prompt = %v, want submitted prompt", param["prompt"])
+			}
+			if param["duration_sec"] != float64(5) {
+				t.Fatalf("duration_sec = %v, want 5", param["duration_sec"])
+			}
+			if param["ratio"] != "9:16" || param["model"] != "seedance2.0_vision" || param["resolution"] != "720p" {
+				t.Fatalf("param = %#v, want ratio/model/resolution", param)
+			}
+			assertAssetRefs(t, param["images"], []string{"image_asset_1", "image_asset_2"})
+			assertAssetRefs(t, param["videos"], []string{"video_asset_1", "video_asset_2"})
+			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"run":{"thread_id":"thread_123","run_id":"run_456"},"web_thread_link":"https://xyq.example/thread_123"}}`))
+		default:
+			t.Fatalf("unexpected path %s", r.URL.Path)
+		}
+	}))
+	defer server.Close()
+
+	cwd := chdirTemp(t)
+	image1 := filepath.Join(cwd, "cat1.jpg")
+	image2 := filepath.Join(cwd, "cat2.jpg")
+	video1 := filepath.Join(cwd, "video1.mp4")
+	video2 := filepath.Join(cwd, "video2.mp4")
+	for _, path := range []string{image1, image2, video1, video2} {
+		if err := os.WriteFile(path, []byte("media-data"), 0o644); err != nil {
+			t.Fatalf("WriteFile(%s): %v", path, err)
+		}
+	}
+
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{
+		"generate-video",
+		"--prompt", "做个小猫视频",
+		"--image", image1,
+		"--image", image2,
+		"--video", video1,
+		"--video", video2,
+		"--duration", "5",
+		"--ratio", "9:16",
+		"--model", "seedance2.0_vision",
+		"--resolution", "720p",
+	})
+
+	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_123" || got["run_id"] != "run_456" {
+		t.Fatalf("output = %#v, want thread and run IDs", got)
+	}
+}
+
+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":
+			_, _ = 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)
+		}
+	}))
+	defer server.Close()
+
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{
+		"generate-video",
+		"--prompt", "x",
+		"--duration", "1",
+		"--ratio", "1:1",
+		"--model", "bad_model",
+		"--resolution", "bad_resolution",
+	})
+
+	if err := root.Execute(); err != nil {
+		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
+	}
+}
+
+func TestGenerateVideoRequiresPrompt(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		t.Fatal("server should not receive request without prompt")
+	}))
+	defer server.Close()
+
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{
+		"generate-video",
+		"--duration", "1",
+	})
+
+	err := root.Execute()
+	if err == nil {
+		t.Fatal("Execute() error = nil, want prompt validation")
+	}
+	if !strings.Contains(err.Error(), "缺少必填参数 --prompt") {
+		t.Fatalf("error = %q, want prompt validation", err)
+	}
+}
+
+func TestGenerateVideoRejectsTooManyImages(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		t.Fatal("server should not receive request when image count is invalid")
+	}))
+	defer server.Close()
+
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	args := []string{"generate-video", "--prompt", "x"}
+	for _, path := range mediaPaths("image", ".jpg", 10) {
+		args = append(args, "--image", path)
+	}
+	root.SetArgs(args)
+
+	err := root.Execute()
+	if err == nil {
+		t.Fatal("Execute() error = nil, want image count validation")
+	}
+	if !strings.Contains(err.Error(), "参考图片最多支持 9 个，当前传入 10 个") {
+		t.Fatalf("error = %q, want image count validation", err)
+	}
+}
+
+func TestGenerateVideoRejectsTooManyVideos(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		t.Fatal("server should not receive request when video count is invalid")
+	}))
+	defer server.Close()
+
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	args := []string{"generate-video", "--prompt", "x"}
+	for _, path := range mediaPaths("video", ".mp4", 4) {
+		args = append(args, "--video", path)
+	}
+	root.SetArgs(args)
+
+	err := root.Execute()
+	if err == nil {
+		t.Fatal("Execute() error = nil, want video count validation")
+	}
+	if !strings.Contains(err.Error(), "参考视频最多支持 3 个，当前传入 4 个") {
+		t.Fatalf("error = %q, want video count validation", err)
+	}
+}
+
+func TestGenerateVideoSubmitRunErrorIncludesLogID(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":
+			_, _ = w.Write([]byte(`{"ret":"16008","errmsg":"提交Run任务失败","log_id":"log_123"}`))
+		default:
+			t.Fatalf("unexpected path %s", r.URL.Path)
+		}
+	}))
+	defer server.Close()
+
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{
+		"generate-video",
+		"--prompt", "x",
+	})
+
+	err := root.Execute()
+	if err == nil {
+		t.Fatal("Execute() error = nil, want submit_run error")
+	}
+	if !strings.Contains(err.Error(), "log_id=log_123") {
+		t.Fatalf("error = %q, want log_id", err)
+	}
+}
+
+func TestGenerateVideoErrorLogIncludesLogID(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":
+			_, _ = w.Write([]byte(`{"ret":"16008","errmsg":"提交Run任务失败","log_id":"log_123"}`))
+		default:
+			t.Fatalf("unexpected path %s", r.URL.Path)
+		}
+	}))
+	defer server.Close()
+
+	clearDailyErrorLog(t)
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{
+		"generate-video",
+		"--prompt", "x",
+	})
+
+	err := root.Execute()
+	if err == nil {
+		t.Fatal("Execute() error = nil, want submit_run 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["log_id"] != "log_123" {
+		t.Fatalf("log_id = %v, want log_123", fields["log_id"])
+	}
+}
+
+func TestQueryResultDownloadsCompletedVideo(t *testing.T) {
+	var requestedDownload 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/get_thread":
+			if r.Method != http.MethodPost {
+				t.Fatalf("get_thread method = %s, want POST", r.Method)
+			}
+			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)
+			}
+			if body["thread_id"] != "thread_123" {
+				t.Fatalf("thread_id = %v, want thread_123", body["thread_id"])
+			}
+			if body["run_id"] != "run_456" {
+				t.Fatalf("run_id = %v, want run_456", body["run_id"])
+			}
+			if _, ok := body["version"]; ok {
+				t.Fatalf("version = %v, want omitted", body["version"])
+			}
+			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"thread":{"thread_id":"thread_123","run_list":[{"run_id":"run_456","state":3,"entry_list":[{"artifact":{"content":[{"sub_type":"biz/x_data_prompt_text","data":"做个小猫视频"},{"sub_type":"biz/x_data_video","data":"{\"video\":{\"download_url\":\"` + serverURL(r) + `/video.mp4\",\"title\":\"cat_video\",\"vid\":\"cat_vid\"}}"}]}}]}]}}}`))
+		case "/video.mp4":
+			requestedDownload = true
+			if r.Method != http.MethodGet {
+				t.Fatalf("download method = %s, want GET", r.Method)
+			}
+			_, _ = w.Write([]byte("video-data"))
+		default:
+			t.Fatalf("unexpected path %s", r.URL.Path)
+		}
+	}))
+	defer server.Close()
+
+	downloadDir := filepath.Join(t.TempDir(), "downloads")
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{
+		"query-result",
+		"--thread-id", "thread_123",
+		"--run-id", "run_456",
+		"--download-dir", downloadDir,
+	})
+
+	if err := root.Execute(); err != nil {
+		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
+	}
+
+	outputPath := filepath.Join(downloadDir, "cat_vid.mp4")
+	downloadURL := server.URL + "/video.mp4"
+	if !requestedDownload {
+		t.Fatal("download endpoint was not requested")
+	}
+	if got := stdout.String(); !strings.Contains(got, "Run 已完成，产物已下载：") ||
+		!strings.Contains(got, outputPath) ||
+		!strings.Contains(got, "download_url: "+downloadURL) {
+		t.Fatalf("stdout = %q, want download path and download url", got)
+	}
+	assertFileContent(t, outputPath, "video-data")
+}
+
+func TestQueryResultIgnoresVideoDataWithoutVideoSubType(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/biz/v1/skill/get_thread":
+			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"thread":{"thread_id":"thread_123","run_list":[{"run_id":"run_456","state":3,"entry_list":[{"artifact":{"content":[{"data":"{\"video\":{\"download_url\":\"` + serverURL(r) + `/video.mp4\",\"title\":\"cat_video\"}}"}]}}]}]}}}`))
+		default:
+			t.Fatalf("unexpected path %s", r.URL.Path)
+		}
+	}))
+	defer server.Close()
+
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{
+		"query-result",
+		"--thread-id", "thread_123",
+		"--run-id", "run_456",
+		"--download-dir", t.TempDir(),
+	})
+
+	err := root.Execute()
+	if err == nil {
+		t.Fatal("Execute() error = nil, want no downloadable video error")
+	}
+	if !strings.Contains(err.Error(), "下载失败：未找到可下载的视频产物") {
+		t.Fatalf("error = %q, want no downloadable video error", err)
+	}
+	if stdout.Len() != 0 {
+		t.Fatalf("stdout = %q, want empty", stdout.String())
+	}
+}
+
+func TestQueryResultErrorLogIncludesLogID(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/biz/v1/skill/get_thread":
+			_, _ = w.Write([]byte(`{"ret":"5","errmsg":"创作失败","log_id":"log_456"}`))
+		default:
+			t.Fatalf("unexpected path %s", r.URL.Path)
+		}
+	}))
+	defer server.Close()
+
+	clearDailyErrorLog(t)
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{
+		"query-result",
+		"--thread-id", "thread_123",
+		"--run-id", "run_456",
+		"--download-dir", t.TempDir(),
+	})
+
+	err := root.Execute()
+	if err == nil {
+		t.Fatal("Execute() error = nil, want get_thread 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["log_id"] != "log_456" {
+		t.Fatalf("log_id = %v, want log_456", fields["log_id"])
+	}
+	if fields["thread_id"] != "thread_123" || fields["run_id"] != "run_456" {
+		t.Fatalf("fields = %#v, want thread/run ids", fields)
+	}
+}
+
+func TestQueryResultPendingDoesNotDownload(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/biz/v1/skill/get_thread":
+			_, _ = w.Write([]byte(`{"ret":"0","errmsg":"","data":{"thread":{"thread_id":"thread_123","run_list":[{"run_id":"run_456","state":1}]}}}`))
+		default:
+			t.Fatalf("unexpected path %s", r.URL.Path)
+		}
+	}))
+	defer server.Close()
+
+	var stdout, stderr bytes.Buffer
+	root := newTestRootCommand(t, &stdout, &stderr, server.URL)
+	root.SetArgs([]string{
+		"query-result",
+		"--thread-id", "thread_123",
+		"--run-id", "run_456",
+		"--download-dir", t.TempDir(),
+	})
+
+	if err := root.Execute(); err != nil {
+		t.Fatalf("Execute() error = %v, stderr = %s", err, stderr.String())
+	}
+	if got := stdout.String(); !strings.Contains(got, "Run 尚未完成，当前状态：1") {
+		t.Fatalf("stdout = %q, want pending state", got)
+	}
+}
+
+func serverURL(r *http.Request) string {
+	return "http://" + r.Host
+}
+
+func assertAssetRefs(t *testing.T, got any, want []string) {
+	t.Helper()
+	items, ok := got.([]any)
+	if !ok || len(items) != len(want) {
+		t.Fatalf("asset refs = %#v, want %v", got, want)
+	}
+	for i, item := range items {
+		ref, ok := item.(map[string]any)
+		if !ok || ref["pippit_asset_id"] != want[i] {
+			t.Fatalf("asset refs[%d] = %#v, want %s", i, item, want[i])
+		}
+	}
+}
+
+func mediaPaths(prefix string, ext string, count int) []string {
+	paths := make([]string, 0, count)
+	for i := 0; i < count; i++ {
+		paths = append(paths, prefix+string(rune('a'+i))+ext)
+	}
+	return paths
+}

package/cmd/get_thread.go

@@ -27,6 +27,7 @@ func newGetThreadCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra
 				return fmt.Errorf("--thread-id is required")
 			}
 			opts.RunID = strings.TrimSpace(opts.RunID)
+			opts.Version = common.GetThreadVersionV2
 
 			result, err := common.GetThread(cmd.Context(), &opts, runner)
 			if err != nil {

package/cmd/list_thread_file.go

@@ -39,7 +39,7 @@ func newListThreadFileCommand(stdout, stderr io.Writer, runner *common.Runner) *
 			if err != nil {
 				return err
 			}
-			return writeJSON(stdout, result)
+			return common.WriteJSON(stdout, result)
 		}),
 	}
 	cmd.SetOut(stdout)