@pippit-dev/cli 1.0.26 → 1.0.28

package/internal/generate_video/generate_video.go

@@ -18,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
@@ -54,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 {
@@ -116,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
+}

package/internal/models/describe_test.go

@@ -0,0 +1,199 @@
+package models
+
+import (
+	"bytes"
+	"encoding/json"
+	"reflect"
+	"testing"
+)
+
+func description(t *testing.T, raw string) map[string]json.RawMessage {
+	t.Helper()
+	out, err := describeModel(json.RawMessage(raw))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var fields map[string]json.RawMessage
+	if err := json.Unmarshal(out, &fields); err != nil {
+		t.Fatal(err)
+	}
+	return fields
+}
+
+func TestDescriptionCLIParametersAndRawPreservation(t *testing.T) {
+	raw := `{"key":"MiniMax-H3","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":"seed","default_value":"random"}],"need_available_combinations":true}}
+	`
+	out := description(t, raw)
+	for _, key := range []string{"config_key", "supported_ratio_list", "default_ratio", "supported_duration_list", "default_duration_value", "audio_total_limit", "max_image_size"} {
+		if _, ok := out[key]; ok {
+			t.Fatalf("unconverted field %s", key)
+		}
+	}
+	var ratio struct {
+		Options []string
+		Default string
+	}
+	if err := json.Unmarshal(out["ratio"], &ratio); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(ratio.Options, []string{"adaptive", "16:9", "21:9", "9:16", "4:3", "3:4", "1:1"}) || ratio.Default != "9:16" {
+		t.Fatalf("ratio=%+v", ratio)
+	}
+	var resolution struct {
+		Options []string
+		Default string
+	}
+	if err := json.Unmarshal(out["resolution"], &resolution); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(resolution.Options, []string{"768p", "2k"}) || resolution.Default != "768p" {
+		t.Fatalf("resolution=%+v", resolution)
+	}
+	var duration struct {
+		Min, Max, Step, Default int
+		Unit                    string
+	}
+	if err := json.Unmarshal(out["duration"], &duration); err != nil {
+		t.Fatal(err)
+	}
+	if duration.Min != 4 || duration.Max != 15 || duration.Step != 1 || duration.Default != 10 || duration.Unit != "seconds" {
+		t.Fatalf("duration=%+v", duration)
+	}
+	if string(out["future_field"]) != "9007199254740993" {
+		t.Fatal("integer precision lost")
+	}
+	var limits map[string]json.RawMessage
+	if err := json.Unmarshal(out["material_limits"], &limits); err != nil {
+		t.Fatal(err)
+	}
+	if string(limits["audio_total_limit"]) != "0" || string(limits["max_image_size_bytes"]) != "31457280" || string(limits["min_video_duration_ms"]) != "2000" {
+		t.Fatalf("limits=%s", out["material_limits"])
+	}
+	if _, ok := limits["video_total_limit"]; ok {
+		t.Fatal("absent limit must stay absent")
+	}
+	if !bytes.Contains(out["parameter_config"], []byte("seed")) || !bytes.Contains(out["parameter_config"], []byte("need_available_combinations")) {
+		t.Fatal("unrelated configuration lost")
+	}
+	if _, ok := out["warnings"]; ok {
+		t.Fatalf("valid dimensions must override legacy durations: %s", out["warnings"])
+	}
+	if !bytes.Contains(out["notes"], []byte("纯文生视频")) {
+		t.Fatal("missing MiniMax adaptive restriction")
+	}
+}
+
+func TestDescriptionUnknownRatioAndDefault(t *testing.T) {
+	for _, value := range []int{1, 999} {
+		raw, _ := json.Marshal(map[string]any{"supported_ratio_list": []int{value, 2, 2}, "default_ratio": value})
+		out := description(t, string(raw))
+		var ratio struct {
+			Options []string
+			Default *string
+		}
+		if err := json.Unmarshal(out["ratio"], &ratio); err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(ratio.Options, []string{"16:9"}) || ratio.Default != nil {
+			t.Fatalf("invented usable value: %+v", ratio)
+		}
+		if _, exists := out["warnings"]; exists {
+			t.Fatal("unknown and custom enums should be silently skipped")
+		}
+	}
+	out := description(t, `{"supported_ratio_list":[0,7,8,9,10,11,12],"default_ratio":0}`)
+	var ratio struct {
+		Options []string
+		Default string
+	}
+	if err := json.Unmarshal(out["ratio"], &ratio); err != nil {
+		t.Fatal(err)
+	}
+	if ratio.Default != "adaptive" || !reflect.DeepEqual(ratio.Options, []string{"adaptive", "2:1", "2.35:1", "1.85:1", "1.125:2.436", "3:2", "2:3"}) {
+		t.Fatalf("ratio=%+v", ratio)
+	}
+}
+
+func TestDescriptionDimensionFailuresAndOptions(t *testing.T) {
+	for _, dimension := range []string{
+		`{"key":"resolution","default_value":"2k","option_list":[{"value":"768p"},{"value":"2k","disabled":true}]}`,
+		`{"key":"resolution","default_value":"","option_list":[]}`,
+		`{"key":"duration","default_value":"7","range_config":{"min_value":4,"max_value":10,"step":2}}`,
+		`{"key":"duration","range_config":{"min_value":10,"max_value":4}}`,
+		`{"key":"duration","option_list":[{"value":"auto"}]}`,
+	} {
+		out := description(t, `{"parameter_config":{"dimensions":[`+dimension+`]}}`)
+		if _, ok := out["warnings"]; !ok {
+			t.Fatalf("missing warning: %s", dimension)
+		}
+		for _, key := range []string{"resolution", "duration"} {
+			var value map[string]json.RawMessage
+			if len(out[key]) == 0 {
+				continue
+			}
+			if err := json.Unmarshal(out[key], &value); err != nil {
+				t.Fatal(err)
+			}
+			if _, ok := value["default"]; ok {
+				t.Fatalf("invalid default exposed: %s", out[key])
+			}
+		}
+	}
+	out := description(t, `{"parameter_config":{"dimensions":[{"key":"duration","default_value":"10","option_list":[{"value":"5"},{"value":"10"},{"value":"15","disabled":true}]}]}}`)
+	var duration struct {
+		Options []int
+		Default int
+		Min     *int
+	}
+	if err := json.Unmarshal(out["duration"], &duration); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(duration.Options, []int{5, 10}) || duration.Default != 10 || duration.Min != nil {
+		t.Fatalf("duration=%+v", duration)
+	}
+}
+
+func TestDescriptionCreationModesAndCacheNotMutated(t *testing.T) {
+	raw := json.RawMessage(`{"key":"MiniMax-H3-Max","kind":"video","supported_ratio_list":[0,2],"default_ratio":2,"creation_mode_config":{"schema_version":1,"default_mode":"text_to_video","modes":[{"key":"text_to_video","enabled":true,"ratio_policy":{"value_mode":"inherit"}},{"key":"first_last_frame","enabled":true,"ratio_policy":{"value_mode":"smart"},"validation_policy":{"required_video_count":0,"forbidden_input_types":["video","audio"]}}]}}`)
+	before := append([]byte(nil), raw...)
+	var catalog Catalog
+	if err := json.Unmarshal([]byte(`{"config":{"models":[]}}`), &catalog); err != nil {
+		t.Fatal(err)
+	}
+	catalog.Config.Models = append(catalog.Config.Models, raw)
+	result, err := catalog.Describe("MiniMax-H3-Max")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var out struct {
+		Modes []struct {
+			GenerateType int `json:"generate_type"`
+			Ratio        struct {
+				Options []string
+				Default string
+			}
+			Validation struct {
+				Required  *int     `json:"required_video_count"`
+				Forbidden []string `json:"forbidden_input_types"`
+			} `json:"validation_policy"`
+		} `json:"creation_modes"`
+	}
+	if err := json.Unmarshal(result, &out); err != nil {
+		t.Fatal(err)
+	}
+	if len(out.Modes) != 2 || out.Modes[0].Ratio.Default != "16:9" || !reflect.DeepEqual(out.Modes[0].Ratio.Options, []string{"16:9"}) || out.Modes[1].GenerateType != 1 || out.Modes[1].Ratio.Default != "adaptive" || !reflect.DeepEqual(out.Modes[1].Ratio.Options, []string{"adaptive"}) {
+		t.Fatalf("modes=%+v", out.Modes)
+	}
+	if out.Modes[1].Validation.Required == nil || *out.Modes[1].Validation.Required != 0 || !reflect.DeepEqual(out.Modes[1].Validation.Forbidden, []string{"video", "audio"}) {
+		t.Fatal("mode requirements lost")
+	}
+	if !bytes.Equal(before, catalog.Config.Models[0]) {
+		t.Fatal("description mutated cached raw config")
+	}
+}