Improve model config error handling (#333)

Author: DePasqualeOrg

Libraries/MLXLLM/LLMModelFactory.swift

@@ -317,12 +317,26 @@ public class LLMModelFactory: ModelFactory {
         let modelDirectory = try await downloadModel(
             hub: hub, configuration: configuration, progressHandler: progressHandler)
 
-        // load the generic config to understand which model and how to load the weights
+        // Load the generic config to understand which model and how to load the weights
         let configurationURL = modelDirectory.appending(component: "config.json")
-        let baseConfig = try JSONDecoder().decode(
-            BaseConfiguration.self, from: Data(contentsOf: configurationURL))
-        let model = try typeRegistry.createModel(
-            configuration: configurationURL, modelType: baseConfig.modelType)
+
+        let baseConfig: BaseConfiguration
+        do {
+            baseConfig = try JSONDecoder().decode(
+                BaseConfiguration.self, from: Data(contentsOf: configurationURL))
+        } catch let error as DecodingError {
+            throw ModelFactoryError.configurationDecodingError(
+                configurationURL.lastPathComponent, configuration.name, error)
+        }
+
+        let model: LanguageModel
+        do {
+            model = try typeRegistry.createModel(
+                configuration: configurationURL, modelType: baseConfig.modelType)
+        } catch let error as DecodingError {
+            throw ModelFactoryError.configurationDecodingError(
+                configurationURL.lastPathComponent, configuration.name, error)
+        }
 
         // apply the weights to the bare model
         try loadWeights(
@@ -338,12 +352,12 @@ public class LLMModelFactory: ModelFactory {
                 DefaultMessageGenerator()
             }
 
+        let processor = LLMUserInputProcessor(
+            tokenizer: tokenizer, configuration: configuration,
+            messageGenerator: messageGenerator)
+
         return .init(
-            configuration: configuration, model: model,
-            processor: LLMUserInputProcessor(
-                tokenizer: tokenizer, configuration: configuration,
-                messageGenerator: messageGenerator),
-            tokenizer: tokenizer)
+            configuration: configuration, model: model, processor: processor, tokenizer: tokenizer)
     }
 
 }

Libraries/MLXLMCommon/ModelFactory.swift

@@ -7,11 +7,40 @@ import Tokenizers
 public enum ModelFactoryError: LocalizedError {
     case unsupportedModelType(String)
     case unsupportedProcessorType(String)
+    case configurationDecodingError(String, String, DecodingError)
 
     public var errorDescription: String? {
         switch self {
-        case .unsupportedModelType(let type): "Unsupported model type: \(type)"
-        case .unsupportedProcessorType(let type): "Unsupported processor type: \(type)"
+        case .unsupportedModelType(let type):
+            return "Unsupported model type: \(type)"
+        case .unsupportedProcessorType(let type):
+            return "Unsupported processor type: \(type)"
+        case .configurationDecodingError(let file, let modelName, let decodingError):
+            let errorDetail = extractDecodingErrorDetail(decodingError)
+            return "Failed to parse \(file) for model '\(modelName)': \(errorDetail)"
+        }
+    }
+
+    private func extractDecodingErrorDetail(_ error: DecodingError) -> String {
+        switch error {
+        case .keyNotFound(let key, let context):
+            let path = (context.codingPath + [key]).map { $0.stringValue }.joined(separator: ".")
+            return "Missing field '\(path)'"
+        case .typeMismatch(_, let context):
+            let path = context.codingPath.map { $0.stringValue }.joined(separator: ".")
+            return "Type mismatch at '\(path)'"
+        case .valueNotFound(_, let context):
+            let path = context.codingPath.map { $0.stringValue }.joined(separator: ".")
+            return "Missing value at '\(path)'"
+        case .dataCorrupted(let context):
+            if context.codingPath.isEmpty {
+                return "Invalid JSON"
+            } else {
+                let path = context.codingPath.map { $0.stringValue }.joined(separator: ".")
+                return "Invalid data at '\(path)'"
+            }
+        @unknown default:
+            return error.localizedDescription
         }
     }
 }

Libraries/MLXVLM/VLMModelFactory.swift

@@ -212,11 +212,24 @@ public class VLMModelFactory: ModelFactory {
         let configurationURL = modelDirectory.appending(
             component: "config.json"
         )
-        let baseConfig = try JSONDecoder().decode(
-            BaseConfiguration.self, from: Data(contentsOf: configurationURL))
 
-        let model = try typeRegistry.createModel(
-            configuration: configurationURL, modelType: baseConfig.modelType)
+        let baseConfig: BaseConfiguration
+        do {
+            baseConfig = try JSONDecoder().decode(
+                BaseConfiguration.self, from: Data(contentsOf: configurationURL))
+        } catch let error as DecodingError {
+            throw ModelFactoryError.configurationDecodingError(
+                configurationURL.lastPathComponent, configuration.name, error)
+        }
+
+        let model: LanguageModel
+        do {
+            model = try typeRegistry.createModel(
+                configuration: configurationURL, modelType: baseConfig.modelType)
+        } catch let error as DecodingError {
+            throw ModelFactoryError.configurationDecodingError(
+                configurationURL.lastPathComponent, configuration.name, error)
+        }
 
         // apply the weights to the bare model
         try loadWeights(
@@ -228,17 +241,23 @@ public class VLMModelFactory: ModelFactory {
             hub: hub
         )
 
-        let processorConfiguration = modelDirectory.appending(
+        let processorConfigurationURL = modelDirectory.appending(
             component: "preprocessor_config.json"
         )
-        let baseProcessorConfig = try JSONDecoder().decode(
-            BaseProcessorConfiguration.self,
-            from: Data(
-                contentsOf: processorConfiguration
+
+        let baseProcessorConfig: BaseProcessorConfiguration
+        do {
+            baseProcessorConfig = try JSONDecoder().decode(
+                BaseProcessorConfiguration.self,
+                from: Data(contentsOf: processorConfigurationURL)
             )
-        )
+        } catch let error as DecodingError {
+            throw ModelFactoryError.configurationDecodingError(
+                processorConfigurationURL.lastPathComponent, configuration.name, error)
+        }
+
         let processor = try processorRegistry.createModel(
-            configuration: processorConfiguration,
+            configuration: processorConfigurationURL,
             processorType: baseProcessorConfig.processorClass, tokenizer: tokenizer)
 
         return .init(