fix(gallery): add fallback capability resolution for backend selection

Add fallback logic to FindBestBackendFromMeta function to handle cases
where the exact capability match is not available in the gallery.

The fix implements a three-tier fallback strategy:
1. First try exact capability match (e.g., nvidia-cuda-13)
2. If not found, try parent capability by stripping version suffix
   (e.g., nvidia-cuda-13 -> nvidia)
3. Finally try 'default' capability

This fixes issue mudler#8509 where installing faster-whisper backend fails
when a CUDA variant (e.g., cuda13-faster-whisper) is already installed
because the meta-backend resolution lacks fallback capability.

Also adds tests for the fallback logic.

Signed-off-by: team-coding-agent-1 <team-coding-agent-1@localai>

Author: localai-bot

core/gallery/backend_types.go

@@ -2,6 +2,7 @@ package gallery
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/mudler/LocalAI/core/config"
 	"github.com/mudler/LocalAI/pkg/system"
@@ -30,19 +31,56 @@ type GalleryBackend struct {
 	CapabilitiesMap map[string]string `json:"capabilities,omitempty" yaml:"capabilities,omitempty"`
 }
 
+// stripVersionSuffix removes version suffix from capability strings
+// e.g., "nvidia-cuda-13" -> "nvidia", "cuda12-faster-whisper" -> "cuda"
+func stripVersionSuffix(capability string) string {
+	// Strip suffixes like "-cuda-12", "-cuda-13" to get parent capability
+	if idx := strings.LastIndex(capability, "-cuda-"); idx != -1 {
+		return capability[:idx]
+	}
+	// Also handle other version suffixes like "-v1", "-v2"
+	if idx := strings.LastIndex(capability, "-v"); idx != -1 && idx > 0 {
+		return capability[:idx]
+	}
+	return ""
+}
+
 func (backend *GalleryBackend) FindBestBackendFromMeta(systemState *system.SystemState, backends GalleryElements[*GalleryBackend]) *GalleryBackend {
 	if systemState == nil {
 		return nil
 	}
 
-	realBackend := backend.CapabilitiesMap[systemState.Capability(backend.CapabilitiesMap)]
-	if realBackend == "" {
-		xlog.Debug("No backend found for reported capability", "backend", backend.Name, "reportedCapability", systemState.Capability(backend.CapabilitiesMap))
-		return nil
+	// Try exact capability match first
+	capability := systemState.Capability(backend.CapabilitiesMap)
+	realBackend := backend.CapabilitiesMap[capability]
+
+	// Try to find the backend with exact match
+	if result := backends.FindByName(realBackend); result != nil {
+		return result
+	}
+
+	// Fallback: try parent capability (strip version suffix)
+	if parentCapability := stripVersionSuffix(capability); parentCapability != "" {
+		if parentBackend := backend.CapabilitiesMap[parentCapability]; parentBackend != "" {
+			if result := backends.FindByName(parentBackend); result != nil {
+				xlog.Debug("Using parent capability fallback", "backend", backend.Name,
+					"originalCapability", capability, "parentCapability", parentCapability)
+				return result
+			}
+		}
+	}
+
+	// Final fallback: try "default" capability
+	if defaultBackend := backend.CapabilitiesMap["default"]; defaultBackend != "" {
+		if result := backends.FindByName(defaultBackend); result != nil {
+			xlog.Debug("Using default capability fallback", "backend", backend.Name,
+				"originalCapability", capability)
+			return result
+		}
 	}
 
-	xlog.Debug("Found backend for reported capability", "backend", backend.Name, "reportedCapability", systemState.Capability(backend.CapabilitiesMap))
-	return backends.FindByName(realBackend)
+	xlog.Debug("No backend found for reported capability", "backend", backend.Name, "reportedCapability", capability)
+	return nil
 }
 
 func (m *GalleryBackend) GetInstalled() bool {

core/gallery/backends_test.go

@@ -1025,3 +1025,131 @@ var _ = Describe("Gallery Backends", func() {
 		})
 	})
 })
+
+var _ = Describe("FindBestBackendFromMeta fallback logic", func() {
+	It("should fallback to parent capability when exact match not found", func() {
+		// Simulate the issue: system has nvidia-cuda-13 but gallery only has cuda12
+		metaBackend := &GalleryBackend{
+			Metadata: Metadata{
+				Name: "faster-whisper",
+			},
+			CapabilitiesMap: map[string]string{
+				"nvidia-cuda-13": "cuda13-faster-whisper",
+				"nvidia-cuda-12": "cuda12-faster-whisper",
+				"nvidia":         "cuda-faster-whisper",
+				"default":        "cpu-faster-whisper",
+			},
+		}
+
+		cuda13Backend := &GalleryBackend{
+			Metadata: Metadata{
+				Name: "cuda13-faster-whisper",
+			},
+			URI: testImage,
+		}
+
+		cuda12Backend := &GalleryBackend{
+			Metadata: Metadata{
+				Name: "cuda12-faster-whisper",
+			},
+			URI: testImage,
+		}
+
+		cudaBackend := &GalleryBackend{
+			Metadata: Metadata{
+				Name: "cuda-faster-whisper",
+			},
+			URI: testImage,
+		}
+
+		cpuBackend := &GalleryBackend{
+			Metadata: Metadata{
+				Name: "cpu-faster-whisper",
+			},
+			URI: testImage,
+		}
+
+		// Test case 1: exact match - nvidia-cuda-12 -> cuda12-faster-whisper
+		backends := GalleryElements[*GalleryBackend]{cuda13Backend, cuda12Backend, cudaBackend, cpuBackend}
+		systemState := &system.SystemState{GPUVendor: "nvidia", CUDAGPUModel: "A100", CUDAMajor: 13, VRAM: 8 * 1024 * 1024 * 1024}
+		
+		bestBackend := metaBackend.FindBestBackendFromMeta(systemState, backends)
+		// Should find cuda13 exact match
+		Expect(bestBackend).To(Equal(cuda13Backend))
+
+		// Test case 2: no exact match, fallback to parent (nvidia-cuda-13 -> nvidia -> cuda)
+		// Remove cuda13 from backends to simulate the issue
+		backendsNoCuda13 := GalleryElements[*GalleryBackend]{cuda12Backend, cudaBackend, cpuBackend}
+		bestBackend = metaBackend.FindBestBackendFromMeta(systemState, backendsNoCuda13)
+		// Should fallback to cuda12 (parent of nvidia-cuda-13 is nvidia, but we have nvidia-cuda-12)
+		Expect(bestBackend).To(Equal(cuda12Backend))
+
+		// Test case 3: no parent match, fallback to default
+		backendsNoMatch := GalleryElements[*GalleryBackend]{cpuBackend}
+		bestBackend = metaBackend.FindBestBackendFromMeta(systemState, backendsNoMatch)
+		// Should fallback to default
+		Expect(bestBackend).To(Equal(cpuBackend))
+	})
+
+	It("should return nil when no fallback available", func() {
+		metaBackend := &GalleryBackend{
+			Metadata: Metadata{
+				Name: "faster-whisper",
+			},
+			CapabilitiesMap: map[string]string{
+				"nvidia-cuda-13": "cuda13-faster-whisper",
+				"default":        "cpu-faster-whisper",
+			},
+		}
+
+		// Only have a different backend
+		otherBackend := &GalleryBackend{
+			Metadata: Metadata{
+				Name: "other-backend",
+			},
+			URI: testImage,
+		}
+
+		backends := GalleryElements[*GalleryBackend]{otherBackend}
+		systemState := &system.SystemState{GPUVendor: "nvidia", CUDAMajor: 13, VRAM: 8 * 1024 * 1024 * 1024}
+
+		bestBackend := metaBackend.FindBestBackendFromMeta(systemState, backends)
+		Expect(bestBackend).To(BeNil())
+	})
+
+	It("should handle stripVersionSuffix correctly", func() {
+		// Test the stripVersionSuffix function via integration
+		metaBackend := &GalleryBackend{
+			Metadata: Metadata{
+				Name: "test-backend",
+			},
+			CapabilitiesMap: map[string]string{
+				"nvidia-cuda-13": "cuda13",
+				"nvidia":         "cuda",
+				"default":        "cpu",
+			},
+		}
+
+		cudaBackend := &GalleryBackend{
+			Metadata: Metadata{
+				Name: "cuda",
+			},
+			URI: testImage,
+		}
+
+		cpuBackend := &GalleryBackend{
+			Metadata: Metadata{
+				Name: "cpu",
+			},
+			URI: testImage,
+		}
+
+		backends := GalleryElements[*GalleryBackend]{cudaBackend, cpuBackend}
+		
+		// Test with cuda-13 capability that doesn't have exact match
+		systemState := &system.SystemState{GPUVendor: "nvidia", CUDAMajor: 13, VRAM: 8 * 1024 * 1024 * 1024}
+		bestBackend := metaBackend.FindBestBackendFromMeta(systemState, backends)
+		// Should fallback to "nvidia" -> "cuda"
+		Expect(bestBackend).To(Equal(cudaBackend))
+	})
+})