@pippit-dev/cli 1.0.25 → 1.0.27

package/internal/common/submit_run.go

@@ -2,7 +2,10 @@ package common
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"net/url"
+	"strings"
 
 	"github.com/Pippit-dev/pippit-cli/internal/config"
 )
@@ -37,11 +40,36 @@ type SubmitRunResponseRun struct {
 
 // 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) {
+	return submitRun(ctx, command, SubmitRunPath(runner), body, runner)
+}
+
+// SubmitRunWithBabiParam carries client attribution in the same query field as Web.
+func SubmitRunWithBabiParam(ctx context.Context, command string, body any, runner *Runner, babiParam map[string]string) (*SubmitRunResult, error) {
+	path, err := url.Parse(SubmitRunPath(runner))
+	if err != nil {
+		return nil, fmt.Errorf("解析 submit_run 路径失败: %w", err)
+	}
+	query, err := url.ParseQuery(path.RawQuery)
+	if err != nil {
+		return nil, fmt.Errorf("解析 submit_run 查询参数失败: %w", err)
+	}
+	raw, err := json.Marshal(babiParam)
+	if err != nil {
+		return nil, fmt.Errorf("序列化 babi_param 失败: %w", err)
+	}
+	if !query.Has("babi_param") {
+		query.Set("babi_param", string(raw))
+	}
+	path.RawQuery = query.Encode()
+	return submitRun(ctx, command, path.String(), body, runner)
+}
+
+func submitRun(ctx context.Context, command, path 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 {
+	if err := runner.Client.SendRequest(ctx, path, body, &resp); err != nil {
 		return nil, fmt.Errorf("提交 %s 请求失败: %w", command, err)
 	}
 	if resp.Ret != "0" {
@@ -71,3 +99,12 @@ func SubmitRunPath(runner *Runner) string {
 	}
 	return config.SubmitRunPath
 }
+
+// WithSubmitRunSource adds optional host attribution to a newly constructed skill request.
+// The API consumes this metadata as platform; it is not part of the creative input.
+func WithSubmitRunSource(body map[string]any, source string) map[string]any {
+	if source = strings.TrimSpace(source); source != "" {
+		body["platform"] = source
+	}
+	return body
+}

package/internal/config/config.go

@@ -13,6 +13,7 @@ const (
 	DefaultAuthStoreServiceName = "pippit-cli"
 	SubmitRunPath               = "/api/biz/v1/skill/submit_run"
 	GetCreditBalancePath        = "/api/biz/v1/skill/get_credit_balance"
+	GetAvailableModelListPath   = "/api/biz/v1/skill/get_available_model_list"
 	GetThreadPath               = "/api/biz/v1/skill/get_thread"
 	UploadFilePath              = "/api/biz/v1/skill/upload_file"
 	ListThreadFilePath          = "/api/biz/v1/skill/list_thread_file"
@@ -30,11 +31,12 @@ type Config struct {
 }
 
 type Paths struct {
-	SubmitRun        string
-	GetCreditBalance string
-	GetThread        string
-	UploadFile       string
-	ListThreadFile   string
+	SubmitRun             string
+	GetCreditBalance      string
+	GetAvailableModelList string
+	GetThread             string
+	UploadFile            string
+	ListThreadFile        string
 }
 
 // Load resolves the built-in runtime config.
@@ -45,11 +47,12 @@ func Load() *Config {
 		AuthTTL:     DefaultAuthTTL,
 		AccessKey:   strings.TrimSpace(os.Getenv(EnvXYQAccessKey)),
 		Paths: &Paths{
-			SubmitRun:        SubmitRunPath,
-			GetCreditBalance: GetCreditBalancePath,
-			GetThread:        GetThreadPath,
-			UploadFile:       UploadFilePath,
-			ListThreadFile:   ListThreadFilePath,
+			SubmitRun:             SubmitRunPath,
+			GetCreditBalance:      GetCreditBalancePath,
+			GetAvailableModelList: GetAvailableModelListPath,
+			GetThread:             GetThreadPath,
+			UploadFile:            UploadFilePath,
+			ListThreadFile:        ListThreadFilePath,
 		},
 	}
 }

package/internal/config/config_test.go

@@ -23,6 +23,9 @@ func TestLoadUsesDefaultConfig(t *testing.T) {
 	if cfg.Paths.GetCreditBalance != GetCreditBalancePath {
 		t.Fatalf("GetCreditBalance path = %q, want %q", cfg.Paths.GetCreditBalance, GetCreditBalancePath)
 	}
+	if cfg.Paths.GetAvailableModelList != GetAvailableModelListPath {
+		t.Fatalf("GetAvailableModelList path = %q, want %q", cfg.Paths.GetAvailableModelList, GetAvailableModelListPath)
+	}
 }
 
 func TestLoadReadsAccessKey(t *testing.T) {

package/internal/generate_image/generate_image.go

@@ -23,6 +23,7 @@ const ratioUsage = "enum values: 0=原始比例/自动, 2=16:9(横屏), 13=21:9(
 
 // Options is the stable command-facing request shape for generate-image.
 type Options struct {
+	Source             string
 	Prompt             string
 	ImagePaths         []string
 	Model              string
@@ -151,7 +152,7 @@ func buildSubmitRunBody(opts *Options, imageAssetIDs []string) map[string]any {
 	if len(imageAssetIDs) > 0 {
 		body["asset_ids"] = imageAssetIDs
 	}
-	return body
+	return common.WithSubmitRunSource(body, opts.Source)
 }
 
 func parseRatio(raw string) (*int, error) {

package/internal/generate_video/generate_video.go

@@ -9,12 +9,6 @@ import (
 	"github.com/Pippit-dev/pippit-cli/internal/common"
 )
 
-const (
-	maxReferenceImages = 9
-	maxReferenceVideos = 3
-	maxReferenceAudios = 3
-)
-
 var (
 	allowedImageExtensionList = []string{".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".svg"}
 	allowedAudioExtensionList = []string{".mp3", ".wav"}
@@ -24,6 +18,7 @@ var (
 
 // Options is the stable command-facing request shape for generate-video.
 type Options struct {
+	Source       string
 	Prompt       string
 	ImagePaths   []string
 	VideoPaths   []string
@@ -60,7 +55,15 @@ func Run(ctx context.Context, opts *Options, runner *common.Runner) (*Result, er
 	}
 
 	body := buildSubmitRunBody(opts, imageAssetIDs, videoAssetIDs, audioAssetIDs)
-	return common.SubmitRun(ctx, "generate-video", body, runner)
+	// Business attribution belongs to this command, regardless of the selected model.
+	return common.SubmitRunWithBabiParam(ctx, "generate-video", body, runner, map[string]string{
+		"scene_lv1":  "ai_agent",
+		"scene_lv2":  "front_tool",
+		"tool_id":    "instant_video",
+		"tab_name":   "other",
+		"edit_type":  "instant_video",
+		"enter_from": "skill",
+	})
 }
 
 func ValidateOptions(opts *Options) error {
@@ -70,15 +73,6 @@ func ValidateOptions(opts *Options) error {
 	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 len(opts.AudioPaths) > maxReferenceAudios {
-		return fmt.Errorf("参考音频最多支持 %d 个，当前传入 %d 个", maxReferenceAudios, len(opts.AudioPaths))
-	}
 	if err := validateMediaExtensions("图片", opts.ImagePaths, allowedImageExtensions, allowedImageExtensionList); err != nil {
 		return err
 	}
@@ -131,11 +125,11 @@ func buildSubmitRunBody(opts *Options, imageAssetIDs []string, videoAssetIDs []s
 		GenerateType: opts.GenerateType,
 	}
 
-	return map[string]any{
+	return common.WithSubmitRunSource(map[string]any{
 		"agent_name":            common.AgentNameVideoPart,
 		"message":               prompt,
 		"video_part_tool_param": param,
-	}
+	}, opts.Source)
 }
 
 func assetRefs(assetIDs []string) []*common.MediaAsset {

package/internal/generate_video/generate_video_test.go

@@ -1,8 +1,13 @@
 package generate_video
 
 import (
+	"context"
 	"encoding/json"
+	"net/url"
 	"testing"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	"github.com/Pippit-dev/pippit-cli/internal/config"
 )
 
 func TestBuildSubmitRunBodyPreservesEmptyPrompt(t *testing.T) {
@@ -15,3 +20,124 @@ func TestBuildSubmitRunBodyPreservesEmptyPrompt(t *testing.T) {
 		t.Fatalf("video_part_tool_param = %s, want explicit empty prompt", got)
 	}
 }
+
+type videoSubmitRecordingClient struct {
+	common.Client
+	path string
+	body any
+}
+
+func (c *videoSubmitRecordingClient) SendRequest(_ context.Context, path string, body, out any) error {
+	c.path, c.body = path, body
+	return json.Unmarshal([]byte(`{"ret":"0","data":{"run":{"thread_id":"thread_123","run_id":"run_123"}}}`), out)
+}
+
+func TestRunCarriesVideoROIQuery(t *testing.T) {
+	for _, model := range []string{
+		"MiniMax-H3", "MiniMax-H3-Max", "wan3.0", "happyhorse-1.1",
+		"Seedance_2.5", "seedance2.0_vision", "seedance2.0_fast_vision",
+		"Seedance_2.0_mini", "Seedance_2.0_mini_lite", "", "future-model",
+	} {
+		t.Run(model, func(t *testing.T) {
+			client := &videoSubmitRecordingClient{}
+			runner := &common.Runner{
+				Client: client,
+				Config: &config.Config{Paths: &config.Paths{SubmitRun: "/custom/submit_run?source=a%2Bb&item=1&item=2"}},
+			}
+			if _, err := Run(context.Background(), &Options{Prompt: "cat walking", Model: model}, runner); err != nil {
+				t.Fatal(err)
+			}
+			path, err := url.Parse(client.path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			query := path.Query()
+			if path.Path != "/custom/submit_run" || query.Get("source") != "a+b" || len(query["item"]) != 2 {
+				t.Fatalf("configured path/query lost: %s", client.path)
+			}
+			var babi map[string]string
+			if err := json.Unmarshal([]byte(query.Get("babi_param")), &babi); err != nil {
+				t.Fatal(err)
+			}
+			for key, want := range map[string]string{
+				"scene_lv1": "ai_agent", "scene_lv2": "front_tool", "tool_id": "instant_video",
+				"tab_name": "other", "edit_type": "instant_video", "enter_from": "skill",
+			} {
+				if babi[key] != want {
+					t.Fatalf("babi_param[%s] = %q, want %q", key, babi[key], want)
+				}
+			}
+			body := client.body.(map[string]any)
+			if body["agent_name"] != common.AgentNameVideoPart || body["message"] != "cat walking" || len(body) != 3 {
+				t.Fatalf("ROI must not change the request body contract: %#v", body)
+			}
+		})
+	}
+}
+
+func TestRunPreservesExplicitROIQuery(t *testing.T) {
+	for _, model := range []string{"MiniMax-H3", "Seedance_2.0_mini"} {
+		t.Run(model, func(t *testing.T) {
+			client := &videoSubmitRecordingClient{}
+			raw := `{"scene_lv1":"ai_agent","scene_lv2":"front_tool","tool_id":"custom_video"}`
+			runner := &common.Runner{Client: client, Config: &config.Config{Paths: &config.Paths{
+				SubmitRun: "/custom/submit_run?babi_param=" + url.QueryEscape(raw),
+			}}}
+			if _, err := Run(context.Background(), &Options{Prompt: "cat walking", Model: model}, runner); err != nil {
+				t.Fatal(err)
+			}
+			path, err := url.Parse(client.path)
+			if err != nil || path.Query().Get("babi_param") != raw {
+				t.Fatalf("explicit attribution overwritten: %s, %v", client.path, err)
+			}
+		})
+	}
+}
+
+func TestRunRejectsMalformedQueryBeforeSubmit(t *testing.T) {
+	client := &videoSubmitRecordingClient{}
+	runner := &common.Runner{Client: client, Config: &config.Config{Paths: &config.Paths{
+		SubmitRun: "/custom/submit_run?source=%invalid",
+	}}}
+	if _, err := Run(context.Background(), &Options{Prompt: "cat walking", Model: "MiniMax-H3"}, runner); err == nil {
+		t.Fatal("expected malformed URL query error")
+	}
+	if client.path != "" {
+		t.Fatal("malformed URL must not submit a request")
+	}
+}
+
+func TestConfiguredVideoModelParametersPassThrough(t *testing.T) {
+	for _, model := range []string{"MiniMax-H3", "MiniMax-H3-Max", "wan3.0", "happyhorse-1.1"} {
+		t.Run(model, func(t *testing.T) {
+			opts := &Options{Prompt: "cat walking", Model: model, Ratio: "16:9"}
+			if err := ValidateOptions(opts); err != nil {
+				t.Fatal(err)
+			}
+			data, err := json.Marshal(buildSubmitRunBody(opts, nil, nil, nil))
+			if err != nil {
+				t.Fatal(err)
+			}
+			var body struct {
+				AgentName string         `json:"agent_name"`
+				Param     map[string]any `json:"video_part_tool_param"`
+			}
+			if err := json.Unmarshal(data, &body); err != nil {
+				t.Fatal(err)
+			}
+			if body.AgentName != "pippit_video_part_agent" || body.Param["model"] != model || body.Param["ratio"] != "16:9" {
+				t.Fatalf("unexpected body: %s", data)
+			}
+			for _, field := range []string{"duration_sec", "resolution", "generate_type"} {
+				if _, exists := body.Param[field]; exists {
+					t.Fatalf("CLI must leave %s defaults to the API: %s", field, data)
+				}
+			}
+			// API owns the Max 21:9 rejection; the CLI must not add an enum gate.
+			opts.Ratio = "21:9"
+			if err := ValidateOptions(opts); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}

package/internal/models/describe.go

@@ -0,0 +1,281 @@
+package models
+
+import (
+	"encoding/json"
+	"fmt"
+	"slices"
+	"strconv"
+	"strings"
+)
+
+// Mirrors capcut_business_common.Ratio and the Skill API's skillVideoRatio.
+// Custom (1) has no corresponding generate-video --ratio value.
+var ratioValues = map[int64]string{
+	0: "adaptive", 1: "", 2: "16:9", 3: "9:16", 4: "4:3", 5: "3:4", 6: "1:1",
+	7: "2:1", 8: "2.35:1", 9: "1.85:1", 10: "1.125:2.436", 11: "3:2", 12: "2:3", 13: "21:9",
+}
+
+type dimensionConfig struct {
+	Key          string  `json:"key"`
+	DefaultValue *string `json:"default_value"`
+	OptionList   []struct {
+		Value    string `json:"value"`
+		Disabled bool   `json:"disabled"`
+	} `json:"option_list"`
+	RangeConfig *struct {
+		Min  *int64 `json:"min_value"`
+		Max  *int64 `json:"max_value"`
+		Step int64  `json:"step"`
+	} `json:"range_config"`
+	ActiveWhenAny json.RawMessage `json:"active_when_any"`
+}
+
+// Normalize only fields with an explicit CLI contract. RawMessage preserves
+// unknown fields and large integers; the cached catalog is never mutated.
+func describeModel(raw json.RawMessage) (json.RawMessage, error) {
+	var fields map[string]json.RawMessage
+	var source struct {
+		Key       string  `json:"key"`
+		Ratios    []int64 `json:"supported_ratio_list"`
+		Default   *int64  `json:"default_ratio"`
+		Parameter struct {
+			Dimensions []*dimensionConfig `json:"dimensions"`
+		} `json:"parameter_config"`
+		Creation *struct {
+			Modes []json.RawMessage `json:"modes"`
+		} `json:"creation_mode_config"`
+	}
+	if err := json.Unmarshal(raw, &fields); err != nil {
+		return nil, err
+	}
+	if err := json.Unmarshal(raw, &source); err != nil {
+		return nil, fmt.Errorf("模型参数配置无法解析，请 --refresh 重试或升级 CLI: %w", err)
+	}
+	out := make(map[string]any, len(fields))
+	for key, value := range fields {
+		out[key] = value
+	}
+	delete(out, "config_key")
+	warnings := []string{}
+	warn := func(message string) { warnings = append(warnings, message) }
+	ratios := make([]string, 0, len(source.Ratios))
+	for _, value := range source.Ratios {
+		// Unknown enums and Custom cannot be submitted as CLI ratio strings.
+		if value := ratioValues[value]; value != "" && !slices.Contains(ratios, value) {
+			ratios = append(ratios, value)
+		}
+	}
+	ratio := map[string]any{"options": ratios}
+	if source.Default != nil {
+		if value := ratioValues[*source.Default]; value != "" {
+			if slices.Contains(ratios, value) {
+				ratio["default"] = value
+			} else {
+				warn("默认比例不在可用比例中，未输出默认值；请 --refresh 重试")
+			}
+		}
+	}
+	if _, exists := fields["supported_ratio_list"]; exists || source.Default != nil {
+		out["ratio"] = ratio
+	}
+	delete(out, "supported_ratio_list")
+	delete(out, "default_ratio")
+
+	seen := make(map[string]bool)
+	for _, dimension := range source.Parameter.Dimensions {
+		if dimension == nil || (dimension.Key != "resolution" && dimension.Key != "duration") {
+			continue
+		}
+		if seen[dimension.Key] {
+			return nil, fmt.Errorf("模型配置包含重复 %s 维度，请 --refresh 重试", dimension.Key)
+		}
+		seen[dimension.Key] = true
+		out[dimension.Key] = describeDimension(dimension, warn)
+	}
+	// Keep unrelated parameter dimensions and combination constraints as supplied.
+	if parameterRaw, ok := fields["parameter_config"]; ok && string(parameterRaw) != "null" {
+		var parameter map[string]json.RawMessage
+		if err := json.Unmarshal(parameterRaw, &parameter); err != nil {
+			return nil, err
+		}
+		var dimensions []json.RawMessage
+		if err := json.Unmarshal(parameter["dimensions"], &dimensions); len(parameter["dimensions"]) != 0 && err != nil {
+			return nil, err
+		}
+		remaining := []json.RawMessage{}
+		for _, dimension := range dimensions {
+			var key struct {
+				Key string `json:"key"`
+			}
+			if err := json.Unmarshal(dimension, &key); err != nil {
+				return nil, err
+			}
+			if key.Key != "resolution" && key.Key != "duration" {
+				remaining = append(remaining, dimension)
+			}
+		}
+		delete(parameter, "dimensions")
+		if len(remaining) > 0 {
+			parameter["dimensions"], _ = json.Marshal(remaining)
+		}
+		delete(out, "parameter_config")
+		if len(parameter) > 0 {
+			out["parameter_config"] = parameter
+		}
+	}
+	if seen["duration"] {
+		delete(out, "supported_duration_list")
+		delete(out, "default_duration_value")
+	} else if _, exists := fields["supported_duration_list"]; exists {
+		warn("服务端未提供 duration 参数维度；supported_duration_list 为旧时长枚举，不能直接当作 --duration 秒数")
+	}
+
+	limits := map[string]json.RawMessage{}
+	for from, to := range map[string]string{
+		"total_limit": "total_limit", "image_total_limit": "image_total_limit",
+		"video_total_limit": "video_total_limit", "audio_total_limit": "audio_total_limit",
+		"max_image_size": "max_image_size_bytes", "min_video_duration": "min_video_duration_ms",
+		"max_video_duration": "max_video_duration_ms", "max_total_video_duration": "max_total_video_duration_ms",
+	} {
+		if value, exists := fields[from]; exists {
+			limits[to] = value
+			delete(out, from)
+		}
+	}
+	if len(limits) > 0 {
+		out["material_limits"] = limits
+	}
+	if source.Creation != nil {
+		modes := make([]map[string]any, 0, len(source.Creation.Modes))
+		for _, rawMode := range source.Creation.Modes {
+			if string(rawMode) == "null" {
+				continue
+			}
+			var modeFields map[string]json.RawMessage
+			var mode struct {
+				Key         string `json:"key"`
+				RatioPolicy struct {
+					ValueMode string `json:"value_mode"`
+				} `json:"ratio_policy"`
+			}
+			if err := json.Unmarshal(rawMode, &modeFields); err != nil {
+				return nil, err
+			}
+			if err := json.Unmarshal(rawMode, &mode); err != nil {
+				return nil, err
+			}
+			entry := make(map[string]any, len(modeFields)+2)
+			for key, value := range modeFields {
+				entry[key] = value
+			}
+			switch mode.Key {
+			case "text_to_video", "reference_generation":
+				entry["generate_type"] = 0
+			case "first_last_frame":
+				entry["generate_type"] = 1
+			}
+			switch mode.RatioPolicy.ValueMode {
+			case "smart":
+				entry["ratio"] = map[string]any{"options": []string{"adaptive"}, "default": "adaptive"}
+			case "", "inherit":
+				entry["ratio"] = ratio
+				if mode.Key == "text_to_video" && (source.Key == "MiniMax-H3" || source.Key == "MiniMax-H3-Max") {
+					fixed := make([]string, 0, len(ratios))
+					for _, value := range ratios {
+						if value != "adaptive" {
+							fixed = append(fixed, value)
+						}
+					}
+					modeRatio := map[string]any{"options": fixed}
+					if value, ok := ratio["default"].(string); ok && value != "adaptive" {
+						modeRatio["default"] = value
+					}
+					entry["ratio"] = modeRatio
+				}
+			default:
+				warn("创作模式 " + mode.Key + " 的比例策略无法识别，请 --refresh 重试或升级 CLI")
+			}
+			modes = append(modes, entry)
+		}
+		// Retain schema/default-mode metadata, but expose interpreted modes separately.
+		var creation map[string]json.RawMessage
+		if err := json.Unmarshal(fields["creation_mode_config"], &creation); err != nil {
+			return nil, err
+		}
+		delete(creation, "modes")
+		delete(out, "creation_mode_config")
+		if len(creation) > 0 {
+			out["creation_mode_config"] = creation
+		}
+		out["creation_modes"] = modes
+	}
+	if (source.Key == "MiniMax-H3" || source.Key == "MiniMax-H3-Max") && slices.Contains(ratios, "adaptive") {
+		out["notes"] = []string{"MiniMax 使用 adaptive 需要参考图片或视频；纯文生视频请选择固定比例。创作模式的比例策略优先于模型级选项。"}
+	}
+	if len(warnings) > 0 {
+		out["warnings"] = warnings
+	}
+	return json.Marshal(out)
+}
+
+func describeDimension(d *dimensionConfig, warn func(string)) map[string]any {
+	out := map[string]any{}
+	if len(d.ActiveWhenAny) > 0 {
+		out["active_when_any"] = d.ActiveWhenAny
+	}
+	convert := func(value string) (any, bool) {
+		value = strings.TrimSpace(value)
+		if d.Key == "duration" {
+			number, err := strconv.ParseInt(value, 10, 32)
+			return number, err == nil && number > 0
+		}
+		return strings.ToLower(value), value != ""
+	}
+	if d.Key == "duration" {
+		out["unit"] = "seconds"
+	}
+	validDefault := func(any) bool { return false }
+	if bounds := d.RangeConfig; bounds != nil {
+		if d.Key != "duration" || len(d.OptionList) != 0 || bounds.Min == nil || bounds.Max == nil || *bounds.Min <= 0 || *bounds.Max < *bounds.Min {
+			warn(d.Key + " 范围配置不合法，请 --refresh 重试")
+			return out
+		}
+		step := bounds.Step
+		if step < 1 {
+			step = 1
+		}
+		out["min"], out["max"], out["step"] = *bounds.Min, *bounds.Max, step
+		validDefault = func(value any) bool {
+			n := value.(int64)
+			return n >= *bounds.Min && n <= *bounds.Max && (n-*bounds.Min)%step == 0
+		}
+	} else {
+		options := []any{}
+		for _, option := range d.OptionList {
+			if option.Disabled {
+				continue
+			}
+			value, ok := convert(option.Value)
+			if !ok {
+				warn(d.Key + " 包含无法转换的选项，已排除；请 --refresh 重试")
+				continue
+			}
+			if !slices.Contains(options, value) {
+				options = append(options, value)
+			}
+		}
+		out["options"] = options
+		if len(options) == 0 {
+			warn(d.Key + " 没有可用选项，请 --refresh 重试")
+		}
+		validDefault = func(value any) bool { return slices.Contains(options, value) }
+	}
+	if d.DefaultValue != nil {
+		if value, ok := convert(*d.DefaultValue); ok && validDefault(value) {
+			out["default"] = value
+		} else {
+			warn(d.Key + " 默认值不在可用范围内，未输出默认值；请 --refresh 重试")
+		}
+	}
+	return out
+}