Fix model name normalization

Signed-off-by: Christopher Petito <chrisjpetito@gmail.com>

Author: krissetto

cmd/cli/commands/run.go

@@ -15,6 +15,7 @@ import (
 	"github.com/docker/model-runner/cmd/cli/commands/completion"
 	"github.com/docker/model-runner/cmd/cli/desktop"
 	"github.com/docker/model-runner/cmd/cli/readline"
+	dmrm "github.com/docker/model-runner/pkg/inference/models"
 	"github.com/muesli/termenv"
 
 	"github.com/fatih/color"
@@ -676,6 +677,8 @@ func newRunCmd() *cobra.Command {
 				return nil
 			}
 
+			model = dmrm.NormalizeModelName(model)
+
 			if _, err := ensureStandaloneRunnerAvailable(cmd.Context(), asPrinter(cmd), debug); err != nil {
 				return fmt.Errorf("unable to initialize standalone model runner: %w", err)
 			}

cmd/cli/commands/run_test.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 	"testing"
 
+	dmrm "github.com/docker/model-runner/pkg/inference/models"
 	"github.com/spf13/cobra"
 )
 
@@ -156,3 +157,147 @@ func TestRunCmdDetachFlag(t *testing.T) {
 		t.Errorf("Expected detach flag value to be true, got false")
 	}
 }
+
+// TestRunModelNameNormalization verifies that model names are normalized correctly
+// in the run command to ensure consistency with how models are stored after pulling
+func TestRunModelNameNormalization(t *testing.T) {
+	tests := []struct {
+		name                   string
+		userProvidedModelName  string
+		expectedNormalizedName string
+		description            string
+	}{
+		{
+			name:                   "simple model name without namespace",
+			userProvidedModelName:  "llama3",
+			expectedNormalizedName: "ai/llama3:latest",
+			description:            "When user runs 'docker model run llama3', it should be normalized to 'ai/llama3:latest'",
+		},
+		{
+			name:                   "model name with tag but no namespace",
+			userProvidedModelName:  "llama3:8b",
+			expectedNormalizedName: "ai/llama3:8b",
+			description:            "When user runs 'docker model run llama3:8b', it should be normalized to 'ai/llama3:8b'",
+		},
+		{
+			name:                   "model name with explicit namespace",
+			userProvidedModelName:  "myorg/llama3",
+			expectedNormalizedName: "myorg/llama3:latest",
+			description:            "When user runs 'docker model run myorg/llama3', it should preserve the namespace",
+		},
+		{
+			name:                   "model name with ai namespace already set",
+			userProvidedModelName:  "ai/llama3",
+			expectedNormalizedName: "ai/llama3:latest",
+			description:            "When user runs 'docker model run ai/llama3', it should remain as 'ai/llama3:latest'",
+		},
+		{
+			name:                   "fully qualified model name",
+			userProvidedModelName:  "ai/llama3:latest",
+			expectedNormalizedName: "ai/llama3:latest",
+			description:            "When user runs 'docker model run ai/llama3:latest', it should remain unchanged",
+		},
+		{
+			name:                   "model name with custom org and tag",
+			userProvidedModelName:  "myorg/llama3:v2",
+			expectedNormalizedName: "myorg/llama3:v2",
+			description:            "When user runs 'docker model run myorg/llama3:v2', it should remain unchanged",
+		},
+		{
+			name:                   "huggingface model",
+			userProvidedModelName:  "hf.co/meta-llama/Llama-3-8B",
+			expectedNormalizedName: "hf.co/meta-llama/llama-3-8b:latest",
+			description:            "HuggingFace models should be lowercased and tagged with :latest",
+		},
+		{
+			name:                   "registry prefixed model",
+			userProvidedModelName:  "registry.example.com/mymodel",
+			expectedNormalizedName: "registry.example.com/mymodel:latest",
+			description:            "Registry-prefixed models should only get :latest tag added",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Test that the normalization function produces the expected output
+			normalizedName := dmrm.NormalizeModelName(tt.userProvidedModelName)
+
+			if normalizedName != tt.expectedNormalizedName {
+				t.Errorf("NormalizeModelName(%q) = %q, want %q\nDescription: %s",
+					tt.userProvidedModelName,
+					normalizedName,
+					tt.expectedNormalizedName,
+					tt.description)
+			}
+		})
+	}
+}
+
+// TestRunModelNameNormalizationConsistency verifies that the run command
+// uses the same normalization as the pull command, ensuring that:
+// 1. A model pulled as "docker model pull mymodel" creates "ai/mymodel:latest"
+// 2. The same model can be run as "docker model run mymodel" (without ai/ prefix)
+func TestRunModelNameNormalizationConsistency(t *testing.T) {
+	testCases := []struct {
+		name                      string
+		userInputForPull          string
+		userInputForRun           string
+		expectedInternalReference string
+		description               string
+	}{
+		{
+			name:                      "pull and run without namespace",
+			userInputForPull:          "gemma3",
+			userInputForRun:           "gemma3",
+			expectedInternalReference: "ai/gemma3:latest",
+			description:               "User pulls 'gemma3' and runs 'gemma3' - both should resolve to 'ai/gemma3:latest'",
+		},
+		{
+			name:                      "pull with namespace and run without namespace",
+			userInputForPull:          "ai/gemma3",
+			userInputForRun:           "gemma3",
+			expectedInternalReference: "ai/gemma3:latest",
+			description:               "User pulls 'ai/gemma3' and runs 'gemma3' - both should resolve to 'ai/gemma3:latest'",
+		},
+		{
+			name:                      "pull without namespace and run with namespace",
+			userInputForPull:          "gemma3",
+			userInputForRun:           "ai/gemma3",
+			expectedInternalReference: "ai/gemma3:latest",
+			description:               "User pulls 'gemma3' and runs 'ai/gemma3' - both should resolve to 'ai/gemma3:latest'",
+		},
+		{
+			name:                      "pull and run with tag",
+			userInputForPull:          "gemma3:2b",
+			userInputForRun:           "gemma3:2b",
+			expectedInternalReference: "ai/gemma3:2b",
+			description:               "User pulls 'gemma3:2b' and runs 'gemma3:2b' - both should resolve to 'ai/gemma3:2b'",
+		},
+		{
+			name:                      "custom org is preserved",
+			userInputForPull:          "myorg/gemma3",
+			userInputForRun:           "myorg/gemma3",
+			expectedInternalReference: "myorg/gemma3:latest",
+			description:               "User pulls 'myorg/gemma3' and runs 'myorg/gemma3' - both should resolve to 'myorg/gemma3:latest'",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Simulate what happens during pull (model name is normalized before storage)
+			normalizedPullName := dmrm.NormalizeModelName(tc.userInputForPull)
+
+			// Simulate what should happen during run (model name is normalized before lookup)
+			normalizedRunName := dmrm.NormalizeModelName(tc.userInputForRun)
+
+			// Both should normalize to the same internal reference
+			if normalizedPullName != tc.expectedInternalReference || normalizedRunName != tc.expectedInternalReference {
+				t.Errorf("Normalization failed for test case %q:\n  Pull input: %q -> Got %q, Want %q\n  Run input:  %q -> Got %q, Want %q\n  Description: %s",
+					tc.name,
+					tc.userInputForPull, normalizedPullName, tc.expectedInternalReference,
+					tc.userInputForRun, normalizedRunName, tc.expectedInternalReference,
+					tc.description)
+			}
+		})
+	}
+}