@pippit-dev/cli 1.0.32 → 1.0.34

package/internal/generate_image/generate_image_test.go

@@ -1,6 +1,7 @@
 package generate_image
 
 import (
+	"encoding/json"
 	"strings"
 	"testing"
 )
@@ -19,10 +20,10 @@ func TestValidateOptionsRequiresModel(t *testing.T) {
 	}
 }
 
-func TestValidateOptionsAllowsServerDecidedModel(t *testing.T) {
+func TestValidateOptionsAllowsDynamicModelName(t *testing.T) {
 	opts := &Options{
 		Prompt: "x",
-		Model:  "seedream_3.0",
+		Model:  "图片测试模型",
 	}
 
 	if err := ValidateOptions(opts); err != nil {
@@ -33,7 +34,7 @@ func TestValidateOptionsAllowsServerDecidedModel(t *testing.T) {
 func TestValidateOptionsAllowsServerDecidedRatio(t *testing.T) {
 	opts := &Options{
 		Prompt: "x",
-		Model:  "seedream_4.5",
+		Model:  "图片测试模型",
 		Ratio:  "99",
 	}
 
@@ -45,7 +46,7 @@ func TestValidateOptionsAllowsServerDecidedRatio(t *testing.T) {
 func TestValidateOptionsAllowsServerDecidedResolution(t *testing.T) {
 	opts := &Options{
 		Prompt:     "x",
-		Model:      "seedream_4.5",
+		Model:      "图片测试模型",
 		Resolution: "8K",
 	}
 
@@ -58,7 +59,7 @@ func TestValidateOptionsRejectsNegativeGenerateImageCount(t *testing.T) {
 	count := -1
 	opts := &Options{
 		Prompt:             "x",
-		Model:              "seedream_4.5",
+		Model:              "图片测试模型",
 		GenerateImageCount: &count,
 	}
 
@@ -83,6 +84,13 @@ func TestParseRatioSupportsVisibleEnumValues(t *testing.T) {
 		{ratio: "4", want: 4},
 		{ratio: "5", want: 5},
 		{ratio: "6", want: 6},
+		{ratio: "7", want: 7},
+		{ratio: "8", want: 8},
+		{ratio: "9", want: 9},
+		{ratio: "10", want: 10},
+		{ratio: "11", want: 11},
+		{ratio: "12", want: 12},
+		{ratio: "99", want: 99},
 	}
 
 	for _, tt := range cases {
@@ -98,20 +106,55 @@ func TestParseRatioSupportsVisibleEnumValues(t *testing.T) {
 	}
 }
 
-func TestParseRatioRejectsNonInteger(t *testing.T) {
-	_, err := parseRatio("1:1")
-	if err == nil {
-		t.Fatal("parseRatio() error = nil, want integer validation")
+func TestImageOptionalParametersAndEffortPassThrough(t *testing.T) {
+	for _, effort := range []string{"", " HIGH ", "future-effort"} {
+		opts := &Options{Prompt: "image", Model: "未来图片模型", Effort: effort}
+		if err := ValidateOptions(opts); err != nil {
+			t.Fatal(err)
+		}
+		raw, err := json.Marshal(buildSubmitRunBody(opts, "future-image-model", nil))
+		if err != nil {
+			t.Fatal(err)
+		}
+		var body struct {
+			Settings map[string]json.RawMessage `json:"general_agent_settings"`
+		}
+		if err := json.Unmarshal(raw, &body); err != nil {
+			t.Fatal(err)
+		}
+		for _, key := range []string{"ratio", "resolution", "generate_image_count"} {
+			if _, exists := body.Settings[key]; exists {
+				t.Fatalf("unspecified %s was filled: %s", key, raw)
+			}
+		}
+		if effort == "" {
+			if _, exists := body.Settings["image_effort"]; exists {
+				t.Fatalf("unspecified effort was filled: %s", raw)
+			}
+		} else {
+			var got string
+			if err := json.Unmarshal(body.Settings["image_effort"], &got); err != nil || got != strings.ToLower(strings.TrimSpace(effort)) {
+				t.Fatalf("effort not forwarded: %s, %v", raw, err)
+			}
+		}
 	}
-	if !strings.Contains(err.Error(), `ratio "1:1" 必须是整数枚举值`) {
-		t.Fatalf("error = %q, want integer validation", err)
+}
+
+func TestParseRatioRejectsNonInteger(t *testing.T) {
+	for _, ratio := range []string{"9:16", "adaptive", "17:11", "3.0"} {
+		t.Run(ratio, func(t *testing.T) {
+			err := ValidateOptions(&Options{Prompt: "image", Model: "未来图片模型", Ratio: ratio})
+			if err == nil || !strings.Contains(err.Error(), "必须是整数枚举值") {
+				t.Fatalf("ratio %q: error = %v, want integer enum validation", ratio, err)
+			}
+		})
 	}
 }
 
 func TestValidateOptionsRejectsUnsupportedImageExtension(t *testing.T) {
 	opts := &Options{
 		Prompt:     "x",
-		Model:      "seedream_4.5",
+		Model:      "图片测试模型",
 		ImagePaths: []string{"ref.tiff"},
 	}
 
@@ -128,13 +171,13 @@ func TestBuildSubmitRunBodyWithGeneralAgentSettings(t *testing.T) {
 	count := 2
 	opts := &Options{
 		Prompt:             "  生成小猫海报  ",
-		Model:              " seedream_5.0_pro ",
+		Model:              " Seedream 5.0 Pro ",
 		Ratio:              "6",
 		Resolution:         " 4k ",
 		GenerateImageCount: &count,
 	}
 
-	body := buildSubmitRunBody(opts, []string{"asset_1"})
+	body := buildSubmitRunBody(opts, "seedream_5.0_pro", []string{"asset_1"})
 	if body["agent_name"] != agentNameNest {
 		t.Fatalf("agent_name = %v, want nest agent", body["agent_name"])
 	}

package/internal/models/describe.go

@@ -6,17 +6,15 @@ import (
 	"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",
-}
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+)
 
 type dimensionConfig struct {
 	Key          string  `json:"key"`
+	Label        string  `json:"label"`
+	Description  string  `json:"description"`
+	Required     *bool   `json:"required_field"`
 	DefaultValue *string `json:"default_value"`
 	OptionList   []struct {
 		Value    string `json:"value"`
@@ -36,6 +34,8 @@ func describeModel(raw json.RawMessage) (json.RawMessage, error) {
 	var fields map[string]json.RawMessage
 	var source struct {
 		Key       string  `json:"key"`
+		Name      string  `json:"name"`
+		Kind      string  `json:"kind"`
 		Ratios    []int64 `json:"supported_ratio_list"`
 		Default   *int64  `json:"default_ratio"`
 		Parameter struct {
@@ -57,18 +57,27 @@ func describeModel(raw json.RawMessage) (json.RawMessage, error) {
 	}
 	delete(out, "config_key")
 	delete(out, "is_default") // A server default does not authorize model selection.
+	if source.Kind == "image" {
+		// Billing maps and other Web-only metadata can contain wire model names.
+		// Keep them in the raw catalog, not in host-facing command output.
+		out = map[string]any{"name": strings.TrimSpace(source.Name), "kind": source.Kind}
+		for _, key := range []string{"description", "parameter_config", "creation_mode_config"} {
+			if value, exists := fields[key]; exists {
+				out[key] = value
+			}
+		}
+	}
 	warnings := []string{}
 	warn := func(message string) { warnings = append(warnings, message) }
-	ratios := make([]string, 0, len(source.Ratios))
+	ratios := make([]any, 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) {
+		if value, ok := cliRatioValue(value, source.Kind); ok && !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 value, ok := cliRatioValue(*source.Default, source.Kind); ok {
 			if slices.Contains(ratios, value) {
 				ratio["default"] = value
 			} else {
@@ -84,17 +93,37 @@ func describeModel(raw json.RawMessage) (json.RawMessage, error) {
 
 	seen := make(map[string]bool)
 	for _, dimension := range source.Parameter.Dimensions {
-		if dimension == nil || (dimension.Key != "resolution" && dimension.Key != "duration") {
+		if dimension == nil {
+			continue
+		}
+		if source.Kind == "image" {
+			if dimension.Key != "resolution" && dimension.Key != "ratio" && dimension.Key != "effort" {
+				continue
+			}
+		} else if 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)
+		out[dimension.Key] = describeDimension(dimension, source.Kind, warn)
+	}
+	if source.Kind == "image" {
+		if imageRatio, ok := out["ratio"].(map[string]any); ok {
+			if options, ok := imageRatio["options"].([]any); ok {
+				labels := make(map[string]string, len(options))
+				for _, option := range options {
+					value := option.(int64)
+					labels[strconv.FormatInt(value, 10)] = common.RatioValue(value)
+				}
+				imageRatio["option_labels"] = labels
+			}
+		}
 	}
-	// Keep unrelated parameter dimensions and combination constraints as supplied.
-	if parameterRaw, ok := fields["parameter_config"]; ok && string(parameterRaw) != "null" {
+	// Image dimensions retain their complete source metadata and combination rules.
+	// Video descriptions keep the existing compact representation.
+	if parameterRaw, ok := fields["parameter_config"]; source.Kind != "image" && ok && string(parameterRaw) != "null" {
 		var parameter map[string]json.RawMessage
 		if err := json.Unmarshal(parameterRaw, &parameter); err != nil {
 			return nil, err
@@ -146,7 +175,7 @@ func describeModel(raw json.RawMessage) (json.RawMessage, error) {
 	if len(limits) > 0 {
 		out["material_limits"] = limits
 	}
-	if source.Creation != nil {
+	if source.Creation != nil && source.Kind != "image" {
 		modes := make([]map[string]any, 0, len(source.Creation.Modes))
 		for _, rawMode := range source.Creation.Modes {
 			if string(rawMode) == "null" {
@@ -181,7 +210,7 @@ func describeModel(raw json.RawMessage) (json.RawMessage, error) {
 			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))
+					fixed := make([]any, 0, len(ratios))
 					for _, value := range ratios {
 						if value != "adaptive" {
 							fixed = append(fixed, value)
@@ -210,7 +239,7 @@ func describeModel(raw json.RawMessage) (json.RawMessage, error) {
 		}
 		out["creation_modes"] = modes
 	}
-	if (source.Key == "MiniMax-H3" || source.Key == "MiniMax-H3-Max") && slices.Contains(ratios, "adaptive") {
+	if source.Kind != "image" && (source.Key == "MiniMax-H3" || source.Key == "MiniMax-H3-Max") && slices.Contains(ratios, "adaptive") {
 		out["notes"] = []string{"MiniMax 使用 adaptive 需要参考图片或视频；纯文生视频请选择固定比例。创作模式的比例策略优先于模型级选项。"}
 	}
 	if len(warnings) > 0 {
@@ -219,8 +248,29 @@ func describeModel(raw json.RawMessage) (json.RawMessage, error) {
 	return json.Marshal(out)
 }
 
-func describeDimension(d *dimensionConfig, warn func(string)) map[string]any {
+// Image generation accepts wire enums; video generation accepts ratio strings.
+func cliRatioValue(value int64, kind string) (any, bool) {
+	label := common.RatioValue(value)
+	if label == "" {
+		return nil, false
+	}
+	if kind == "image" {
+		return value, true
+	}
+	return label, true
+}
+
+func describeDimension(d *dimensionConfig, kind string, warn func(string)) map[string]any {
 	out := map[string]any{}
+	if d.Label != "" {
+		out["label"] = d.Label
+	}
+	if d.Description != "" {
+		out["description"] = d.Description
+	}
+	if d.Required != nil {
+		out["required_field"] = *d.Required
+	}
 	if len(d.ActiveWhenAny) > 0 {
 		out["active_when_any"] = d.ActiveWhenAny
 	}
@@ -230,6 +280,16 @@ func describeDimension(d *dimensionConfig, warn func(string)) map[string]any {
 			number, err := strconv.ParseInt(value, 10, 32)
 			return number, err == nil && number > 0
 		}
+		if d.Key == "ratio" {
+			number, err := strconv.ParseInt(value, 10, 64)
+			if err != nil {
+				return nil, false
+			}
+			return cliRatioValue(number, kind)
+		}
+		if kind == "image" && d.Key == "resolution" {
+			return strings.ToUpper(value), value != ""
+		}
 		return strings.ToLower(value), value != ""
 	}
 	if d.Key == "duration" {

package/internal/models/describe_test.go

@@ -21,12 +21,12 @@ func description(t *testing.T, raw string) map[string]json.RawMessage {
 }
 
 func TestDescriptionCLIParametersAndRawPreservation(t *testing.T) {
-	raw := `{"key":"MiniMax-H3","is_default":true,"supported_ratio_list":[0,2,13,3,4,5,6],"default_ratio":3,"config_key":"internal",
+	raw := `{"key":"MiniMax-H3","kind":"video","is_default":true,"supported_ratio_list":[0,2,13,3,4,5,6],"default_ratio":3,"config_key":"internal",
 	"future_field":9007199254740993,"audio_total_limit":0,"max_image_size":31457280,"min_video_duration":2000,
 	"supported_duration_list":[{"value":999}],"default_duration_value":999,
 	"parameter_config":{"dimensions":[
-	{"key":"duration","default_value":"10","range_config":{"min_value":4,"max_value":15,"step":1}},
-	{"key":"resolution","default_value":" 768P ","option_list":[{"value":"768p"},{"value":"2k"},{"value":"4k","disabled":true}]},
+	{"key":"duration","label":"视频时长","description":"生成的视频时长","required_field":true,"default_value":"10","range_config":{"min_value":4,"max_value":15,"step":1}},
+	{"key":"resolution","label":"视频分辨率","description":"输出清晰度","required_field":false,"default_value":" 768P ","option_list":[{"value":"768p"},{"value":"2k"},{"value":"4k","disabled":true}]},
 	{"key":"seed","default_value":"random"}],"need_available_combinations":true}}
 	`
 	out := description(t, raw)
@@ -46,8 +46,10 @@ func TestDescriptionCLIParametersAndRawPreservation(t *testing.T) {
 		t.Fatalf("ratio=%+v", ratio)
 	}
 	var resolution struct {
-		Options []string
-		Default string
+		Options            []string
+		Default            string
+		Label, Description string
+		Required           *bool `json:"required_field"`
 	}
 	if err := json.Unmarshal(out["resolution"], &resolution); err != nil {
 		t.Fatal(err)
@@ -55,9 +57,14 @@ func TestDescriptionCLIParametersAndRawPreservation(t *testing.T) {
 	if !reflect.DeepEqual(resolution.Options, []string{"768p", "2k"}) || resolution.Default != "768p" {
 		t.Fatalf("resolution=%+v", resolution)
 	}
+	if resolution.Label != "视频分辨率" || resolution.Description != "输出清晰度" || resolution.Required == nil || *resolution.Required {
+		t.Fatalf("video resolution metadata lost: %+v", resolution)
+	}
 	var duration struct {
 		Min, Max, Step, Default int
 		Unit                    string
+		Label, Description      string
+		Required                *bool `json:"required_field"`
 	}
 	if err := json.Unmarshal(out["duration"], &duration); err != nil {
 		t.Fatal(err)
@@ -65,6 +72,9 @@ func TestDescriptionCLIParametersAndRawPreservation(t *testing.T) {
 	if duration.Min != 4 || duration.Max != 15 || duration.Step != 1 || duration.Default != 10 || duration.Unit != "seconds" {
 		t.Fatalf("duration=%+v", duration)
 	}
+	if duration.Label != "视频时长" || duration.Description != "生成的视频时长" || duration.Required == nil || !*duration.Required {
+		t.Fatalf("video duration metadata lost: %+v", duration)
+	}
 	if string(out["future_field"]) != "9007199254740993" {
 		t.Fatal("integer precision lost")
 	}
@@ -197,3 +207,119 @@ func TestDescriptionCreationModesAndCacheNotMutated(t *testing.T) {
 		t.Fatal("description mutated cached raw config")
 	}
 }
+
+func TestImageDescriptionParametersAndConstraints(t *testing.T) {
+	raw := `{"key":"future-image","name":"未来图片模型","report_name":"internal-report-model","kind":"image","is_default":true,
+	"supported_ratio_list":[0,2,6,13,1,999],"default_ratio":6,
+	"parameter_config":{"dimensions":[
+	{"key":"resolution","label":"图片分辨率","required_field":false,"default_value":"2k","option_list":[{"value":"2k","label":"高清"},{"value":"4K","disabled":true}]},
+	{"key":"effort","label":"推理强度","description":"计算档位","required_field":true,"default_value":"HIGH","active_when_any":[{"resolution":["2k"]}],"option_list":[{"value":"low"},{"value":"HIGH","label":"高","description":"更多计算"},{"value":"max","disabled":true}]},
+	{"key":"future-dimension","option_list":[{"value":"future-choice"}]}],
+	"need_available_combinations":true,"combination_dimension_keys":["resolution","effort"],
+	"default_combination":{"resolution":"2k","effort":"HIGH"},
+	"available_combinations":[{"option_values":{"resolution":"2k","effort":"HIGH"}}]},
+	"creation_mode_config":{"modes":[{"key":"reference_generation","enabled":true}]}}
+	`
+	out := description(t, raw)
+	if _, exists := out["key"]; exists || string(out["name"]) != `"未来图片模型"` {
+		t.Fatalf("image identity must contain only the display name: %s", out)
+	}
+	if _, exists := out["report_name"]; exists {
+		t.Fatal("internal reporting model name exposed")
+	}
+	var ratio struct {
+		Options []int64
+		Default int64
+		Labels  map[string]string `json:"option_labels"`
+	}
+	var resolution, effort struct {
+		Options     []string
+		Default     string
+		Required    *bool           `json:"required_field"`
+		Active      json.RawMessage `json:"active_when_any"`
+		Label       string
+		Description string
+	}
+	for key, target := range map[string]any{"ratio": &ratio, "resolution": &resolution, "effort": &effort} {
+		if err := json.Unmarshal(out[key], target); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if !reflect.DeepEqual(ratio.Options, []int64{0, 2, 6, 13}) || ratio.Default != 6 || !reflect.DeepEqual(ratio.Labels, map[string]string{"0": "adaptive", "2": "16:9", "6": "1:1", "13": "21:9"}) {
+		t.Fatalf("ratio=%+v", ratio)
+	}
+	if !reflect.DeepEqual(resolution.Options, []string{"2K"}) || resolution.Default != "2K" || resolution.Required == nil || *resolution.Required {
+		t.Fatalf("resolution=%+v", resolution)
+	}
+	if !reflect.DeepEqual(effort.Options, []string{"low", "high"}) || effort.Default != "high" || effort.Required == nil || !*effort.Required || effort.Label != "推理强度" || effort.Description != "计算档位" || string(effort.Active) != `[{"resolution":["2k"]}]` {
+		t.Fatalf("effort=%+v", effort)
+	}
+	var source map[string]json.RawMessage
+	if err := json.Unmarshal([]byte(raw), &source); err != nil {
+		t.Fatal(err)
+	}
+	var compact bytes.Buffer
+	if err := json.Compact(&compact, source["parameter_config"]); err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(out["parameter_config"], compact.Bytes()) {
+		t.Fatalf("raw dimension metadata or combination rules changed: %s", out["parameter_config"])
+	}
+	if bytes.Contains(out["creation_mode_config"], []byte("generate_type")) || len(out["creation_modes"]) != 0 {
+		t.Fatal("image modes must not acquire video generation selectors")
+	}
+	if _, exists := out["is_default"]; exists {
+		t.Fatal("model default marker exposed")
+	}
+}
+
+func TestImageDescriptionOptionalEffortAndRatioDimension(t *testing.T) {
+	out := description(t, `{"kind":"image","supported_ratio_list":[2],"parameter_config":{"dimensions":[{"key":"ratio","default_value":"13","option_list":[{"value":"13"},{"value":"6"},{"value":"2","disabled":true},{"value":"999"},{"value":"1"}]}]}}`)
+	if len(out["effort"]) != 0 || len(out["resolution"]) != 0 {
+		t.Fatal("absent capabilities must not be invented")
+	}
+	var ratio struct {
+		Options []int64
+		Default int64
+		Labels  map[string]string `json:"option_labels"`
+	}
+	if err := json.Unmarshal(out["ratio"], &ratio); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(ratio.Options, []int64{13, 6}) || ratio.Default != 13 || !reflect.DeepEqual(ratio.Labels, map[string]string{"13": "21:9", "6": "1:1"}) {
+		t.Fatalf("ratio dimension did not override legacy list: %+v", ratio)
+	}
+	for _, raw := range []string{
+		`{"kind":"image","parameter_config":{"dimensions":[{"key":"effort","default_value":"high","option_list":[{"value":"low"},{"value":"high","disabled":true}]}]}}`,
+		`{"kind":"image","parameter_config":{"dimensions":[{"key":"effort","option_list":[]}]}}`,
+	} {
+		out := description(t, raw)
+		if len(out["warnings"]) == 0 || bytes.Contains(out["effort"], []byte(`"default"`)) {
+			t.Fatalf("invalid effort configuration accepted: %s", out["effort"])
+		}
+	}
+	_, err := describeModel(json.RawMessage(`{"kind":"image","parameter_config":{"dimensions":[{"key":"effort"},{"key":"effort"}]}}`))
+	if err == nil {
+		t.Fatal("duplicate effort dimension accepted")
+	}
+}
+
+func TestImageRatioZeroDefaultAndUnavailableValues(t *testing.T) {
+	for _, raw := range []string{
+		`{"kind":"image","supported_ratio_list":[0,0,3,1,999],"default_ratio":0}`,
+		`{"kind":"image","parameter_config":{"dimensions":[{"key":"ratio","default_value":"0","option_list":[{"value":"0"},{"value":"0"},{"value":"3"},{"value":"6","disabled":true},{"value":"1"},{"value":"999"}]}]}}`,
+	} {
+		out := description(t, raw)
+		var ratio struct {
+			Options []int64
+			Default *int64
+			Labels  map[string]string `json:"option_labels"`
+		}
+		if err := json.Unmarshal(out["ratio"], &ratio); err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(ratio.Options, []int64{0, 3}) || ratio.Default == nil || *ratio.Default != 0 || !reflect.DeepEqual(ratio.Labels, map[string]string{"0": "adaptive", "3": "9:16"}) {
+			t.Fatalf("numeric zero default or available ratio values changed: %s", out["ratio"])
+		}
+	}
+}