fix: add default duration for audio command

Adds a default value for required duration on audio inference.

Also refactors flag parsing to have shorthand names and use coba prerun for validation

Author: danmrichards

cmd/constants.go

@@ -25,4 +25,8 @@ const (
 	defaultImageDownloadTimeout = 1 * time.Minute
 	defaultAudioDownloadTimeout = 5 * time.Minute
 	defaultVideoDownloadTimeout = 10 * time.Minute
+
+	// Audio defaults.
+	defaultMinAudioDuration = 10.0
+	maxAudioDuration        = 300.0
 )

cmd/inference_audio.go

@@ -15,6 +15,23 @@ import (
 	"github.com/spf13/cobra"
 )
 
+var audioFlags struct {
+	model           string
+	duration        float64
+	count           int
+	outputDir       string
+	outputFormat    string
+	noDownload      bool
+	includeCost     bool
+	sampleRate      int
+	bitrate         int
+	preset          string
+	dryRun          bool
+	pollInterval    time.Duration
+	timeout         time.Duration
+	downloadTimeout time.Duration
+}
+
 var audioInferenceCmd = &cobra.Command{
 	Use:   "audio [prompt]",
 	Short: "Generate audio from text descriptions",
@@ -24,26 +41,27 @@ Examples:
   runware inference audio "a jazz piano solo with soft drums" --model elevenlabs:1@1 --duration 30
   runware inference audio "ocean waves crashing on rocks" --model elevenlabs:1@1 --duration 60
   runware inference audio "upbeat electronic music" --model elevenlabs:1@1 --duration 120 --sample-rate 48000`,
-	Args: cobra.ExactArgs(1),
-	RunE: runAudioInference,
+	Args:    cobra.ExactArgs(1),
+	PreRunE: preRunAudioInference,
+	RunE:    runAudioInference,
 }
 
 func init() {
 	f := audioInferenceCmd.Flags()
-	f.String("model", "", "Model identifier (e.g. elevenlabs:1@1)")
-	f.Float64("duration", 0, "Audio duration in seconds (10-300)")
-	f.Int("count", 1, "Number of audio files to generate (max 3)")
-	f.String("output", "", "Output directory")
-	f.String("output-format", "", "Audio format: mp3")
-	f.Bool("no-download", false, "Print audio URLs instead of downloading")
-	f.Bool("include-cost", false, "Include cost info in response")
-	f.Int("sample-rate", 0, "Sample rate in Hz (8000-48000)")
-	f.Int("bitrate", 0, "Bitrate in kbps (32-320, compressed formats only)")
-	f.String("preset", "", "Named preset to apply")
-	f.Bool("dry-run", false, "Print the API request without executing")
-	f.Duration("poll-interval", defaultPollInterval, "Polling interval for async results")
-	f.Duration("timeout", defaultAudioGenerationTimeout, "Maximum wait time for audio generation")
-	f.Duration("download-timeout", defaultAudioDownloadTimeout, "timeout to use when downloading audio inference results")
+	f.StringVarP(&audioFlags.model, "model", "m", "", "Model identifier (e.g. elevenlabs:1@1)")
+	f.Float64VarP(&audioFlags.duration, "duration", "d", defaultMinAudioDuration, "Audio duration in seconds (10-300)")
+	f.IntVarP(&audioFlags.count, "count", "n", 1, "Number of audio files to generate (max 3)")
+	f.StringVarP(&audioFlags.outputDir, "output", "o", "", "Output directory")
+	f.StringVarP(&audioFlags.outputFormat, "output-format", "f", "", "Audio format: mp3")
+	f.BoolVarP(&audioFlags.noDownload, "no-download", "D", false, "Print audio URLs instead of downloading")
+	f.BoolVarP(&audioFlags.includeCost, "include-cost", "c", false, "Include cost info in response")
+	f.IntVarP(&audioFlags.sampleRate, "sample-rate", "r", 0, "Sample rate in Hz (8000-48000)")
+	f.IntVarP(&audioFlags.bitrate, "bitrate", "b", 0, "Bitrate in kbps (32-320, compressed formats only)")
+	f.StringVarP(&audioFlags.preset, "preset", "p", "", "Named preset to apply")
+	f.BoolVarP(&audioFlags.dryRun, "dry-run", "X", false, "Print the API request without executing")
+	f.DurationVarP(&audioFlags.pollInterval, "poll-interval", "i", defaultPollInterval, "Polling interval for async results")
+	f.DurationVarP(&audioFlags.timeout, "timeout", "t", defaultAudioGenerationTimeout, "Maximum wait time for audio generation")
+	f.DurationVarP(&audioFlags.downloadTimeout, "download-timeout", "T", defaultAudioDownloadTimeout, "Timeout for downloading audio results")
 
 	audioInferenceCmd.RegisterFlagCompletionFunc("output-format", func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) { //nolint:errcheck,gosec
 		return []cobra.Completion{string(api.OutputFormatMP3)}, cobra.ShellCompDirectiveNoFileComp
@@ -52,6 +70,16 @@ func init() {
 	audioInferenceCmd.RegisterFlagCompletionFunc("preset", completePresetNames) //nolint:errcheck,gosec
 }
 
+func preRunAudioInference(_ *cobra.Command, _ []string) error {
+	if audioFlags.duration < defaultMinAudioDuration || audioFlags.duration > maxAudioDuration {
+		return fmt.Errorf("--duration must be between %.0f and %.0f seconds", defaultMinAudioDuration, maxAudioDuration)
+	}
+	if audioFlags.count < 1 || audioFlags.count > 3 {
+		return fmt.Errorf("--count must be between 1 and 3")
+	}
+	return nil
+}
+
 func runAudioInference(cmd *cobra.Command, args []string) error {
 	ctx := cmd.Context()
 	if ctx == nil {
@@ -71,11 +99,10 @@ func runAudioInference(cmd *cobra.Command, args []string) error {
 	outputDir := cfg.Defaults.OutputDir
 
 	// Apply preset if specified
-	presetName, _ := cmd.Flags().GetString("preset")
-	if presetName != "" {
-		preset := config.GetPreset(presetName)
+	if audioFlags.preset != "" {
+		preset := config.GetPreset(audioFlags.preset)
 		if preset == nil {
-			return fmt.Errorf("preset '%s' not found", presetName)
+			return fmt.Errorf("preset '%s' not found", audioFlags.preset)
 		}
 		if preset.Model != "" {
 			model = preset.Model
@@ -84,57 +111,39 @@ func runAudioInference(cmd *cobra.Command, args []string) error {
 
 	// Override with explicit CLI flags
 	if cmd.Flags().Changed("model") {
-		model, _ = cmd.Flags().GetString("model")
+		model = audioFlags.model
 	}
 	if cmd.Flags().Changed("output") {
-		outputDir, _ = cmd.Flags().GetString("output")
-	}
-
-	duration, _ := cmd.Flags().GetFloat64("duration")
-	count, _ := cmd.Flags().GetInt("count")
-	outputFormat, _ := cmd.Flags().GetString("output-format")
-	noDownload, _ := cmd.Flags().GetBool("no-download")
-	includeCost, _ := cmd.Flags().GetBool("include-cost")
-	dryRun, _ := cmd.Flags().GetBool("dry-run")
-	sampleRate, _ := cmd.Flags().GetInt("sample-rate")
-	bitrate, _ := cmd.Flags().GetInt("bitrate")
-	pollInterval, _ := cmd.Flags().GetDuration("poll-interval")
-	timeout, _ := cmd.Flags().GetDuration("timeout")
-	downloadTimeout, _ := cmd.Flags().GetDuration("download-timeout")
-
-	// Validation
-	if duration <= 0 {
-		return fmt.Errorf("--duration is required (10-300 seconds)")
+		outputDir = audioFlags.outputDir
 	}
 
 	// Build request
 	req := &api.AudioInferenceRequest{
 		TaskUUID:       api.NewUUID(),
 		Model:          model,
 		PositivePrompt: prompt,
-		Duration:       duration,
+		Duration:       audioFlags.duration,
 		DeliveryMethod: api.DeliveryMethodAsync,
-		IncludeCost:    includeCost,
+		IncludeCost:    audioFlags.includeCost,
+		NumberResults:  audioFlags.count,
 	}
 
-	req.NumberResults = count
-	if outputFormat != "" {
-		req.OutputFormat = api.OutputFormat(outputFormat)
+	if audioFlags.outputFormat != "" {
+		req.OutputFormat = api.OutputFormat(audioFlags.outputFormat)
 	}
 
-	// Audio settings
-	if sampleRate > 0 || bitrate > 0 {
+	if audioFlags.sampleRate > 0 || audioFlags.bitrate > 0 {
 		req.AudioSettings = &api.AudioSettings{}
-		if sampleRate > 0 {
-			req.AudioSettings.SampleRate = sampleRate
+		if audioFlags.sampleRate > 0 {
+			req.AudioSettings.SampleRate = audioFlags.sampleRate
 		}
-		if bitrate > 0 {
-			req.AudioSettings.Bitrate = bitrate
+		if audioFlags.bitrate > 0 {
+			req.AudioSettings.Bitrate = audioFlags.bitrate
 		}
 	}
 
 	// Dry run
-	if dryRun {
+	if audioFlags.dryRun {
 		data, _ := json.MarshalIndent([]any{req}, "", "  ")
 		fmt.Println(string(data))
 		return nil
@@ -148,7 +157,6 @@ func runAudioInference(cmd *cobra.Command, args []string) error {
 	_, err := client.AudioInference(context.Background(), req)
 	if err != nil {
 		s.Stop()
-
 		if api.IsAuthError(err) {
 			output.Error("Authentication failed. Run 'runware auth login' to set your API key.")
 			return err
@@ -158,16 +166,14 @@ func runAudioInference(cmd *cobra.Command, args []string) error {
 
 	s.Suffix(" Generating audio (this may take a few minutes)...")
 
-	taskUUID := req.TaskUUID
-
-	pollCtx, cancel := context.WithTimeout(cmd.Context(), timeout)
+	pollCtx, cancel := context.WithTimeout(cmd.Context(), audioFlags.timeout)
 	defer cancel()
 
 	results, err := api.PollResults(
 		pollCtx,
 		client,
-		taskUUID,
-		pollInterval,
+		req.TaskUUID,
+		audioFlags.pollInterval,
 		flagVerbose,
 		func(raw json.RawMessage) (api.AudioInferenceResult, bool) {
 			var r api.AudioInferenceResult
@@ -186,7 +192,7 @@ func runAudioInference(cmd *cobra.Command, args []string) error {
 	if len(results) == 0 {
 		s.Stop()
 		output.Error("Audio generation timed out or returned no results")
-		return fmt.Errorf("no audio results after %v", timeout)
+		return fmt.Errorf("no audio results after %v", audioFlags.timeout)
 	}
 
 	// JSON/YAML output
@@ -196,21 +202,20 @@ func runAudioInference(cmd *cobra.Command, args []string) error {
 		return output.Print(format, results, nil, nil)
 	}
 
-	// Table output
-	if noDownload {
+	// Table output — no-download: just print URLs
+	if audioFlags.noDownload {
 		headers := []any{tableHeaderNum, tableHeaderURL}
-		if includeCost {
+		if audioFlags.includeCost {
 			headers = append(headers, tableHeaderCost)
 		}
 		var rows [][]any
 		for i, r := range results {
 			row := []any{i + 1, r.AudioURL}
-			if includeCost {
+			if audioFlags.includeCost {
 				row = append(row, fmt.Sprintf("%.4f", r.Cost))
 			}
 			rows = append(rows, row)
 		}
-
 		s.Stop()
 		return output.Print(format, results, headers, rows)
 	}
@@ -223,26 +228,26 @@ func runAudioInference(cmd *cobra.Command, args []string) error {
 	}
 
 	headers := []any{tableHeaderNum, tableHeaderFile}
-	if includeCost {
+	if audioFlags.includeCost {
 		headers = append(headers, tableHeaderCost)
 	}
 	var rows [][]any
 
 	for i, r := range results {
-		ext := outputFormat
+		ext := audioFlags.outputFormat
 		if ext == "" {
 			ext = string(api.OutputFormatMP3)
 		}
 		filename := fmt.Sprintf("runware_%s_%d.%s", time.Now().Format("20060102_150405"), i+1, ext)
 		destPath := filepath.Join(outputDir, filename)
 
-		if err := rhttp.Download(ctx, r.AudioURL, destPath, downloadTimeout); err != nil {
+		if err := rhttp.Download(ctx, r.AudioURL, destPath, audioFlags.downloadTimeout); err != nil {
 			output.Error(fmt.Sprintf("Failed to download audio %d: %s", i+1, err))
 			continue
 		}
 
 		row := []any{i + 1, destPath}
-		if includeCost {
+		if audioFlags.includeCost {
 			row = append(row, fmt.Sprintf("%.4f", r.Cost))
 		}
 		rows = append(rows, row)