fix remaining convertors

Author: thushan

internal/adapter/converter/openai_converter.go

@@ -22,11 +22,15 @@ type OpenAIModelData struct {
 }
 
 // OpenAIConverter converts models to OpenAI-compatible format
-type OpenAIConverter struct{}
+type OpenAIConverter struct {
+	*BaseConverter
+}
 
 // NewOpenAIConverter creates a new OpenAI format converter
 func NewOpenAIConverter() ports.ModelResponseConverter {
-	return &OpenAIConverter{}
+	return &OpenAIConverter{
+		BaseConverter: NewBaseConverter("openai"),
+	}
 }
 
 func (c *OpenAIConverter) GetFormatName() string {

internal/adapter/converter/unified_converter.go

@@ -42,11 +42,15 @@ type EndpointStatus struct {
 }
 
 // UnifiedConverter converts models to the default Olla unified format
-type UnifiedConverter struct{}
+type UnifiedConverter struct {
+	*BaseConverter
+}
 
 // NewUnifiedConverter creates a new unified format converter
 func NewUnifiedConverter() ports.ModelResponseConverter {
-	return &UnifiedConverter{}
+	return &UnifiedConverter{
+		BaseConverter: NewBaseConverter("unified"),
+	}
 }
 
 func (c *UnifiedConverter) GetFormatName() string {
@@ -176,12 +180,16 @@ func matchesTypeFilter(model *domain.UnifiedModel, filterType string) bool {
 		return true
 	}
 
-	// Check metadata first
-	if modelType, ok := model.Metadata["type"].(string); ok && modelType == filterType {
+	// Use base converter to determine model type
+	base := NewBaseConverter("")
+	modelType := base.DetermineModelType(model, "")
+
+	// If model type matches directly, return true
+	if modelType == filterType {
 		return true
 	}
 
-	// Check capabilities as fallback
+	// Also check capabilities for backward compatibility
 	return matchesTypeByCapabilities(model.Capabilities, filterType)
 }
 

internal/adapter/converter/vllm_converter.go

@@ -16,11 +16,15 @@ type VLLMModelData = profile.VLLMModel
 type VLLMModelPermission = profile.VLLMModelPermission
 
 // VLLMConverter converts models to vLLM-compatible format with extended metadata
-type VLLMConverter struct{}
+type VLLMConverter struct {
+	*BaseConverter
+}
 
 // NewVLLMConverter creates a new vLLM format converter
 func NewVLLMConverter() ports.ModelResponseConverter {
-	return &VLLMConverter{}
+	return &VLLMConverter{
+		BaseConverter: NewBaseConverter(constants.ProviderTypeVLLM),
+	}
 }
 
 func (c *VLLMConverter) GetFormatName() string {
@@ -91,14 +95,11 @@ func (c *VLLMConverter) convertModel(model *domain.UnifiedModel) *profile.VLLMMo
 
 // findVLLMNativeName looks for the native vLLM name from aliases
 func (c *VLLMConverter) findVLLMNativeName(model *domain.UnifiedModel) string {
-	// Check aliases for vLLM source - this reliably identifies vLLM models
-	// We don't check NativeName for slashes as other providers (Ollama, etc.) also use them
-	for _, alias := range model.Aliases {
-		if alias.Source == constants.ProviderTypeVLLM {
-			return alias.Name
-		}
+	// Use base converter to find vLLM-specific alias
+	alias, found := c.BaseConverter.FindProviderAlias(model)
+	if found {
+		return alias
 	}
-
 	return ""
 }
 

internal/adapter/converter/vllm_converter_test.go

@@ -207,7 +207,7 @@ func TestVLLMConverter_GetFormatName(t *testing.T) {
 }
 
 func TestVLLMConverter_determineOwner(t *testing.T) {
-	converter := &VLLMConverter{}
+	converter := NewVLLMConverter().(*VLLMConverter)
 
 	tests := []struct {
 		name     string
@@ -245,7 +245,7 @@ func TestVLLMConverter_determineOwner(t *testing.T) {
 }
 
 func TestVLLMConverter_findVLLMNativeName(t *testing.T) {
-	converter := &VLLMConverter{}
+	converter := NewVLLMConverter().(*VLLMConverter)
 
 	t.Run("only finds vLLM name from aliases with vllm source", func(t *testing.T) {
 		// Test that slash-based names from non-vLLM sources are ignored