feat: error out early for incompatible flags

Author: kardolus

cmd/chatgpt/main.go

@@ -134,7 +134,7 @@ func run(cmd *cobra.Command, args []string) error {
 		changedFlags[f.Name] = true
 	})
 
-	if err := utils.ValidateFlags(changedFlags); err != nil {
+	if err := utils.ValidateFlags(cfg.Model, changedFlags); err != nil {
 		return err
 	}
 

cmd/chatgpt/utils/utils.go

@@ -9,6 +9,13 @@ import (
 	"unicode/utf8"
 )
 
+const (
+	AudioPattern      = "-audio"
+	TranscribePattern = "-transcribe"
+	TTSPattern        = "-tts"
+	O1ProPattern      = "o1-pro"
+)
+
 func ColorToAnsi(color string) (string, string) {
 	if color == "" {
 		return "", ""
@@ -100,7 +107,7 @@ func IsBinary(data []byte) bool {
 	return binaryCount > threshold
 }
 
-func ValidateFlags(flags map[string]bool) error {
+func ValidateFlags(model string, flags map[string]bool) error {
 	if flags["new-thread"] && (flags["set-thread"] || flags["thread"]) {
 		return errors.New("the --new-thread flag cannot be used with the --set-thread or --thread flags")
 	}
@@ -110,6 +117,21 @@ func ValidateFlags(flags map[string]bool) error {
 	if !flags["speak"] && flags["output"] {
 		return errors.New("the --speak flag cannot be used without the --output flag")
 	}
+	if flags["audio"] && !strings.Contains(model, AudioPattern) {
+		return errors.New("the --audio flag cannot be used without a compatible model, ie gpt-4o-audio-preview (see --list-models)")
+	}
+	if flags["transcribe"] && !strings.Contains(model, TranscribePattern) {
+		return errors.New("the --transcribe flag cannot be used without a compatible model, ie gpt-4o-transcribe (see --list-models)")
+	}
+	if flags["speak"] && flags["output"] && !strings.Contains(model, TTSPattern) {
+		return errors.New("the --speak and --output flags cannot be used without a compatible model, ie gpt-4o-mini-tts (see --list-models)")
+	}
+	if flags["voice"] && !strings.Contains(model, TTSPattern) {
+		return errors.New("the --voice flag cannot be used without a compatible model, ie gpt-4o-mini-tts (see --list-models)")
+	}
+	if flags["effort"] && !strings.Contains(model, O1ProPattern) {
+		return errors.New("the --effort flag cannot be used with non o1-pro models (see --list-models)")
+	}
 
 	return nil
 }

cmd/chatgpt/utils/utils_test.go

@@ -190,39 +190,104 @@ func testUtils(t *testing.T, when spec.G, it spec.S) {
 	})
 
 	when("ValidateFlags()", func() {
+		const defaultModel = "mock-model"
+
+		var flags map[string]bool
+
+		it.Before(func() {
+			flags = make(map[string]bool)
+		})
+
 		it("doesn't throw an error when no flags are provided", func() {
-			flags := make(map[string]bool)
-			Expect(utils.ValidateFlags(flags)).To(Succeed())
+			Expect(utils.ValidateFlags(defaultModel, flags)).To(Succeed())
 		})
-		it("should return an error when new-thread and set-thread are both used", func() {
-			flags := make(map[string]bool)
+		it("should return an error when --new-thread and --set-thread are both used", func() {
 			flags["new-thread"] = true
 			flags["set-thread"] = true
 
-			err := utils.ValidateFlags(flags)
+			err := utils.ValidateFlags(defaultModel, flags)
 			Expect(err).To(HaveOccurred())
 		})
-		it("should return an error when new-thread and thread are both used", func() {
-			flags := make(map[string]bool)
+		it("should return an error when --new-thread and --thread are both used", func() {
 			flags["new-thread"] = true
 			flags["thread"] = true
 
-			err := utils.ValidateFlags(flags)
+			err := utils.ValidateFlags(defaultModel, flags)
 			Expect(err).To(HaveOccurred())
 		})
-		it("should return an error when speak is used but output is omitted", func() {
-			flags := make(map[string]bool)
+		it("should return an error when --speak is used but --output is omitted", func() {
 			flags["speak"] = true
 
-			err := utils.ValidateFlags(flags)
+			err := utils.ValidateFlags(defaultModel, flags)
 			Expect(err).To(HaveOccurred())
 		})
-		it("should return an error when output is used but speak is omitted", func() {
-			flags := make(map[string]bool)
+		it("should return an error when --output is used but --speak is omitted", func() {
 			flags["output"] = true
 
-			err := utils.ValidateFlags(flags)
+			err := utils.ValidateFlags(defaultModel, flags)
 			Expect(err).To(HaveOccurred())
 		})
+		it("should return an error when --audio is used with an incompatible model", func() {
+			flags["audio"] = true
+
+			err := utils.ValidateFlags(defaultModel, flags)
+			Expect(err).To(HaveOccurred())
+		})
+		it("should NOT return an error when --audio is used with a compatible model", func() {
+			flags["audio"] = true
+
+			err := utils.ValidateFlags(defaultModel+utils.AudioPattern, flags)
+			Expect(err).NotTo(HaveOccurred())
+		})
+		it("should return an error when --transcribe is used with an incompatible model", func() {
+			flags["transcribe"] = true
+
+			err := utils.ValidateFlags(defaultModel, flags)
+			Expect(err).To(HaveOccurred())
+		})
+		it("should NOT return an error when --transcribe is used with a compatible model", func() {
+			flags["transcribe"] = true
+
+			err := utils.ValidateFlags(defaultModel+utils.TranscribePattern, flags)
+			Expect(err).NotTo(HaveOccurred())
+		})
+		it("should return an error when --speak and --output flags are used with an incompatible model", func() {
+			flags["speak"] = true
+			flags["output"] = true
+
+			err := utils.ValidateFlags(defaultModel, flags)
+			Expect(err).To(HaveOccurred())
+		})
+		it("should NOT return an error when --speak and --output flags are used with a compatible model", func() {
+			flags["speak"] = true
+			flags["output"] = true
+
+			err := utils.ValidateFlags(defaultModel+utils.TTSPattern, flags)
+			Expect(err).NotTo(HaveOccurred())
+		})
+		it("should return an error when --voice is used with an incompatible model", func() {
+			flags["voice"] = true
+
+			err := utils.ValidateFlags(defaultModel, flags)
+			Expect(err).To(HaveOccurred())
+		})
+		it("should NOT return an error when --voice is used with a compatible model", func() {
+			flags["voice"] = true
+
+			err := utils.ValidateFlags(defaultModel+utils.TTSPattern, flags)
+			Expect(err).NotTo(HaveOccurred())
+		})
+		it("should return an error when --effort is used with an incompatible model", func() {
+			flags["effort"] = true
+
+			err := utils.ValidateFlags(defaultModel, flags)
+			Expect(err).To(HaveOccurred())
+		})
+		it("should NOT return an error when --effort is used with a compatible model", func() {
+			flags["effort"] = true
+
+			err := utils.ValidateFlags(defaultModel+utils.O1ProPattern, flags)
+			Expect(err).NotTo(HaveOccurred())
+		})
 	})
 }