@pippit-dev/cli 1.0.31 → 1.0.33

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"])
+		}
+	}
+}

package/internal/models/models.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 	"time"
 
@@ -16,12 +17,14 @@ import (
 )
 
 const (
-	Scene    = "web_turbo_video_generator"
-	CacheTTL = 5 * time.Minute
+	VideoScene = "web_turbo_video_generator"
+	ImageScene = "web_image_agent"
+	CacheTTL   = 5 * time.Minute
 )
 
 // Catalog preserves the server's model configuration, including unknown fields
-// and integer enums. It is never used as a local generation allowlist.
+// and integer enums. Image names are resolved here before submission; admission
+// and parameter validation remain the server's responsibility.
 type Catalog struct {
 	Scene     string `json:"scene"`
 	ConfigKey string `json:"config_key"`
@@ -31,7 +34,7 @@ type Catalog struct {
 }
 
 type Summary struct {
-	Key  string `json:"key"`
+	Key  string `json:"key,omitempty"`
 	Name string `json:"name"`
 	Kind string `json:"kind"`
 }
@@ -62,7 +65,22 @@ func NewService(runner *common.Runner) *Service {
 	return &Service{runner: runner, cacheDir: dir, now: time.Now}
 }
 
-func (s *Service) Get(ctx context.Context, refresh bool) (*Result, error) {
+func sceneForType(modelType string) (string, error) {
+	switch modelType {
+	case "video":
+		return VideoScene, nil
+	case "image":
+		return ImageScene, nil
+	default:
+		return "", fmt.Errorf("不支持的模型类型 %q；--type 可选 video 或 image", modelType)
+	}
+}
+
+func (s *Service) Get(ctx context.Context, modelType string, refresh bool) (*Result, error) {
+	scene, err := sceneForType(modelType)
+	if err != nil {
+		return nil, err
+	}
 	if err := ctx.Err(); err != nil {
 		return nil, err
 	}
@@ -79,9 +97,9 @@ func (s *Service) Get(ctx context.Context, refresh bool) (*Result, error) {
 	if s.runner.Config.Paths != nil && s.runner.Config.Paths.GetAvailableModelList != "" {
 		path = s.runner.Config.Paths.GetAvailableModelList
 	}
-	cachePath := s.cachePath(accessKey, path)
+	cachePath := s.cachePath(accessKey, path, scene)
 	if !refresh && cachePath != "" {
-		if entry := s.readCache(cachePath); entry != nil {
+		if entry := s.readCache(cachePath, scene); entry != nil {
 			return &Result{Catalog: entry.Catalog, Cached: true, FetchedAt: entry.FetchedAt}, nil
 		}
 	}
@@ -100,14 +118,14 @@ func (s *Service) Get(ctx context.Context, refresh bool) (*Result, error) {
 	err = s.runner.Client.SendRequest(queryCtx, path, struct {
 		Scene          string `json:"scene"`
 		SourceModelKey string `json:"source_model_key"`
-	}{Scene: Scene}, &resp)
+	}{Scene: scene}, &resp)
 	if err != nil {
 		return nil, fmt.Errorf("模型查询失败，请稍后重试（可加 --refresh）: %w", err)
 	}
 	if resp.Ret != "0" {
 		return nil, common.NewLogIDError(fmt.Sprintf("模型查询失败，请稍后重试（可加 --refresh）: ret=%s errmsg=%s", resp.Ret, resp.Errmsg), resp.LogID)
 	}
-	if err := validateCatalog(resp.Data); err != nil {
+	if err := validateCatalog(resp.Data, scene); err != nil {
 		return nil, common.NewLogIDError("模型配置无效，请稍后重试（可加 --refresh）: "+err.Error(), resp.LogID)
 	}
 	currentKey, err := s.runner.Auth.ResolveAccessKey(ctx)
@@ -121,24 +139,24 @@ func (s *Service) Get(ctx context.Context, refresh bool) (*Result, error) {
 	return result, nil
 }
 
-func (s *Service) cachePath(accessKey, path string) string {
+func (s *Service) cachePath(accessKey, path, scene string) string {
 	if s.cacheDir == "" {
 		return ""
 	}
 	scope, _ := json.Marshal([]string{
-		"v1", strings.TrimRight(s.runner.Config.BaseURL, "/"), path, Scene,
+		"v1", strings.TrimRight(s.runner.Config.BaseURL, "/"), path, scene,
 		version.Current(), accessKey,
 	})
 	return filepath.Join(s.cacheDir, fmt.Sprintf("%x.json", sha256.Sum256(scope)))
 }
 
-func (s *Service) readCache(path string) *cacheEntry {
+func (s *Service) readCache(path, scene string) *cacheEntry {
 	raw, err := os.ReadFile(path)
 	if err != nil {
 		return nil
 	}
 	var entry cacheEntry
-	if json.Unmarshal(raw, &entry) != nil || validateCatalog(entry.Catalog) != nil {
+	if json.Unmarshal(raw, &entry) != nil || validateCatalog(entry.Catalog, scene) != nil {
 		return nil
 	}
 	age := s.now().Sub(entry.FetchedAt)
@@ -172,20 +190,37 @@ func (s *Service) writeCache(path string, result *Result) error {
 	return os.Rename(f.Name(), path)
 }
 
-func validateCatalog(catalog *Catalog) error {
-	if catalog == nil || catalog.Config == nil || catalog.Scene != Scene || catalog.ConfigKey == "" {
+func validateCatalog(catalog *Catalog, scene string) error {
+	kind := "video"
+	if scene == ImageScene {
+		kind = "image"
+	} else if scene != VideoScene {
+		return fmt.Errorf("不支持的模型场景 %q", scene)
+	}
+	if catalog == nil || catalog.Config == nil || catalog.Scene != scene || catalog.ConfigKey == "" {
 		return fmt.Errorf("缺少配置或场景不匹配")
 	}
 	seen := make(map[string]bool)
+	seenNames := make(map[string]bool)
 	for _, raw := range catalog.Config.Models {
 		var model Summary
-		if json.Unmarshal(raw, &model) != nil || strings.TrimSpace(model.Key) == "" || model.Kind != "video" {
+		if json.Unmarshal(raw, &model) != nil || strings.TrimSpace(model.Key) == "" || model.Kind != kind {
 			return fmt.Errorf("模型条目缺少有效 key 或 kind")
 		}
 		if seen[model.Key] {
+			if kind == "image" {
+				return fmt.Errorf("图片模型配置包含重复条目")
+			}
 			return fmt.Errorf("模型 key 重复: %s", model.Key)
 		}
 		seen[model.Key] = true
+		if kind == "image" {
+			name := strings.TrimSpace(model.Name)
+			if name == "" || strings.EqualFold(name, strings.TrimSpace(model.Key)) || seenNames[name] {
+				return fmt.Errorf("图片模型展示名称缺失、与模型标识相同或重复，请刷新模型列表")
+			}
+			seenNames[name] = true
+		}
 	}
 	return nil
 }
@@ -196,7 +231,10 @@ func (c *Catalog) Search(query string) []Summary {
 	for _, raw := range c.Config.Models {
 		var model Summary
 		_ = json.Unmarshal(raw, &model) // validated at the network/cache boundary
-		if model.Key == query {
+		if c.Scene == ImageScene {
+			model.Key = "" // Wire identifiers stay in the raw catalog only.
+			model.Name = strings.TrimSpace(model.Name)
+		} else if model.Key == query {
 			return []Summary{model}
 		}
 		if query == "" || strings.Contains(strings.ToLower(model.Name), strings.ToLower(query)) || strings.Contains(strings.ToLower(model.Key), strings.ToLower(query)) {
@@ -206,14 +244,78 @@ func (c *Catalog) Search(query string) []Summary {
 	return matches
 }
 
-func (c *Catalog) Describe(key string) (json.RawMessage, error) {
-	key = strings.TrimSpace(key)
+func (c *Catalog) findModel(selector string) (json.RawMessage, error) {
+	selector = strings.TrimSpace(selector)
+	var found json.RawMessage
 	for _, raw := range c.Config.Models {
 		var model Summary
 		_ = json.Unmarshal(raw, &model)
-		if model.Key == key {
-			return describeModel(raw)
+		value := model.Key
+		if c.Scene == ImageScene {
+			value = strings.TrimSpace(model.Name)
 		}
+		if value != "" && value == selector {
+			if found != nil {
+				return nil, fmt.Errorf("模型名称重复，请执行 model list --type image --refresh 刷新后重试")
+			}
+			found = raw
+		}
+	}
+	if found != nil {
+		return found, nil
+	}
+	if c.Scene == ImageScene {
+		return nil, fmt.Errorf("未找到该图片模型名称；请执行 model list --type image --refresh，并使用列表中的完整名称")
+	}
+	return nil, fmt.Errorf("未找到可用模型 %q；请执行 model list --type video --refresh 查看当前模型", selector)
+}
+
+func (c *Catalog) Describe(selector string) (json.RawMessage, error) {
+	raw, err := c.findModel(selector)
+	if err != nil {
+		return nil, err
+	}
+	return describeModel(raw)
+}
+
+// ImageModelKey translates the user's exact display name into a wire value.
+// Never guess keys from names or send an unresolved name to the server.
+func (c *Catalog) ImageModelKey(name string) (string, error) {
+	if c.Scene != ImageScene {
+		return "", fmt.Errorf("图片生成需要图片模型配置")
+	}
+	raw, err := c.findModel(name)
+	if err != nil {
+		return "", err
+	}
+	var model Summary
+	_ = json.Unmarshal(raw, &model)
+	return model.Key, nil
+}
+
+// ImageDisplayMessage keeps known wire identifiers out of server error messages.
+func (c *Catalog) ImageDisplayMessage(message string) string {
+	var models []Summary
+	for _, raw := range c.Config.Models {
+		var model struct {
+			Summary
+			ReportName string `json:"report_name"`
+		}
+		_ = json.Unmarshal(raw, &model)
+		name := strings.TrimSpace(model.Name)
+		if model.Kind == "image" && name != "" {
+			for _, value := range []string{model.Key, model.ReportName} {
+				if value != "" && value != name {
+					models = append(models, Summary{Key: value, Name: name})
+				}
+			}
+		}
+	}
+	// A key can be a prefix of another key. Replace the longer one first.
+	sort.Slice(models, func(i, j int) bool { return len(models[i].Key) > len(models[j].Key) })
+	pairs := make([]string, 0, len(models)*2)
+	for _, model := range models {
+		pairs = append(pairs, model.Key, strings.TrimSpace(model.Name))
 	}
-	return nil, fmt.Errorf("未找到可用模型 %q；请执行 model list --refresh 查看当前模型", key)
+	return strings.NewReplacer(pairs...).Replace(message)
 }