Support custom model path and MMProj hints

Home: when a custom Model Path is set for Self backend, bake the resolved full file path into a generic local model instance so the LLMService loads from the correct location (creates GenericLocal[Vision][Reasoning]Model variants with FileName set to the resolved path). This fixes cases where Chat.Properties don't reach the service and the model file must be embedded in the model object.

Settings: add RegisteredMmProjPathHint to display the expected MMProj file path for registered local vision models (shows a "MMProj file: ..." hint derived from ResolvedModelPathPreview or fallback model directory), keeping the hint in sync with the "Will load:" preview.

LLMService: when resolving an mmproj for image models, prefer the directory of a fully-qualified modelKey (custom model file path) and fall back to the configured models path; this ensures mmproj files are located next to custom model files.

Author: Madzionator

src/MaIN.InferPage/Components/Pages/Home.razor

@@ -330,7 +330,40 @@
         if (string.IsNullOrEmpty(Utils.Model)) return null;
 
         if (ModelRegistry.TryGetById(Utils.Model, out var registeredModel))
+        {
+            // When a custom Model Path is set, bake the resolved full path into a generic
+            // model so LLMService loads from the right location. This is needed because
+            // ctx._chat (which reaches LLMService) is a separate object from Home.razor's Chat,
+            // so Chat.Properties never reach the service — the path must be in model.FileName.
+            if (Utils.BackendType == BackendType.Self && registeredModel is LocalModel localReg
+                && !string.IsNullOrEmpty(Utils.Path))
+            {
+                var fullPath = Utils.Path.EndsWith(".gguf", StringComparison.OrdinalIgnoreCase)
+                    ? Utils.Path
+                    : System.IO.Path.Combine(Utils.Path, localReg.FileName);
+
+                return localReg switch
+                {
+                    IVisionModel vm when localReg is IReasoningModel { ReasonFunction: not null } rm
+                        => new GenericLocalVisionReasoningModel(
+                            FileName: fullPath, MMProjectPath: vm.MMProjectName ?? "",
+                            ReasonFunction: rm.ReasonFunction,
+                            MaxContextWindowSize: localReg.MaxContextWindowSize),
+                    IVisionModel vm
+                        => new GenericLocalVisionModel(
+                            FileName: fullPath, MMProjectPath: vm.MMProjectName ?? "",
+                            MaxContextWindowSize: localReg.MaxContextWindowSize),
+                    IReasoningModel { ReasonFunction: not null } rm
+                        => new GenericLocalReasoningModel(
+                            FileName: fullPath, ReasonFunction: rm.ReasonFunction,
+                            MaxContextWindowSize: localReg.MaxContextWindowSize),
+                    _ => new GenericLocalModel(
+                            FileName: fullPath,
+                            MaxContextWindowSize: localReg.MaxContextWindowSize)
+                };
+            }
             return registeredModel;
+        }
 
         // Self = local GGUF file; Ollama Local is an HTTP server, not a file path
         if (Utils.BackendType == BackendType.Self)

src/MaIN.InferPage/Components/Pages/Settings.razor

@@ -102,6 +102,10 @@
                                 <span class="no-capabilities">No special capabilities</span>
                             }
                         </div>
+                        @if (RegisteredMmProjPathHint is { } mmProjHint)
+                        {
+                            <span class="api-key-hint">MMProj file: @mmProjHint</span>
+                        }
                     }
                     else
                     {
@@ -201,6 +205,30 @@
     private bool _detectedReasoning;
     private bool _detectedImageGen;
 
+    // Shows expected MMProj file path for registered local vision models.
+    // Derives the directory from ResolvedModelPathPreview so it always stays in sync
+    // with the "Will load:" hint (including any custom Model Path the user typed).
+    private string? RegisteredMmProjPathHint
+    {
+        get
+        {
+            if (_selectedBackend?.BackendType != BackendType.Self || !_isRegisteredModel) return null;
+            if (!_detectedVision) return null;
+            if (string.IsNullOrWhiteSpace(_modelName)) return null;
+            if (!ModelRegistry.TryGetById(_modelName, out var aiModel) || aiModel is not LocalModel localModel) return null;
+            if (localModel is not IVisionModel visionModel || visionModel.MMProjectName is not { } mmProjName) return null;
+
+            // Reuse the already-resolved model file path to derive the directory,
+            // so changes to the Model Path field are immediately reflected here too.
+            var modelFilePath = ResolvedModelPathPreview;
+            var dir = modelFilePath != null
+                ? (Path.GetDirectoryName(modelFilePath) ?? "")
+                : (MaINSettings.ModelsPath ?? Environment.GetEnvironmentVariable("MaIN_ModelsPath") ?? "");
+
+            return string.IsNullOrEmpty(dir) ? mmProjName : Path.Combine(dir, mmProjName);
+        }
+    }
+
     // Manual capability selection (unregistered models)
     private bool _manualVision;
     private bool _manualReasoning;

src/MaIN.Services/Services/LLMService/LLMService.cs

@@ -243,7 +243,12 @@ private async Task<List<LLMTokenValue>> ProcessChatRequest(
         MtmdWeights? mtmdWeights = null;
         if (mmProjName is not null && lastMsg.Image != null)
         {
-            var mmProjPath = ResolvePath(null, mmProjName);
+            // When the model file is at a custom location (fully-qualified path),
+            // look for the mmproj in the same directory. Otherwise fall back to modelsPath.
+            var mmProjDir = Path.IsPathFullyQualified(modelKey)
+                ? Path.GetDirectoryName(modelKey)
+                : null;
+            var mmProjPath = ResolvePath(mmProjDir, mmProjName);
             mtmdWeights = await MtmdWeights.LoadFromFileAsync(
                 mmProjPath, llmModel, MtmdContextParams.Default(), cancellationToken);
         }