use server side backend selection instead of duplicating logic in CLI

Remove the CLI side GetRequiredBackendFromModelInfo mapping and delegate
backend resolution to the server via a new GET /models/backend?model=<ref>
endpoint. The endpoint reuses Scheduler.selectBackendForModel so the
platform aware fallback chain (vLLM, MLX, SGLang, diffusers) stays in
one place. Also address earlier review feedback: sentinel error for
cancelled install, cmd.InOrStdin for prompt input, and unit tests for
the new helpers.

Author: iamanishx

cmd/cli/commands/run.go

@@ -828,22 +828,15 @@ func newRunCmd() *cobra.Command {
 				return nil
 			}
 
-			modelInfo, err := desktopClient.Inspect(model, false)
+			_, err := desktopClient.Inspect(model, false)
 			modelFoundLocally := err == nil
 			if err != nil && !errors.Is(err, desktop.ErrNotFound) {
 				return handleClientError(err, "Failed to inspect model")
 			}
 
-			if !modelFoundLocally {
-				remoteInfo, remoteErr := desktopClient.Inspect(model, true)
-				if remoteErr == nil {
-					modelInfo = remoteInfo
-				}
-			}
-
 			backend := ""
-			if modelInfo.ID != "" {
-				backend, _ = GetRequiredBackendFromModelInfo(&modelInfo)
+			if resolvedBackend, resolveErr := ResolveRequiredBackend(model); resolveErr == nil {
+				backend = resolvedBackend
 			}
 
 			if backend != "" {

cmd/cli/commands/utils.go

@@ -14,11 +14,7 @@ import (
 	"github.com/docker/model-runner/cmd/cli/pkg/standalone"
 	"github.com/docker/model-runner/pkg/distribution/distribution"
 	"github.com/docker/model-runner/pkg/distribution/oci/reference"
-	"github.com/docker/model-runner/pkg/distribution/types"
-	"github.com/docker/model-runner/pkg/inference/backends/diffusers"
-	"github.com/docker/model-runner/pkg/inference/backends/llamacpp"
 	"github.com/docker/model-runner/pkg/inference/backends/vllm"
-	dmrm "github.com/docker/model-runner/pkg/inference/models"
 	"github.com/moby/term"
 	"github.com/olekukonko/tablewriter"
 	"github.com/olekukonko/tablewriter/renderer"
@@ -367,22 +363,13 @@ func EnsureBackendAvailable(backend string, cmd *cobra.Command) error {
 	return nil
 }
 
-func GetRequiredBackendFromModelInfo(modelInfo *dmrm.Model) (string, error) {
-	config, ok := modelInfo.Config.(*types.Config)
-	if !ok {
-		return llamacpp.Name, nil
+func ResolveRequiredBackend(model string) (string, error) {
+	selection, err := desktopClient.ResolveModelBackend(model)
+	if err != nil {
+		return "", err
 	}
 
-	switch config.Format {
-	case types.FormatSafetensors:
-		return vllm.Name, nil
-	case types.FormatGGUF:
-		return llamacpp.Name, nil
-	case types.FormatDiffusers:
-		return diffusers.Name, nil
-	default:
-		return llamacpp.Name, nil
-	}
+	return selection.Backend, nil
 }
 
 func printNextSteps(out io.Writer, messages []string) {

cmd/cli/commands/utils_test.go

@@ -7,17 +7,15 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"strings"
 	"testing"
 
 	"github.com/docker/model-runner/cmd/cli/desktop"
 	mockdesktop "github.com/docker/model-runner/cmd/cli/mocks"
-	"github.com/docker/model-runner/pkg/distribution/types"
 	"github.com/docker/model-runner/pkg/inference"
-	"github.com/docker/model-runner/pkg/inference/backends/diffusers"
-	"github.com/docker/model-runner/pkg/inference/backends/llamacpp"
 	"github.com/docker/model-runner/pkg/inference/backends/vllm"
-	dmrm "github.com/docker/model-runner/pkg/inference/models"
+	"github.com/docker/model-runner/pkg/inference/scheduling"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
@@ -219,22 +217,28 @@ func TestEnsureBackendAvailableCancelled(t *testing.T) {
 	require.Contains(t, out.String(), "docker model install-runner --backend vllm")
 }
 
-func TestGetRequiredBackendFromModelInfo(t *testing.T) {
-	t.Run("safetensors chooses vllm", func(t *testing.T) {
-		backend, err := GetRequiredBackendFromModelInfo(&dmrm.Model{Config: &types.Config{Format: types.FormatSafetensors}})
-		require.NoError(t, err)
-		require.Equal(t, vllm.Name, backend)
-	})
+func TestResolveRequiredBackend(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
 
-	t.Run("gguf chooses llamacpp", func(t *testing.T) {
-		backend, err := GetRequiredBackendFromModelInfo(&dmrm.Model{Config: &types.Config{Format: types.FormatGGUF}})
-		require.NoError(t, err)
-		require.Equal(t, llamacpp.Name, backend)
-	})
+	client := mockdesktop.NewMockDockerHttpClient(ctrl)
+	modelRunner = desktop.NewContextForMock(client)
+	desktopClient = desktop.New(modelRunner)
 
-	t.Run("diffusers chooses diffusers backend", func(t *testing.T) {
-		backend, err := GetRequiredBackendFromModelInfo(&dmrm.Model{Config: &types.Config{Format: types.FormatDiffusers}})
-		require.NoError(t, err)
-		require.Equal(t, diffusers.Name, backend)
-	})
+	model := "ai/functiongemma-vllm:270M"
+	selection := scheduling.ModelBackendSelection{Backend: vllm.Name, Installed: false}
+	body, err := json.Marshal(selection)
+	require.NoError(t, err)
+
+	expectedResolveURL := modelRunner.URL(inference.ModelsPrefix + "/backend?model=" + url.QueryEscape(model))
+	expectedUserAgent := "docker-model-cli/" + desktop.Version
+
+	client.EXPECT().Do(gomock.Cond(func(req any) bool {
+		r, ok := req.(*http.Request)
+		return ok && r.URL.String() == expectedResolveURL && r.Header.Get("User-Agent") == expectedUserAgent
+	})).Return(&http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(bytes.NewReader(body))}, nil)
+
+	backend, err := ResolveRequiredBackend(model)
+	require.NoError(t, err)
+	require.Equal(t, vllm.Name, backend)
 }

cmd/cli/desktop/desktop.go

@@ -362,6 +362,36 @@ func (c *Client) Inspect(model string, remote bool) (dmrm.Model, error) {
 	return modelInspect, nil
 }
 
+func (c *Client) ResolveModelBackend(model string) (scheduling.ModelBackendSelection, error) {
+	resolvePath := fmt.Sprintf("%s/backend?model=%s", inference.ModelsPrefix, url.QueryEscape(model))
+
+	resp, err := c.doRequest(http.MethodGet, resolvePath, nil)
+	if err != nil {
+		return scheduling.ModelBackendSelection{}, c.handleQueryError(err, resolvePath)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		if resp.StatusCode == http.StatusNotFound {
+			return scheduling.ModelBackendSelection{}, errors.Wrap(ErrNotFound, model)
+		}
+		body, _ := io.ReadAll(resp.Body)
+		return scheduling.ModelBackendSelection{}, fmt.Errorf("failed to resolve model backend: %s: %s", resp.Status, string(body))
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return scheduling.ModelBackendSelection{}, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	var selection scheduling.ModelBackendSelection
+	if err := json.Unmarshal(body, &selection); err != nil {
+		return scheduling.ModelBackendSelection{}, fmt.Errorf("failed to unmarshal response body: %w", err)
+	}
+
+	return selection, nil
+}
+
 func (c *Client) InspectOpenAI(model string) (dmrm.OpenAIModel, error) {
 	modelsRoute := c.modelRunner.OpenAIPathPrefix() + "/models"
 	rawResponse, err := c.listRaw(fmt.Sprintf("%s/%s", modelsRoute, model), model)

pkg/inference/scheduling/api.go

@@ -119,3 +119,9 @@ type ModelConfigEntry struct {
 	Mode    inference.BackendMode
 	Config  inference.BackendConfiguration
 }
+
+// ModelBackendSelection describes the backend selected by the scheduler for a model.
+type ModelBackendSelection struct {
+	Backend   string `json:"backend"`
+	Installed bool   `json:"installed"`
+}

pkg/inference/scheduling/http_handler.go

@@ -119,6 +119,7 @@ func (h *HTTPHandler) routeHandlers() map[string]http.HandlerFunc {
 	m["GET "+inference.InferencePrefix+"/status"] = h.GetBackendStatus
 	m["GET "+inference.InferencePrefix+"/ps"] = h.GetRunningBackends
 	m["GET "+inference.InferencePrefix+"/df"] = h.GetDiskUsage
+	m["GET "+inference.ModelsPrefix+"/backend"] = h.GetModelBackend
 	m["POST "+inference.InferencePrefix+"/unload"] = h.Unload
 	m["POST "+inference.InferencePrefix+"/{backend}/_configure"] = h.Configure
 	m["POST "+inference.InferencePrefix+"/_configure"] = h.Configure
@@ -540,6 +541,30 @@ func (h *HTTPHandler) GetModelConfigs(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+// GetModelBackend resolves the backend selected by the scheduler for the provided model.
+func (h *HTTPHandler) GetModelBackend(w http.ResponseWriter, r *http.Request) {
+	modelRef := r.URL.Query().Get("model")
+	if modelRef == "" {
+		http.Error(w, "model is required", http.StatusBadRequest)
+		return
+	}
+
+	backend, err := h.scheduler.ResolveBackendForModel(r.Context(), modelRef)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("failed to resolve backend: %v", err), http.StatusNotFound)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(ModelBackendSelection{
+		Backend:   backend.Name(),
+		Installed: h.scheduler.installer.isInstalled(backend.Name()),
+	}); err != nil {
+		http.Error(w, fmt.Sprintf("Failed to encode response: %v", err), http.StatusInternalServerError)
+		return
+	}
+}
+
 // ServeHTTP implements net/http.Handler.ServeHTTP.
 func (h *HTTPHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	h.lock.RLock()

pkg/inference/scheduling/scheduler.go

@@ -142,6 +142,10 @@ func (s *Scheduler) selectBackendForModel(model types.Model, backend inference.B
 		format = inferFormatFromModel(model)
 	}
 
+	return s.selectBackendForFormat(format, backend, modelRef)
+}
+
+func (s *Scheduler) selectBackendForFormat(format types.Format, backend inference.Backend, modelRef string) inference.Backend {
 	switch format {
 	case types.FormatSafetensors:
 		// Prefer vLLM for safetensors models (handles platform dispatch internally)
@@ -211,6 +215,28 @@ func inferFormatFromModel(model types.Model) types.Format {
 	return ""
 }
 
+// ResolveBackendForModel resolves the backend that should be used for a model reference.
+// It prefers local model metadata and falls back to remote metadata when needed.
+func (s *Scheduler) ResolveBackendForModel(ctx context.Context, modelRef string) (inference.Backend, error) {
+	backend := s.defaultBackend
+
+	if model, err := s.modelManager.GetLocal(modelRef); err == nil {
+		return s.selectBackendForModel(model, backend, modelRef), nil
+	}
+
+	artifact, err := s.modelManager.GetRemote(ctx, modelRef)
+	if err != nil {
+		return nil, err
+	}
+
+	config, err := artifact.Config()
+	if err != nil {
+		return nil, err
+	}
+
+	return s.selectBackendForFormat(config.GetFormat(), backend, modelRef), nil
+}
+
 // ResetInstaller resets the backend installer with a new HTTP client.
 func (s *Scheduler) ResetInstaller(httpClient *http.Client) {
 	s.installer = newInstaller(s.log, s.backends, httpClient, s.deferredBackends)

pkg/routing/router.go

@@ -49,6 +49,7 @@ func NewRouter(cfg RouterConfig) *NormalizedServeMux {
 	if cfg.ModelHandlerMiddleware != nil {
 		modelEndpoint = cfg.ModelHandlerMiddleware(cfg.ModelHandler)
 	}
+	router.Handle(inference.ModelsPrefix+"/backend", cfg.SchedulerHTTP)
 	router.Handle(inference.ModelsPrefix, modelEndpoint)
 	router.Handle(inference.ModelsPrefix+"/", modelEndpoint)