fix: check local store before pulling HuggingFace models (#617)

* fix: check local store before pulling HuggingFace models

Fixes #616

Previously, HuggingFace models were always downloaded from the Hub even
if the same model already existed in the local store. This caused
unnecessary bandwidth usage and slower pull times.

This change adds a cache check before calling pullNativeHuggingFace(),
similar to how OCI models are handled. If the model is found in the
local store, it returns immediately without downloading.

Also includes hf.co to huggingface.co URL normalization to ensure
consistent cache lookups regardless of which URL format is used.

* refactor: apply Gemini code review suggestions

- Fix error handling: only treat ErrModelNotFound as cache miss, propagate other errors
- Consolidate test functions into table-driven test for better maintainability

Author: littleKitchen

pkg/distribution/distribution/client.go

@@ -249,6 +249,24 @@ func (c *Client) PullModel(ctx context.Context, reference string, progressWriter
 	// HuggingFace references always use native pull (download raw files from HF Hub)
 	if isHuggingFaceReference(originalReference) {
 		c.log.Infoln("Using native HuggingFace pull for:", utils.SanitizeForLog(reference))
+
+		// Check if model already exists in local store (reference is already normalized)
+		localModel, err := c.store.Read(reference)
+		if err == nil {
+			c.log.Infoln("HuggingFace model found in local store:", utils.SanitizeForLog(reference))
+			cfg, err := localModel.Config()
+			if err != nil {
+				return fmt.Errorf("getting cached model config: %w", err)
+			}
+			if err := progress.WriteSuccess(progressWriter, fmt.Sprintf("Using cached model: %s", cfg.GetSize()), oci.ModePull); err != nil {
+				c.log.Warnf("Writing progress: %v", err)
+			}
+			return nil
+		}
+		if !errors.Is(err, ErrModelNotFound) {
+			return fmt.Errorf("checking for cached HuggingFace model: %w", err)
+		}
+
 		// Pass original reference to preserve case-sensitivity for HuggingFace API
 		return c.pullNativeHuggingFace(ctx, originalReference, progressWriter, token)
 	}

pkg/distribution/distribution/client_test.go

@@ -1140,3 +1140,56 @@ func randomFile(size int64) (string, error) {
 
 	return f.Name(), nil
 }
+
+func TestPullHuggingFaceModelFromCache(t *testing.T) {
+	testCases := []struct {
+		name    string
+		pullRef string
+	}{
+		{
+			name:    "full URL",
+			pullRef: "huggingface.co/testorg/testmodel:latest",
+		},
+		{
+			name:    "short URL",
+			pullRef: "hf.co/testorg/testmodel:latest",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			tempDir := t.TempDir()
+
+			// Create client
+			client, err := newTestClient(tempDir)
+			if err != nil {
+				t.Fatalf("Failed to create client: %v", err)
+			}
+
+			// Create a test model and write it to the store with a normalized HuggingFace tag
+			model, err := gguf.NewModel(testGGUFFile)
+			if err != nil {
+				t.Fatalf("Failed to create model: %v", err)
+			}
+
+			// Store with normalized tag (huggingface.co)
+			hfTag := "huggingface.co/testorg/testmodel:latest"
+			if err := client.store.Write(model, []string{hfTag}, nil); err != nil {
+				t.Fatalf("Failed to write model to store: %v", err)
+			}
+
+			// Now try to pull using the test case's reference - it should use the cache
+			var progressBuffer bytes.Buffer
+			err = client.PullModel(t.Context(), tc.pullRef, &progressBuffer)
+			if err != nil {
+				t.Fatalf("Failed to pull model from cache: %v", err)
+			}
+
+			// Verify that progress shows it was cached
+			progressOutput := progressBuffer.String()
+			if !strings.Contains(progressOutput, "Using cached model") {
+				t.Errorf("Expected progress to indicate cached model, got: %s", progressOutput)
+			}
+		})
+	}
+}