Fixed agents being left without a model when none was set aside for them (#985)

app/MindWork AI Studio/Dialogs/AssistantPluginAuditDialog.razor

@@ -29,13 +29,25 @@
                     <MudText Typo="Typo.h6">@this.plugin.Name</MudText>
                     <MudText Typo="Typo.body2" Class="mb-2">@this.plugin.Description</MudText>
                     <MudText Typo="Typo.body2">
-                        @T("Audit provider"): <strong>@this.ProviderLabel</strong>
+                        @T("Audit model"): <strong>@this.ProviderLabel</strong>
                     </MudText>
                     <MudText Typo="Typo.body2">
                         @T("Minimum required safety level"): <strong>@this.MinimumLevelLabel</strong>
                     </MudText>
                 </MudPaper>
 
+                @if (this.NeedsProviderSelection && !this.securityState.IsEnterpriseApproved)
+                {
+                    <MudPaper Class="pa-3 border-dashed border rounded-lg">
+                        <MudText Typo="Typo.body2" Class="mb-3">
+                            @T("No model is set for security checks, neither for this agent nor for the app as a whole. Choose one here to check this plugin. Your choice applies to this check only; you can set a permanent one in the app settings.")
+                        </MudText>
+                        <CascadingValue Value="Components.AGENT_ASSISTANT_PLUGIN_AUDIT">
+                            <ProviderSelection @bind-ProviderSettings="@this.auditProviderSelection" ValidateProvider="@this.ValidatingProvider" Label="@T("Model")" Disabled="@this.isAuditing" />
+                        </CascadingValue>
+                    </MudPaper>
+                }
+
                 <MudExpansionPanels MultiExpansion="true">
                     <MudExpansionPanel Expanded="true">
                         <TitleContent>

app/MindWork AI Studio/Dialogs/AssistantPluginAuditDialog.razor.cs

@@ -39,11 +39,32 @@ public partial class AssistantPluginAuditDialog : MSGComponentBase
     private bool isAuditing;
     private PluginAssistantSecurityState securityState = new();
 
+    /// <summary>
+    /// The provider the user picks inside this dialog when nothing is configured for the audit agent.
+    /// </summary>
+    /// <remarks>
+    /// It lives and dies with this dialog and is never written to the settings: an audit is a one-off
+    /// job, and the choice made here says nothing about which model the next one should use.
+    /// </remarks>
+    private AIStudio.Settings.Provider auditProviderSelection = AIStudio.Settings.Provider.NONE;
+
     private AIStudio.Settings.Provider CurrentProvider => this.SettingsManager.GetPreselectedProvider(Tools.Components.AGENT_ASSISTANT_PLUGIN_AUDIT, null, true);
 
-    private string ProviderLabel => this.CurrentProvider == AIStudio.Settings.Provider.NONE
-        ? this.T("No provider configured")
-        : $"{this.CurrentProvider.InstanceName} ({this.CurrentProvider.UsedLLMProvider.ToName()})";
+    /// <summary>
+    /// The provider this audit runs with: the configured one, or what the user picked here instead.
+    /// </summary>
+    private AIStudio.Settings.Provider EffectiveProvider => this.CurrentProvider == AIStudio.Settings.Provider.NONE
+        ? this.auditProviderSelection
+        : this.CurrentProvider;
+
+    /// <summary>
+    /// Whether this dialog has to offer a provider, because neither the audit agent nor the app has one.
+    /// </summary>
+    private bool NeedsProviderSelection => this.CurrentProvider == AIStudio.Settings.Provider.NONE;
+
+    private string ProviderLabel => this.EffectiveProvider == AIStudio.Settings.Provider.NONE
+        ? T("No model configured")
+        : $"{this.EffectiveProvider.InstanceName} ({this.EffectiveProvider.UsedLLMProvider.ToName()})";
 
     private DataAssistantPluginAudit AuditSettings => this.SettingsManager.ConfigurationData.AssistantPluginAudit;
 
@@ -51,17 +72,41 @@ public partial class AssistantPluginAuditDialog : MSGComponentBase
 
     private string MinimumLevelLabel => this.MinimumLevel.GetName();
 
-    private bool CanRunAudit => this.plugin is not null && this.CurrentProvider != AIStudio.Settings.Provider.NONE && !this.isAuditing && !this.securityState.IsEnterpriseApproved;
+    private bool CanRunAudit => this.plugin is not null && this.EffectiveProvider != AIStudio.Settings.Provider.NONE && !this.isAuditing && !this.securityState.IsEnterpriseApproved;
 
-    private bool IsAuditBelowMinimum => this.audit is not null && this.audit.Level < this.MinimumLevel;
+    /// <summary>
+    /// The audit result this dialog acts on: the one it has, unless that one concluded nothing.
+    /// </summary>
+    /// <remarks>
+    /// UNKNOWN is not a low audit level, it is the absence of a result: the model was unreachable,
+    /// the key was wrong, no provider was trusted enough. Everything which decides something has to
+    /// read it as no audit at all -- whether the plugin may be activated, and what this dialog hands
+    /// back to be stored. Otherwise a check which failed would unlock a plugin nobody has checked,
+    /// and storing it would replace the last result which did say something, because audits are kept
+    /// one per plugin. This is the rule PluginAssistantSecurityResolver already applies to the stored
+    /// audits. What the dialog shows the user still reads the raw result: a failed run is precisely
+    /// what they need to see.
+    /// </remarks>
+    private PluginAssistantAudit? ConclusiveAudit => this.audit is { Level: not AssistantAuditLevel.UNKNOWN } ? this.audit : null;
 
-    private bool IsActivationBlockedBySettings => this.AuditSettings.RequireAuditBeforeActivation && (this.audit is null || this.IsAuditBelowMinimum && this.AuditSettings.BlockActivationBelowMinimum);
+    private bool IsAuditBelowMinimum => this.ConclusiveAudit is not null && this.ConclusiveAudit.Level < this.MinimumLevel;
 
-    private bool RequiresActivationConfirmation => this.audit is not null && this.IsAuditBelowMinimum && !this.IsActivationBlockedBySettings;
+    private bool IsActivationBlockedBySettings => this.AuditSettings.RequireAuditBeforeActivation && (this.ConclusiveAudit is null || this.IsAuditBelowMinimum && this.AuditSettings.BlockActivationBelowMinimum);
+
+    private bool RequiresActivationConfirmation => this.ConclusiveAudit is not null && this.IsAuditBelowMinimum && !this.IsActivationBlockedBySettings;
 
     private bool CanEnablePlugin => this.plugin is not null && !this.isAuditing && !this.IsActivationBlockedBySettings;
 
     private Color EnableButtonColor => this.RequiresActivationConfirmation ? Color.Warning : Color.Success;
+
+    /// <summary>
+    /// Whether this dialog has produced an audit result, which is why it offers no second run.
+    /// </summary>
+    /// <remarks>
+    /// A run which concluded nothing must not set this. It would leave the user in front of a plugin
+    /// they cannot check and cannot enable, with closing and reopening the dialog as the only way on
+    /// -- and a failed run is the one case where trying again is exactly the right thing to do.
+    /// </remarks>
     private bool justAudited;
 
     private const ushort BYTES_PER_KILOBYTE = 1024;
@@ -97,26 +142,39 @@ public partial class AssistantPluginAuditDialog : MSGComponentBase
 
         try
         {
-            this.audit = await this.AssistantPluginAuditService.RunAuditAsync(this.plugin);
+            //
+            // The provider picked here is handed over as the fallback: the audit service uses it only
+            // when nothing is configured for the audit agent, so an organization-wide provider keeps
+            // its precedence.
+            //
+            this.audit = await this.AssistantPluginAuditService.RunAuditAsync(this.plugin, fallbackProvider: this.auditProviderSelection);
             this.securityState = PluginAssistantSecurityResolver.Resolve(this.SettingsManager, this.plugin);
         }
         finally
         {
             this.isAuditing = false;
-            this.justAudited = true;
+            this.justAudited = this.ConclusiveAudit is not null;
             await this.InvokeAsync(this.StateHasChanged);
         }
     }
 
+    private string? ValidatingProvider(AIStudio.Settings.Provider provider)
+    {
+        if (provider.UsedLLMProvider == LLMProviders.NONE)
+            return T("Please select a model.");
+
+        return null;
+    }
+
     private void CloseWithoutActivation()
     {
-        if (this.audit is null)
+        if (this.ConclusiveAudit is null)
         {
             this.MudDialog.Cancel();
             return;
         }
 
-        this.MudDialog.Close(DialogResult.Ok(new AssistantPluginAuditDialogResult(this.audit, false)));
+        this.MudDialog.Close(DialogResult.Ok(new AssistantPluginAuditDialogResult(this.ConclusiveAudit, false)));
     }
 
     private async Task EnablePlugin()
@@ -130,7 +188,7 @@ public partial class AssistantPluginAuditDialog : MSGComponentBase
         if (this.RequiresActivationConfirmation && !await this.ConfirmActivationBelowMinimumAsync())
             return;
 
-        this.MudDialog.Close(DialogResult.Ok(new AssistantPluginAuditDialogResult(this.audit, true)));
+        this.MudDialog.Close(DialogResult.Ok(new AssistantPluginAuditDialogResult(this.ConclusiveAudit, true)));
     }
 
     private async Task<bool> ConfirmActivationBelowMinimumAsync()

app/MindWork AI Studio/Dialogs/AssistantPluginRevisionDialog.razor.cs

@@ -198,7 +198,12 @@ public partial class AssistantPluginRevisionDialog : MSGComponentBase
         await this.InvokeAsync(this.StateHasChanged);
         try
         {
-            var audit = await this.AssistantPluginAuditService.RunAuditAsync(updatedPlugin);
+            //
+            // The provider the user picked for the revision serves as the fallback: it is used only
+            // when nothing is configured for the audit agent, and only when it is trusted enough for
+            // an audit. Without it, a revised plugin could not be checked at all here.
+            //
+            var audit = await this.AssistantPluginAuditService.RunAuditAsync(updatedPlugin, fallbackProvider: this.providerSettings);
             if (audit.Level is AssistantAuditLevel.UNKNOWN)
                 return audit;