Refactor list and run commands to support OpenAI

Change --openai flag from boolean to URL string in both commands.
Implement OpenAI endpoint connection for model listing and chat. Update
internal functions to accept interface parameters instead of concrete
types for better abstraction. Add validation to prevent incompatible
flag combinations. Move OpenAI-specific logic to separate functions for
clarity

Signed-off-by: Eric Curtin <[email protected]>

Author: ericcurtin

cmd/cli/commands/list.go

@@ -20,31 +20,45 @@ import (
 )
 
 func newListCmd() *cobra.Command {
-	var jsonFormat, openai, quiet bool
+	var jsonFormat, quiet bool
+	var openaiURL string
 	c := &cobra.Command{
 		Use:     "list [OPTIONS] [MODEL]",
 		Aliases: []string{"ls"},
 		Short:   "List the models pulled to your local environment",
 		Args:    cobra.MaximumNArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if openai && quiet {
-				return fmt.Errorf("--quiet flag cannot be used with --openai flag or OpenAI backend")
+			useOpenAI := openaiURL != ""
+			if useOpenAI && quiet {
+				return fmt.Errorf("--quiet flag cannot be used with --openai flag")
+			}
+
+			var modelFilter string
+			if len(args) > 0 {
+				modelFilter = args[0]
+			}
+
+			// If --openai URL is provided, connect to external OpenAI endpoint
+			if useOpenAI {
+				openaiClient := desktop.NewOpenAIClient(openaiURL)
+				models, err := listModelsFromOpenAI(openaiClient, modelFilter)
+				if err != nil {
+					return err
+				}
+				fmt.Fprint(cmd.OutOrStdout(), models)
+				return nil
 			}
 
 			// If we're doing an automatic install, only show the installation
 			// status if it won't corrupt machine-readable output.
 			var standaloneInstallPrinter standalone.StatusPrinter
-			if !jsonFormat && !openai && !quiet {
+			if !jsonFormat && !quiet {
 				standaloneInstallPrinter = asPrinter(cmd)
 			}
 			if _, err := ensureStandaloneRunnerAvailable(cmd.Context(), standaloneInstallPrinter, false); err != nil {
 				return fmt.Errorf("unable to initialize standalone model runner: %w", err)
 			}
-			var modelFilter string
-			if len(args) > 0 {
-				modelFilter = args[0]
-			}
-			models, err := listModels(openai, desktopClient, quiet, jsonFormat, modelFilter)
+			models, err := listModels(desktopClient, quiet, jsonFormat, modelFilter)
 			if err != nil {
 				return err
 			}
@@ -54,7 +68,7 @@ func newListCmd() *cobra.Command {
 		ValidArgsFunction: completion.ModelNamesAndTags(getDesktopClient, 1),
 	}
 	c.Flags().BoolVar(&jsonFormat, "json", false, "List models in a JSON format")
-	c.Flags().BoolVar(&openai, "openai", false, "List models in an OpenAI format")
+	c.Flags().StringVar(&openaiURL, "openai", "", "List models from an OpenAI-compatible endpoint URL")
 	c.Flags().BoolVarP(&quiet, "quiet", "q", false, "Only show model IDs")
 	return c
 }
@@ -74,25 +88,24 @@ func matchesModelFilter(tag, filter string) bool {
 	return repository == filter
 }
 
-func listModels(openai bool, desktopClient *desktop.Client, quiet bool, jsonFormat bool, modelFilter string) (string, error) {
-	if openai {
-		models, err := desktopClient.ListOpenAI()
-		if err != nil {
-			return "", handleClientError(err, "Failed to list models")
-		}
-		if modelFilter != "" {
-			filter := normalizeModelFilter(modelFilter)
-			filtered := models.Data[:0]
-			for _, m := range models.Data {
-				if matchesModelFilter(m.ID, filter) {
-					filtered = append(filtered, m)
-				}
+func listModelsFromOpenAI(openaiClient *desktop.OpenAIClient, modelFilter string) (string, error) {
+	models, err := openaiClient.ListModels()
+	if err != nil {
+		return "", fmt.Errorf("failed to list models: %w", err)
+	}
+	if modelFilter != "" {
+		filtered := models.Data[:0]
+		for _, m := range models.Data {
+			if strings.Contains(m.ID, modelFilter) {
+				filtered = append(filtered, m)
 			}
-			models.Data = filtered
 		}
-		return formatter.ToStandardJSON(models)
+		models.Data = filtered
 	}
+	return formatter.ToStandardJSON(models)
+}
 
+func listModels(desktopClient *desktop.Client, quiet bool, jsonFormat bool, modelFilter string) (string, error) {
 	models, err := desktopClient.List()
 	if err != nil {
 		return "", handleClientError(err, "Failed to list models")

cmd/cli/commands/run.go

@@ -87,7 +87,7 @@ func readMultilineInput(cmd *cobra.Command, scanner *bufio.Scanner) (string, err
 }
 
 // generateInteractiveWithReadline provides an enhanced interactive mode with readline support
-func generateInteractiveWithReadline(cmd *cobra.Command, desktopClient *desktop.Client, model string) error {
+func generateInteractiveWithReadline(cmd *cobra.Command, client desktop.ChatClient, model string) error {
 	usage := func() {
 		fmt.Fprintln(os.Stderr, "Available Commands:")
 		fmt.Fprintln(os.Stderr, "  /bye            Exit")
@@ -141,7 +141,7 @@ func generateInteractiveWithReadline(cmd *cobra.Command, desktopClient *desktop.
 	})
 	if err != nil {
 		// Fall back to basic input mode if readline initialization fails
-		return generateInteractiveBasic(cmd, desktopClient, model)
+		return generateInteractiveBasic(cmd, client, model)
 	}
 
 	// Disable history if the environment variable is set
@@ -245,7 +245,7 @@ func generateInteractiveWithReadline(cmd *cobra.Command, desktopClient *desktop.
 				}
 			}()
 
-			err := chatWithMarkdownContext(chatCtx, cmd, desktopClient, model, userInput)
+			err := chatWithMarkdownContext(chatCtx, cmd, client, model, userInput)
 
 			// Clean up signal handler
 			signal.Stop(sigChan)
@@ -270,7 +270,7 @@ func generateInteractiveWithReadline(cmd *cobra.Command, desktopClient *desktop.
 }
 
 // generateInteractiveBasic provides a basic interactive mode (fallback)
-func generateInteractiveBasic(cmd *cobra.Command, desktopClient *desktop.Client, model string) error {
+func generateInteractiveBasic(cmd *cobra.Command, client desktop.ChatClient, model string) error {
 	scanner := bufio.NewScanner(os.Stdin)
 	for {
 		userInput, err := readMultilineInput(cmd, scanner)
@@ -306,7 +306,7 @@ func generateInteractiveBasic(cmd *cobra.Command, desktopClient *desktop.Client,
 			}
 		}()
 
-		err = chatWithMarkdownContext(chatCtx, cmd, desktopClient, model, userInput)
+		err = chatWithMarkdownContext(chatCtx, cmd, client, model, userInput)
 
 		cancelChat()
 		signal.Stop(sigChan)
@@ -508,12 +508,12 @@ func renderMarkdown(content string) (string, error) {
 }
 
 // chatWithMarkdown performs chat and streams the response with selective markdown rendering.
-func chatWithMarkdown(cmd *cobra.Command, client *desktop.Client, model, prompt string) error {
+func chatWithMarkdown(cmd *cobra.Command, client desktop.ChatClient, model, prompt string) error {
 	return chatWithMarkdownContext(cmd.Context(), cmd, client, model, prompt)
 }
 
 // chatWithMarkdownContext performs chat with context support and streams the response with selective markdown rendering.
-func chatWithMarkdownContext(ctx context.Context, cmd *cobra.Command, client *desktop.Client, model, prompt string) error {
+func chatWithMarkdownContext(ctx context.Context, cmd *cobra.Command, client desktop.ChatClient, model, prompt string) error {
 	colorMode, _ := cmd.Flags().GetString("color")
 	useMarkdown := shouldUseMarkdown(colorMode)
 	debug, _ := cmd.Flags().GetBool("debug")
@@ -571,6 +571,7 @@ func newRunCmd() *cobra.Command {
 	var debug bool
 	var colorMode string
 	var detach bool
+	var openaiURL string
 
 	const cmdArgs = "MODEL [PROMPT]"
 	c := &cobra.Command{
@@ -617,6 +618,31 @@ func newRunCmd() *cobra.Command {
 				}
 			}
 
+			// Handle --openai flag: connect to external OpenAI-compatible endpoint
+			if openaiURL != "" {
+				if detach {
+					return fmt.Errorf("--detach flag cannot be used with --openai flag")
+				}
+				openaiClient := desktop.NewOpenAIClient(openaiURL)
+
+				if prompt != "" {
+					if err := chatWithMarkdown(cmd, openaiClient, model, prompt); err != nil {
+						return fmt.Errorf("failed to generate a response: %w", err)
+					}
+					cmd.Println()
+					return nil
+				}
+
+				// Interactive mode
+				if term.IsTerminal(int(os.Stdin.Fd())) {
+					termenv.SetDefaultOutput(
+						termenv.NewOutput(asPrinter(cmd), termenv.WithColorCache(true)),
+					)
+					return generateInteractiveWithReadline(cmd, openaiClient, model)
+				}
+				return generateInteractiveBasic(cmd, openaiClient, model)
+			}
+
 			// Check if this is an NVIDIA NIM image
 			if isNIMImage(model) {
 				// NIM images are handled differently - they run as Docker containers
@@ -733,6 +759,7 @@ func newRunCmd() *cobra.Command {
 	c.Flags().BoolVar(&debug, "debug", false, "Enable debug logging")
 	c.Flags().StringVar(&colorMode, "color", "no", "Use colored output (auto|yes|no)")
 	c.Flags().BoolVarP(&detach, "detach", "d", false, "Load the model in the background without interaction")
+	c.Flags().StringVar(&openaiURL, "openai", "", "Connect to an OpenAI-compatible endpoint URL")
 
 	return c
 }