refactor(backends): standardize status reporting across all backends

Signed-off-by: Dorin Geman <dorin.geman@docker.com>

Author: doringeman

cmd/cli/commands/status.go

@@ -1,17 +1,20 @@
 package commands
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"net"
 	"os"
+	"sort"
 	"strconv"
 
 	"github.com/docker/cli/cli-plugins/hooks"
 	"github.com/docker/model-runner/cmd/cli/commands/completion"
 	"github.com/docker/model-runner/cmd/cli/desktop"
 	"github.com/docker/model-runner/cmd/cli/pkg/standalone"
 	"github.com/docker/model-runner/cmd/cli/pkg/types"
+	"github.com/docker/model-runner/pkg/inference"
 	"github.com/spf13/cobra"
 )
 
@@ -56,19 +59,67 @@ func newStatusCmd() *cobra.Command {
 func textStatus(cmd *cobra.Command, status desktop.Status, backendStatus map[string]string) {
 	if status.Running {
 		cmd.Println("Docker Model Runner is running")
-		cmd.Println("\nStatus:")
-		for b, s := range backendStatus {
-			if s != "not running" {
-				cmd.Println(b+":", s)
-			}
-		}
+		cmd.Println()
+		cmd.Print(backendStatusTable(backendStatus))
 	} else {
 		cmd.Println("Docker Model Runner is not running")
 		hooks.PrintNextSteps(cmd.OutOrStdout(), []string{enableViaCLI, enableViaGUI})
 		osExit(1)
 	}
 }
 
+func backendStatusTable(backendStatus map[string]string) string {
+	var buf bytes.Buffer
+	table := newTable(&buf)
+	table.Header([]string{"BACKEND", "STATUS", "DETAILS"})
+
+	type backendInfo struct {
+		name       string
+		statusType string
+		details    string
+		sortOrder  int
+	}
+
+	backends := make([]backendInfo, 0, len(backendStatus))
+	for name, statusText := range backendStatus {
+		statusType, details := inference.ParseStatus(statusText)
+
+		// Assign sort order: Running < Error < Not Installed < Installing
+		sortOrder := 4
+		switch statusType {
+		case inference.StatusRunning:
+			sortOrder = 0
+		case inference.StatusError:
+			sortOrder = 1
+		case inference.StatusNotInstalled:
+			sortOrder = 2
+		case inference.StatusInstalling:
+			sortOrder = 3
+		}
+
+		backends = append(backends, backendInfo{
+			name:       name,
+			statusType: statusType,
+			details:    details,
+			sortOrder:  sortOrder,
+		})
+	}
+
+	sort.Slice(backends, func(i, j int) bool {
+		if backends[i].sortOrder != backends[j].sortOrder {
+			return backends[i].sortOrder < backends[j].sortOrder
+		}
+		return backends[i].name < backends[j].name
+	})
+
+	for _, backend := range backends {
+		table.Append([]string{backend.name, backend.statusType, backend.details})
+	}
+
+	table.Render()
+	return buf.String()
+}
+
 func makeEndpoint(host string, port int) string {
 	return "http://" + net.JoinHostPort(host, strconv.Itoa(port)) + "/v1/"
 }

pkg/inference/backend.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"strings"
 	"time"
 )
 
@@ -24,6 +25,93 @@ const (
 	BackendModeImageGeneration
 )
 
+// Backend status constants for standardized status reporting.
+// Backends should use these prefixes when reporting their status.
+const (
+	// StatusRunning indicates the backend is operational and ready.
+	// Format: "Running: <details>" (e.g., "Running: vllm v0.1.0")
+	StatusRunning = "Running"
+
+	// StatusError indicates the backend encountered an error.
+	// Format: "Error: <details>" (e.g., "Error: installation failed")
+	StatusError = "Error"
+
+	// StatusNotInstalled indicates the backend is not installed.
+	// Format: "Not Installed: <details>" or just "Not Installed"
+	StatusNotInstalled = "Not Installed"
+
+	// StatusInstalling indicates the backend is currently being installed.
+	// Format: "Installing: <details>" or just "Installing"
+	StatusInstalling = "Installing"
+)
+
+// Common status detail messages for consistent reporting across backends.
+const (
+	DetailBinaryNotFound      = "binary not found"
+	DetailPackageNotInstalled = "package not installed"
+	DetailImportFailed        = "import failed"
+	DetailVersionUnknown      = "version unknown"
+	DetailPythonNotFound      = "Python not found"
+	DetailOnlyLinux           = "only supported on Linux"
+	DetailOnlyAppleSilicon    = "only supported on Apple Silicon"
+	DetailDownloading         = "downloading"
+	DetailCheckingForUpdates  = "checking for updates"
+)
+
+// FormatStatus formats a backend status with optional details.
+// If details is empty, returns just the status type.
+// Otherwise, returns "Status: details".
+func FormatStatus(statusType, details string) string {
+	if details == "" {
+		return statusType
+	}
+	return statusType + ": " + details
+}
+
+// ParseStatus splits a formatted status string into type and details.
+// Returns the status type and details separately.
+func ParseStatus(status string) (statusType, details string) {
+	if status == "" {
+		return StatusNotInstalled, ""
+	}
+
+	for _, prefix := range []string{StatusRunning, StatusError, StatusNotInstalled, StatusInstalling} {
+		if status == prefix {
+			return prefix, ""
+		}
+		if details, found := strings.CutPrefix(status, prefix+": "); found {
+			return prefix, details
+		}
+	}
+
+	return StatusError, status
+}
+
+// FormatRunning formats a running status with version/details.
+// Example: FormatRunning("vllm 0.1.0") -> "Running: vllm 0.1.0"
+func FormatRunning(details string) string {
+	return FormatStatus(StatusRunning, details)
+}
+
+// FormatError formats an error status with error message.
+// Example: FormatError("installation failed") -> "Error: installation failed"
+func FormatError(details string) string {
+	return FormatStatus(StatusError, details)
+}
+
+// FormatNotInstalled formats a not installed status with optional details.
+// Example: FormatNotInstalled("package not found") -> "Not Installed: package not found"
+// Example: FormatNotInstalled("") -> "Not Installed"
+func FormatNotInstalled(details string) string {
+	return FormatStatus(StatusNotInstalled, details)
+}
+
+// FormatInstalling formats an installing status with optional details.
+// Example: FormatInstalling("downloading") -> "Installing: downloading"
+func FormatInstalling(details string) string {
+	return FormatStatus(StatusInstalling, details)
+}
+
 type ErrGGUFParse struct {
 	Err error
 }

pkg/inference/backends/diffusers/diffusers.go

@@ -63,7 +63,7 @@ func New(log logging.Logger, modelManager *models.Manager, serverLog logging.Log
 		modelManager:     modelManager,
 		serverLog:        serverLog,
 		config:           conf,
-		status:           "not installed",
+		status:           inference.FormatNotInstalled(""),
 		customPythonPath: customPythonPath,
 	}, nil
 }
@@ -88,6 +88,7 @@ func (d *diffusers) UsesTCP() bool {
 // Install implements inference.Backend.Install.
 func (d *diffusers) Install(_ context.Context, _ *http.Client) error {
 	if !platform.SupportsDiffusers() {
+		d.status = inference.FormatNotInstalled(inference.DetailOnlyLinux)
 		return ErrNotImplemented
 	}
 
@@ -104,7 +105,7 @@ func (d *diffusers) Install(_ context.Context, _ *http.Client) error {
 			// Fall back to system Python
 			systemPython, err := exec.LookPath("python3")
 			if err != nil {
-				d.status = ErrPythonNotFound.Error()
+				d.status = inference.FormatError(inference.DetailPythonNotFound)
 				return ErrPythonNotFound
 			}
 			pythonPath = systemPython
@@ -115,7 +116,7 @@ func (d *diffusers) Install(_ context.Context, _ *http.Client) error {
 
 	// Check if diffusers is installed
 	if err := d.pythonCmd("-c", "import diffusers").Run(); err != nil {
-		d.status = "diffusers package not installed"
+		d.status = inference.FormatNotInstalled(inference.DetailPackageNotInstalled)
 		d.log.Warnf("diffusers package not found. Install with: uv pip install diffusers torch")
 		return ErrDiffusersNotFound
 	}
@@ -124,9 +125,9 @@ func (d *diffusers) Install(_ context.Context, _ *http.Client) error {
 	output, err := d.pythonCmd("-c", "import diffusers; print(diffusers.__version__)").Output()
 	if err != nil {
 		d.log.Warnf("could not get diffusers version: %v", err)
-		d.status = "running diffusers version: unknown"
+		d.status = inference.FormatRunning(inference.DetailVersionUnknown)
 	} else {
-		d.status = fmt.Sprintf("running diffusers version: %s", strings.TrimSpace(string(output)))
+		d.status = inference.FormatRunning(fmt.Sprintf("diffusers %s", strings.TrimSpace(string(output))))
 	}
 
 	return nil

pkg/inference/backends/llamacpp/download.go

@@ -15,6 +15,7 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/docker/model-runner/pkg/inference"
 	"github.com/docker/model-runner/pkg/internal/dockerhub"
 	"github.com/docker/model-runner/pkg/logging"
 )
@@ -100,8 +101,7 @@ func (l *llamaCpp) downloadLatestLlamaCpp(ctx context.Context, log logging.Logge
 	if err != nil {
 		return fmt.Errorf("failed to read bundled llama.cpp version: %w", err)
 	} else if strings.TrimSpace(string(data)) == latest {
-		l.status = fmt.Sprintf("running llama.cpp %s (%s) version: %s",
-			desiredTag, latest, getLlamaCppVersion(log, filepath.Join(vendoredServerStoragePath, "com.docker.llama-server")))
+		l.setRunningStatus(log, filepath.Join(vendoredServerStoragePath, "com.docker.llama-server"), desiredTag, latest)
 		return errLlamaCppUpToDate
 	}
 
@@ -112,8 +112,7 @@ func (l *llamaCpp) downloadLatestLlamaCpp(ctx context.Context, log logging.Logge
 	} else if strings.TrimSpace(string(data)) == latest {
 		log.Infoln("current llama.cpp version is already up to date")
 		if _, statErr := os.Stat(llamaCppPath); statErr == nil {
-			l.status = fmt.Sprintf("running llama.cpp %s (%s) version: %s",
-				desiredTag, latest, getLlamaCppVersion(log, llamaCppPath))
+			l.setRunningStatus(log, llamaCppPath, desiredTag, latest)
 			return nil
 		}
 		log.Infoln("llama.cpp binary must be updated, proceeding to update it")
@@ -128,7 +127,7 @@ func (l *llamaCpp) downloadLatestLlamaCpp(ctx context.Context, log logging.Logge
 	}
 	defer os.RemoveAll(downloadDir)
 
-	l.status = fmt.Sprintf("downloading %s (%s) variant of llama.cpp", desiredTag, latest)
+	l.status = inference.FormatInstalling(fmt.Sprintf("%s llama.cpp %s", inference.DetailDownloading, desiredTag))
 	if extractErr := extractFromImage(ctx, log, image, runtime.GOOS, runtime.GOARCH, downloadDir); extractErr != nil {
 		return fmt.Errorf("could not extract image: %w", extractErr)
 	}
@@ -164,7 +163,7 @@ func (l *llamaCpp) downloadLatestLlamaCpp(ctx context.Context, log logging.Logge
 	}
 
 	log.Infoln("successfully updated llama.cpp binary")
-	l.status = fmt.Sprintf("running llama.cpp %s (%s) version: %s", desiredTag, latest, getLlamaCppVersion(log, llamaCppPath))
+	l.setRunningStatus(log, llamaCppPath, desiredTag, latest)
 	log.Infoln(l.status)
 
 	if err := os.WriteFile(currentVersionFile, []byte(latest), 0o644); err != nil {
@@ -188,6 +187,15 @@ func extractFromImage(ctx context.Context, log logging.Logger, image, requiredOs
 	return dockerhub.Extract(imageTar, requiredArch, requiredOs, destination)
 }
 
+func (l *llamaCpp) setRunningStatus(log logging.Logger, binaryPath, variant, digest string) {
+	version := getLlamaCppVersion(log, binaryPath)
+	if variant == "" && digest == "" {
+		l.status = inference.FormatRunning(fmt.Sprintf("llama.cpp %s", version))
+	} else {
+		l.status = inference.FormatRunning(fmt.Sprintf("llama.cpp %s (%s) %s", variant, digest, version))
+	}
+}
+
 func getLlamaCppVersion(log logging.Logger, llamaCpp string) string {
 	output, err := exec.Command(llamaCpp, "--version").CombinedOutput()
 	if err != nil {

pkg/inference/backends/llamacpp/download_linux.go

@@ -2,7 +2,6 @@ package llamacpp
 
 import (
 	"context"
-	"fmt"
 	"net/http"
 	"path/filepath"
 
@@ -12,7 +11,6 @@ import (
 func (l *llamaCpp) ensureLatestLlamaCpp(_ context.Context, log logging.Logger, _ *http.Client,
 	_, vendoredServerStoragePath string,
 ) error {
-	l.status = fmt.Sprintf("running llama.cpp version: %s",
-		getLlamaCppVersion(log, filepath.Join(vendoredServerStoragePath, "com.docker.llama-server")))
+	l.setRunningStatus(log, filepath.Join(vendoredServerStoragePath, "com.docker.llama-server"), "", "")
 	return errLlamaCppUpdateDisabled
 }

pkg/inference/backends/llamacpp/download_windows.go

@@ -7,6 +7,7 @@ import (
 	"path/filepath"
 	"runtime"
 
+	"github.com/docker/model-runner/pkg/inference"
 	"github.com/docker/model-runner/pkg/logging"
 )
 
@@ -23,13 +24,13 @@ func (l *llamaCpp) ensureLatestLlamaCpp(ctx context.Context, log logging.Logger,
 		case "amd64":
 			canUseCUDA11, err = hasCUDA11CapableGPU(ctx, nvGPUInfoBin)
 			if err != nil {
-				l.status = fmt.Sprintf("failed to check CUDA 11 capability: %v", err)
+				l.status = inference.FormatError(fmt.Sprintf("failed to check CUDA 11 capability: %v", err))
 				return fmt.Errorf("failed to check CUDA 11 capability: %w", err)
 			}
 		case "arm64":
 			canUseOpenCL, err = hasOpenCL()
 			if err != nil {
-				l.status = fmt.Sprintf("failed to check OpenCL capability: %v", err)
+				l.status = inference.FormatError(fmt.Sprintf("failed to check OpenCL capability: %v", err))
 				return fmt.Errorf("failed to check OpenCL capability: %w", err)
 			}
 		}
@@ -41,7 +42,7 @@ func (l *llamaCpp) ensureLatestLlamaCpp(ctx context.Context, log logging.Logger,
 	} else if canUseOpenCL {
 		desiredVariant = "opencl"
 	}
-	l.status = fmt.Sprintf("looking for updates for %s variant", desiredVariant)
+	l.status = inference.FormatInstalling(fmt.Sprintf("%s llama.cpp %s", inference.DetailCheckingForUpdates, desiredVariant))
 	return l.downloadLatestLlamaCpp(ctx, log, httpClient, llamaCppPath, vendoredServerStoragePath, desiredVersion,
 		desiredVariant)
 }

pkg/inference/backends/llamacpp/llamacpp.go

@@ -109,8 +109,6 @@ func (l *llamaCpp) Install(ctx context.Context, httpClient *http.Client) error {
 		llamaServerBin = "com.docker.llama-server.exe"
 	}
 
-	l.status = "installing"
-
 	// Temporary workaround for dynamically downloading llama.cpp from Docker Hub.
 	// Internet access and an available docker/docker-model-backend-llamacpp:latest on Docker Hub are required.
 	// Even if docker/docker-model-backend-llamacpp:latest has been downloaded before, we still require its
@@ -119,7 +117,7 @@ func (l *llamaCpp) Install(ctx context.Context, httpClient *http.Client) error {
 	if err := l.ensureLatestLlamaCpp(ctx, l.log, httpClient, llamaCppPath, l.vendoredServerStoragePath); err != nil {
 		l.log.Infof("failed to ensure latest llama.cpp: %v\n", err)
 		if !errors.Is(err, errLlamaCppUpToDate) && !errors.Is(err, errLlamaCppUpdateDisabled) {
-			l.status = fmt.Sprintf("failed to install llama.cpp: %v", err)
+			l.status = inference.FormatError(fmt.Sprintf("failed to install llama.cpp: %v", err))
 		}
 		if errors.Is(err, context.Canceled) {
 			return err