Fix noninformative error thrown when modelId is not found

Author: srebrek

src/MaIN.Core/Hub/Contexts/FlowContext.cs

@@ -3,6 +3,7 @@
 using MaIN.Domain.Entities;
 using MaIN.Domain.Entities.Agents;
 using MaIN.Domain.Entities.Agents.AgentSource;
+using MaIN.Domain.Exceptions.Agents;
 using MaIN.Domain.Exceptions.Flows;
 using MaIN.Domain.Models.Abstract;
 using MaIN.Services.Services.Abstract;
@@ -152,7 +153,12 @@ public async Task<ChatResult> ProcessAsync(Chat chat, bool translate = false)
     public async Task<ChatResult> ProcessAsync(string message, bool translate = false)
     {
         var chat = await _agentService.GetChatByAgent(_firstAgent!.Id);
-        var backend = ModelRegistry.GetById(chat.ModelId).Backend;
+        if (!ModelRegistry.TryGetById(chat.ModelId, out var model))
+        {
+            throw new AgentModelNotAvailableException(_firstAgent.Id, chat.ModelId);
+        }
+
+        var backend = model!.Backend;
         chat.Messages.Add(new Message()
         {
             Content = message,

src/MaIN.Core/Hub/Contexts/Interfaces/ChatContext/IChatBuilderEntryPoint.cs

@@ -6,7 +6,7 @@ public interface IChatBuilderEntryPoint : IChatActions
     /// Sets the AI model to be used for the current chat session. This determines how the AI will respond to messages
     /// based on the selected model.
     /// </summary>
-    /// <param name="model">The name of the AI model to be used.</param>
+    /// <param name="model">The ID of the AI model to be used.</param>
     /// <returns>The context instance implementing <see cref="IChatMessageBuilder"/> for method chaining.</returns>
     IChatMessageBuilder WithModel(string model);
 

src/MaIN.Domain/Exceptions/Agents/AgentModelNotAvailableException.cs

@@ -0,0 +1,10 @@
+using System.Net;
+
+namespace MaIN.Domain.Exceptions.Agents;
+
+public class AgentModelNotAvailableException(string agentId, string modelId)
+    : MaINCustomException($"Model '{modelId}' used by agent '{agentId}' is not registered. If this is a dynamically registered model, it must be re-registered after application restart.")
+{
+    public override string PublicErrorMessage => $"Model '{modelId}' is not available.";
+    public override HttpStatusCode HttpStatusCode => HttpStatusCode.UnprocessableEntity;
+}

src/MaIN.Domain/Exceptions/Chats/ChatModelNotAvailableException.cs

@@ -0,0 +1,10 @@
+using System.Net;
+
+namespace MaIN.Domain.Exceptions.Chats;
+
+public class ChatModelNotAvailableException(string chatId, string modelId)
+    : MaINCustomException($"Model '{modelId}' used by chat '{chatId}' is not registered. If this is a dynamically registered model, it must be re-registered after application restart.")
+{
+    public override string PublicErrorMessage => $"Model '{modelId}' is not available.";
+    public override HttpStatusCode HttpStatusCode => HttpStatusCode.UnprocessableEntity;
+}

src/MaIN.Services/Services/ChatService.cs

@@ -39,8 +39,12 @@ public async Task<ChatResult> Completions(
             chat.ImageGen = true;
         }
 
-        var model = ModelRegistry.GetById(chat.ModelId);
-        var backend = model.Backend;
+        if (!ModelRegistry.TryGetById(chat.ModelId, out var model))
+        {
+            throw new ChatModelNotAvailableException(chat.Id, chat.ModelId);
+        }
+
+        var backend = model!.Backend;
 
         chat.Messages.Where(x => x.Type == MessageType.NotSet).ToList()
             .ForEach(x => x.Type = backend != BackendType.Self ? MessageType.CloudLLM : MessageType.LocalLLM);

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

@@ -480,8 +480,6 @@ private static string FormatToolsForPrompt(ToolsConfiguration toolsConfig)
             }
         }
 
-
-
         return (tokens, isComplete, hasFailed);
     }
 

src/MaIN.Services/Services/Steps/BecomeStepHandler.cs

@@ -1,5 +1,6 @@
 using MaIN.Domain.Configuration;
 using MaIN.Domain.Entities;
+using MaIN.Domain.Exceptions.Agents;
 using MaIN.Domain.Models.Abstract;
 using MaIN.Services.Services.Abstract;
 using MaIN.Services.Services.Models;
@@ -34,7 +35,12 @@ public async Task<StepResult> Handle(StepContext context)
 
         await context.NotifyProgress("true", context.Agent.Id, null, context.Agent.CurrentBehaviour, StepName);
 
-        var backend = ModelRegistry.GetById(context.Chat.ModelId).Backend;
+        if (!ModelRegistry.TryGetById(context.Chat.ModelId, out var model))
+        {
+            throw new AgentModelNotAvailableException(context.Agent.Id, context.Chat.ModelId);
+        }
+
+        var backend = model!.Backend;
         context.Chat.Messages.Add(new()
         {
             Role = "System",

src/MaIN.Services/Services/Steps/Commands/AnswerCommandHandler.cs

@@ -1,6 +1,7 @@
 using MaIN.Domain.Configuration;
 using MaIN.Domain.Entities;
 using MaIN.Domain.Entities.Agents.Knowledge;
+using MaIN.Domain.Exceptions.Agents;
 using MaIN.Domain.Models;
 using MaIN.Domain.Models.Abstract;
 using MaIN.Services.Constants;
@@ -19,8 +20,7 @@ public class AnswerCommandHandler(
     ILLMServiceFactory llmServiceFactory,
     IMcpService mcpService,
     INotificationService notificationService,
-    IImageGenServiceFactory imageGenServiceFactory,
-    MaINSettings settings)
+    IImageGenServiceFactory imageGenServiceFactory)
     : ICommandHandler<AnswerCommand, Message?>
 {
     private static readonly JsonSerializerOptions _jsonOptions = new()
@@ -30,10 +30,13 @@ public class AnswerCommandHandler(
 
     public async Task<Message?> HandleAsync(AnswerCommand command)
     {
+        if (!ModelRegistry.TryGetById(command.Chat.ModelId, out var model))
+        {
+            throw new AgentModelNotAvailableException(command.AgentId, command.Chat.ModelId);
+        }
+
         ChatResult? result;
-        var backend = ModelRegistry.TryGetById(command.Chat.ModelId, out var resolvedModel)
-            ? resolvedModel!.Backend
-            : settings.BackendType;
+        var backend = model!.Backend;
         var llmService = llmServiceFactory.CreateService(backend);
         var imageGenService = imageGenServiceFactory.CreateService(backend);
 
@@ -44,15 +47,15 @@ public class AnswerCommandHandler(
                     new ChatMemoryOptions { Memory = command.Chat.Memory }, new ChatRequestOptions());
                 return result!.Message;
             case KnowledgeUsage.UseKnowledge:
-                var isKnowledgeNeeded = await ShouldUseKnowledge(command.Knowledge, command.Chat);
+                var isKnowledgeNeeded = await ShouldUseKnowledge(command.Knowledge, command.Chat, backend);
                 if (isKnowledgeNeeded)
                 {
-                    return await ProcessKnowledgeQuery(command.Knowledge, command.Chat, command.AgentId);
+                    return await ProcessKnowledgeQuery(command.Knowledge, command.Chat, command.AgentId, llmService);
                 }
 
                 break;
             case KnowledgeUsage.AlwaysUseKnowledge:
-                return await ProcessKnowledgeQuery(command.Knowledge, command.Chat, command.AgentId);
+                return await ProcessKnowledgeQuery(command.Knowledge, command.Chat, command.AgentId, llmService);
         }
 
         result = command.Chat.ImageGen
@@ -68,7 +71,7 @@ public class AnswerCommandHandler(
         return result!.Message;
     }
 
-    private async Task<bool> ShouldUseKnowledge(Knowledge? knowledge, Chat chat)
+    private async Task<bool> ShouldUseKnowledge(Knowledge? knowledge, Chat chat, BackendType backend)
     {
         var originalContent = chat.Messages.Last().Content;
 
@@ -87,9 +90,6 @@ private async Task<bool> ShouldUseKnowledge(Knowledge? knowledge, Chat chat)
                    Content of available knowledge has source tags. Prompt: {originalContent}
              """;
 
-        var backend = ModelRegistry.TryGetById(chat.ModelId, out var resolvedModel)
-            ? resolvedModel!.Backend
-            : settings.BackendType;
         var service = llmServiceFactory.CreateService(backend);
 
         var result = await service.Send(chat, new ChatRequestOptions()
@@ -104,7 +104,7 @@ private async Task<bool> ShouldUseKnowledge(Knowledge? knowledge, Chat chat)
         return shouldUseKnowledge;
     }
 
-    private async Task<Message?> ProcessKnowledgeQuery(Knowledge? knowledge, Chat chat, string agentId)
+    private async Task<Message?> ProcessKnowledgeQuery(Knowledge? knowledge, Chat chat, string agentId, ILLMService llmService)
     {
         var originalContent = chat.Messages.Last().Content;
         var indexAsKnowledge = knowledge?.Index.Items.ToDictionary(x => x.Name, x => x.Tags);
@@ -116,15 +116,10 @@ private async Task<bool> ShouldUseKnowledge(Knowledge? knowledge, Chat chat)
              KNOWLEDGE:
              {index}
 
-             Find tags that fits user query based on available knowledge (provided to you above as pair of item names with tags). 
+             Find tags that fits user query based on available knowledge (provided to you above as pair of item names with tags).
              Always return at least 1 tag in array, and no more than 4. Prompt: {originalContent}
              """;
 
-        var backend = ModelRegistry.TryGetById(chat.ModelId, out var resolvedModel)
-            ? resolvedModel!.Backend
-            : settings.BackendType;
-        var llmService = llmServiceFactory.CreateService(backend);
-
         var searchResult = await llmService.Send(chat, new ChatRequestOptions()
         {
             SaveConv = false
@@ -134,7 +129,7 @@ Find tags that fits user query based on available knowledge (provided to you abo
             .Where(x => x.Tags.Intersect(matchedTags!).Any() || matchedTags!.Contains(x.Name))
             .ToList();
 
-        //NOTE: perhaps good idea for future to combine knowledge form MCP and from KM 
+        //NOTE: perhaps good idea for future to combine knowledge form MCP and from KM
         var memoryOptions = new ChatMemoryOptions();
         var mcpConfig = BuildMemoryOptionsFromKnowledgeItems(knowledgeItems, memoryOptions);
 

src/MaIN.Services/Services/Steps/Commands/RedirectCommandHandler.cs

@@ -1,5 +1,6 @@
 using MaIN.Domain.Configuration;
 using MaIN.Domain.Entities;
+using MaIN.Domain.Exceptions.Agents;
 using MaIN.Domain.Models.Abstract;
 using MaIN.Services.Services.Abstract;
 using MaIN.Services.Services.Models.Commands;
@@ -12,7 +13,12 @@ public class RedirectCommandHandler(IAgentService agentService) : ICommandHandle
     public async Task<Message?> HandleAsync(RedirectCommand command)
     {
         var chat = await agentService.GetChatByAgent(command.RelatedAgentId);
-        var backend = ModelRegistry.GetById(chat.ModelId).Backend;
+        if (!ModelRegistry.TryGetById(chat.ModelId, out var model))
+        {
+            throw new AgentModelNotAvailableException(command.RelatedAgentId, chat.ModelId);
+        }
+
+        var backend = model!.Backend;
         chat.Messages.Add(new Message()
         {
             Role = "User",

src/MaIN.Services/Services/Steps/Commands/StartCommandHandler.cs

@@ -1,6 +1,8 @@
 using MaIN.Domain.Configuration;
 using MaIN.Domain.Entities;
+using MaIN.Domain.Exceptions.Agents;
 using MaIN.Domain.Models.Abstract;
+using MaIN.Services.Constants;
 using MaIN.Services.Services.Models.Commands;
 using MaIN.Services.Services.Steps.Commands.Abstract;
 
@@ -15,7 +17,13 @@ public class StartCommandHandler : ICommandHandler<StartCommand, Message?>
             return Task.FromResult<Message?>(null);
         }
 
-        var backend = ModelRegistry.GetById(command.Chat.ModelId).Backend;
+        var agentId = command.Chat.Properties.GetValueOrDefault(ServiceConstants.Properties.AgentIdProperty, command.Chat.Id);
+        if (!ModelRegistry.TryGetById(command.Chat.ModelId, out var model))
+        {
+            throw new AgentModelNotAvailableException(agentId, command.Chat.ModelId);
+        }
+
+        var backend = model!.Backend;
         var message = new Message()
         {
             Content = command.InitialPrompt!,