Start implementing /api

From ollama, this now works:

MODEL_RUNNER_PORT=13434 make run

OLLAMA_HOST="127.0.0.1:13434" ollama run ai/smollm2
OLLAMA_HOST="127.0.0.1:13434" ollama ls
OLLAMA_HOST="127.0.0.1:13434" ollama ps
OLLAMA_HOST="127.0.0.1:13434" ollama stop ai/smollm2
OLLAMA_HOST="127.0.0.1:13434" ollama pull ai/smollm2:135M-Q4_0

Signed-off-by: Eric Curtin <eric.curtin@docker.com>

Author: ericcurtin

cmd/cli/commands/list.go

@@ -47,7 +47,7 @@ func newListCmd() *cobra.Command {
 			if err != nil {
 				return err
 			}
-			cmd.Print(models)
+			fmt.Fprint(cmd.OutOrStdout(), models)
 			return nil
 		},
 		ValidArgsFunction: completion.ModelNamesAndTags(getDesktopClient, 1),

main.go

@@ -20,6 +20,7 @@ import (
 	"github.com/docker/model-runner/pkg/inference/scheduling"
 	"github.com/docker/model-runner/pkg/metrics"
 	"github.com/docker/model-runner/pkg/middleware"
+	"github.com/docker/model-runner/pkg/ollama"
 	"github.com/docker/model-runner/pkg/routing"
 	"github.com/sirupsen/logrus"
 )
@@ -160,6 +161,21 @@ func main() {
 	router.Handle("/rerank", aliasHandler)
 	router.Handle("/score", aliasHandler)
 
+	// Add Ollama API compatibility layer (only register with trailing slash to catch sub-paths)
+	ollamaHandler := ollama.NewHandler(log, modelManager, scheduler, nil)
+	router.Handle(ollama.APIPrefix+"/", ollamaHandler)
+
+	// Register root handler LAST - it will only catch exact "/" requests that don't match other patterns
+	router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		// Only respond to exact root path
+		if r.URL.Path != "/" {
+			http.NotFound(w, r)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("Docker Model Runner is running"))
+	})
+
 	// Add metrics endpoint if enabled
 	if os.Getenv("DISABLE_METRICS") != "1" {
 		metricsHandler := metrics.NewAggregatedMetricsHandler(

pkg/distribution/distribution/client.go

@@ -343,7 +343,7 @@ func (c *Client) GetModel(reference string) (types.Model, error) {
 	model, err := c.store.Read(reference)
 	if err != nil {
 		c.log.Errorln("Failed to get model:", err, "reference:", utils.SanitizeForLog(reference))
-		return nil, fmt.Errorf("get model '%q': %w", reference, err)
+		return nil, fmt.Errorf("get model '%q': %w", utils.SanitizeForLog(reference), err)
 	}
 
 	return model, nil

pkg/inference/models/manager.go

@@ -264,27 +264,12 @@ func (m *Manager) handleLoadModel(w http.ResponseWriter, r *http.Request) {
 
 // handleGetModels handles GET <inference-prefix>/models requests.
 func (m *Manager) handleGetModels(w http.ResponseWriter, r *http.Request) {
-	if m.distributionClient == nil {
-		http.Error(w, "model distribution service unavailable", http.StatusServiceUnavailable)
-		return
-	}
-
-	// Query models.
-	models, err := m.distributionClient.ListModels()
+	apiModels, err := m.GetModels()
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	apiModels := make([]*Model, len(models))
-	for i, model := range models {
-		apiModels[i], err = ToModel(model)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-	}
-
 	// Write the response.
 	w.Header().Set("Content-Type", "application/json")
 	if err := json.NewEncoder(w).Encode(apiModels); err != nil {
@@ -884,6 +869,31 @@ func (m *Manager) IsModelInStore(ref string) (bool, error) {
 	return m.distributionClient.IsModelInStore(ref)
 }
 
+// GetModels returns all models.
+func (m *Manager) GetModels() ([]*Model, error) {
+	if m.distributionClient == nil {
+		return nil, fmt.Errorf("model distribution service unavailable")
+	}
+
+	// Query models.
+	models, err := m.distributionClient.ListModels()
+	if err != nil {
+		return nil, fmt.Errorf("error while listing models: %w", err)
+	}
+
+ 	apiModels := make([]*Model, 0, len(models))
+ 	for _, model := range models {
+ 		apiModel, err := ToModel(model)
+ 		if err != nil {
+ 			m.log.Warnf("error while converting model, skipping: %v", err)
+ 			continue
+ 		}
+ 		apiModels = append(apiModels, apiModel)
+ 	}
+
+	return apiModels, nil
+}
+
 // GetModel returns a single model.
 func (m *Manager) GetModel(ref string) (types.Model, error) {
 	model, err := m.distributionClient.GetModel(ref)

pkg/inference/scheduling/scheduler.go

@@ -321,6 +321,11 @@ func (s *Scheduler) GetRunningBackends(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+// GetRunningBackendsInfo returns information about all running backends as a slice
+func (s *Scheduler) GetRunningBackendsInfo(ctx context.Context) []BackendStatus {
+	return s.getLoaderStatus(ctx)
+}
+
 // getLoaderStatus returns information about all running backends managed by the loader
 func (s *Scheduler) getLoaderStatus(ctx context.Context) []BackendStatus {
 	if !s.loader.lock(ctx) {