Merge branch 'main' into chunk-data

app/MindWork AI Studio/Components/AssistantBlock.razor

@@ -7,7 +7,17 @@
         <MudCardHeader>
             <CardHeaderContent>
                 <MudStack AlignItems="AlignItems.Center" Row="@true">
-                    <MudIcon Icon="@this.Icon" Size="Size.Large" Color="Color.Primary"/>
+                    <MudElement HtmlTag="span" Style="position: relative; display: inline-flex; line-height: 1;">
+                        <MudIcon Icon="@this.Icon" Size="Size.Large" Color="Color.Primary"/>
+                        @if (this.AssistantSessionIndicator is { } indicator)
+                        {
+                            <MudTooltip Text="@indicator.Tooltip">
+                                <MudElement HtmlTag="span" Style="position: absolute; right: -0.45rem; bottom: -0.3rem; display: inline-flex; background-color: var(--mud-palette-surface); border-radius: 50%; padding: 1px;">
+                                    <MudIcon Icon="@indicator.Icon" Size="Size.Small" Color="@indicator.Color"/>
+                                </MudElement>
+                            </MudTooltip>
+                        }
+                    </MudElement>
                     <MudText Typo="Typo.h6">
                         @this.Name
                     </MudText>
@@ -24,19 +34,34 @@
         <MudCardActions>
             <MudStack Row="@true" AlignItems="AlignItems.Center" Justify="Justify.SpaceBetween" Style="width: 100%;">
                 <MudButtonGroup Variant="Variant.Outlined">
-                    <MudButton Size="Size.Large" Variant="Variant.Filled" StartIcon="@this.Icon" Color="Color.Default" Href="@this.Link" Disabled="@this.Disabled">
-                        @this.ButtonText
-                    </MudButton>
+                    @if (this.HasStartAction)
+                    {
+                        <MudButton Size="Size.Large" Variant="Variant.Filled" StartIcon="@this.Icon" Color="Color.Default" OnClick="@this.OnClick" Disabled="@this.Disabled">
+                            @this.ButtonText
+                        </MudButton>
+                    }
+                    else
+                    {
+                        <MudButton Size="Size.Large" Variant="Variant.Filled" StartIcon="@this.Icon" Color="Color.Default" Href="@this.Link" Disabled="@this.Disabled">
+                            @this.ButtonText
+                        </MudButton>
+                    }
                     @if (this.HasSettingsPanel)
                     {
                         <MudIconButton Variant="Variant.Text" Icon="@Icons.Material.Filled.Settings" Color="Color.Default" OnClick="@this.OpenSettingsDialog"/>
                     }
                 </MudButtonGroup>
-                @if (this.SecurityBadge is not null)
+                @if (this.SecurityBadge is not null || this.AdditionalActions is not null)
                 {
-                    <MudElement>
-                        @this.SecurityBadge
-                    </MudElement>
+                    <MudStack Row="@true" AlignItems="AlignItems.Center" Spacing="1">
+                        @if (this.SecurityBadge is not null)
+                        {
+                            <MudElement>
+                                @this.SecurityBadge
+                            </MudElement>
+                        }
+                        @this.AdditionalActions
+                    </MudStack>
                 }
             </MudStack>
         </MudCardActions>

app/MindWork AI Studio/Components/AssistantBlock.razor.cs

@@ -1,5 +1,9 @@
 using AIStudio.Dialogs.Settings;
 using AIStudio.Settings.DataModel;
+using AIStudio.Tools.AssistantSessions;
+using AIStudio.Tools.Media;
+using AIStudio.Tools.Services;
+
 using Microsoft.AspNetCore.Components;
 using DialogOptions = AIStudio.Dialogs.DialogOptions;
 
@@ -7,6 +11,14 @@ namespace AIStudio.Components;
 
 public partial class AssistantBlock<TSettings> : MSGComponentBase where TSettings : IComponent
 {
+    /// <summary>
+    /// Describes the assistant session indicator shown on top of the assistant icon.
+    /// </summary>
+    /// <param name="Icon">The icon that communicates the session status.</param>
+    /// <param name="Color">The color that communicates the session status.</param>
+    /// <param name="Tooltip">The tooltip text that explains the session status.</param>
+    private sealed record AssistantSessionIndicatorData(string Icon, Color Color, string Tooltip);
+
     [Parameter]
     public string Name { get; set; } = string.Empty;
 
@@ -22,15 +34,27 @@ public partial class AssistantBlock<TSettings> : MSGComponentBase where TSetting
     [Parameter]
     public string Link { get; set; } = string.Empty;
 
+    [Parameter]
+    public EventCallback OnClick { get; set; }
+
     [Parameter]
     public bool Disabled { get; set; }
 
     [Parameter]
     public RenderFragment? SecurityBadge { get; set; }
 
+    [Parameter]
+    public RenderFragment? AdditionalActions { get; set; }
+
     [Parameter]
     public Tools.Components Component { get; set; } = Tools.Components.NONE;
 
+    /// <summary>
+    /// Gets or sets the optional assistant session instance ID represented by this block.
+    /// </summary>
+    [Parameter]
+    public string AssistantSessionInstanceId { get; set; } = string.Empty;
+
     [Parameter]
     public PreviewFeatures RequiredPreviewFeature { get; set; } = PreviewFeatures.NONE;
 
@@ -39,6 +63,12 @@ public partial class AssistantBlock<TSettings> : MSGComponentBase where TSetting
 
     [Inject]
     private IDialogService DialogService { get; init; } = null!;
+
+    [Inject]
+    private AssistantSessionService AssistantSessionService { get; init; } = null!;
+
+    [Inject]
+    private MediaTranscriptionService MediaTranscriptionService { get; init; } = null!;
     
     private async Task OpenSettingsDialog()
     {
@@ -50,15 +80,107 @@ public partial class AssistantBlock<TSettings> : MSGComponentBase where TSetting
         await this.DialogService.ShowAsync<TSettings>(T("Open Settings"), dialogParameters, DialogOptions.FULLSCREEN);
     }
 
-    private string BorderColor => this.SettingsManager.IsDarkMode switch
+    private string BorderColor => this.AssistantSessionSnapshot?.IsActive is true || this.MediaImportSnapshot?.IsBusy is true ? this.ColorTheme.GetActivityIndicatorColor(this.SettingsManager) : this.SettingsManager.IsDarkMode switch
     {
-        true => this.ColorTheme.GetCurrentPalette(this.SettingsManager).GrayLight,
-        false => this.ColorTheme.GetCurrentPalette(this.SettingsManager).Primary.Value,
+        true => this.ColorTheme.GetCurrentPalette(this.SettingsManager).GrayDefault,
+        false => this.ColorTheme.GetCurrentPalette(this.SettingsManager).GrayDefault,
     };
 
-    private string BlockStyle => $"border-width: 2px; border-color: {this.BorderColor}; border-radius: 12px; border-style: solid; max-width: 20em;";
+    private string BlockStyle => $"border-width: 3px; border-color: {this.BorderColor}; border-radius: 12px; border-style: solid; max-width: 20em;";
 
     private bool IsVisible => this.SettingsManager.IsAssistantVisible(this.Component, assistantName: this.Name, requiredPreviewFeature: this.RequiredPreviewFeature);
 
     private bool HasSettingsPanel => typeof(TSettings) != typeof(NoSettingsPanel);
-}
+
+    private bool HasStartAction => this.OnClick.HasDelegate;
+
+    /// <summary>
+    /// Gets the newest assistant session snapshot represented by this block.
+    /// </summary>
+    private AssistantSessionSnapshot? AssistantSessionSnapshot => string.IsNullOrWhiteSpace(this.AssistantSessionInstanceId)
+        ? this.AssistantSessionService.GetSnapshots().FirstOrDefault(snapshot => snapshot.Key.Component == this.Component)
+        : this.AssistantSessionService.GetSnapshots().FirstOrDefault(snapshot => snapshot.Key.InstanceId == this.AssistantSessionInstanceId);
+
+    private MediaImportOwner CurrentMediaImportOwner => MediaImportOwner.ForAssistant(new AssistantSessionKey(this.Component, this.AssistantSessionInstanceId));
+
+    private MediaImportSnapshot? MediaImportSnapshot => this.MediaTranscriptionService.GetSnapshots()
+        .FirstOrDefault(snapshot => this.OwnedByThisBlock(snapshot.Owner));
+
+    /// <summary>
+    /// Gets whether a media-import owner belongs to the assistant represented by this block.
+    /// </summary>
+    /// <remarks>
+    /// Owners that persist their own sources are keyed by the stored document rather than by an
+    /// assistant session, so this block aggregates all of them for its component. Without a session
+    /// instance we aggregate every owner of the component, otherwise we match the exact owner.
+    /// </remarks>
+    /// <param name="owner">The media-import owner to test.</param>
+    /// <returns><c>true</c> when this block represents the owner.</returns>
+    private bool OwnedByThisBlock(MediaImportOwner owner)
+    {
+        if (owner.Kind.PersistsOwnSources())
+            return owner.Kind == this.Component.MediaOwnerKind();
+
+        if (string.IsNullOrWhiteSpace(this.AssistantSessionInstanceId))
+            return owner.Kind is MediaImportOwnerKind.ASSISTANT && owner.Id.StartsWith($"{this.Component}:", StringComparison.Ordinal);
+
+        return owner == this.CurrentMediaImportOwner;
+    }
+
+    /// <summary>
+    /// Gets the assistant session indicator shown on top of the assistant icon.
+    /// </summary>
+    private AssistantSessionIndicatorData? AssistantSessionIndicator => this.MediaImportSnapshot?.Status switch
+    {
+        MediaImportStatus.QUEUED or MediaImportStatus.RUNNING or MediaImportStatus.CANCELING => new(Icons.Material.Filled.ChangeCircle, Color.Info, this.T("Media is still being prepared.")),
+        MediaImportStatus.SUCCEEDED => new(Icons.Material.Filled.TaskAlt, Color.Success, this.T("The media transcript is ready.")),
+        MediaImportStatus.WARNING => new(Icons.Material.Filled.WarningAmber, Color.Warning, this.T("Media transcription completed with a warning. Open the assistant to review it.")),
+        MediaImportStatus.FAILED => new(Icons.Material.Filled.Error, Color.Error, this.T("Media transcription failed. Open the assistant to review it.")),
+        MediaImportStatus.CANCELLED => new(Icons.Material.Filled.Cancel, Color.Warning, this.T("Media transcription was canceled. Open the assistant to review it.")),
+        
+        _ => this.AssistantSessionIndicatorWithoutMedia,
+    };
+
+    private AssistantSessionIndicatorData? AssistantSessionIndicatorWithoutMedia => this.AssistantSessionSnapshot?.Status switch
+    {
+        AssistantSessionStatus.RUNNING or AssistantSessionStatus.CANCELING => new(Icons.Material.Filled.ChangeCircle, Color.Info, this.T("Assistant is still running.")),
+        AssistantSessionStatus.COMPLETED => new(Icons.Material.Filled.TaskAlt, Color.Success, this.T("The result is ready.")),
+        AssistantSessionStatus.FAILED => new(Icons.Material.Filled.Error, Color.Error, this.T("Assistant failed. Open it to review the result.")),
+        AssistantSessionStatus.CANCELED => new(Icons.Material.Filled.Cancel, Color.Warning, this.T("Assistant was canceled. Open it to review the result.")),
+        _ => null,
+    };
+
+    protected override async Task OnInitializedAsync()
+    {
+        this.MediaTranscriptionService.StateChanged += this.OnMediaImportStateChanged;
+        await base.OnInitializedAsync();
+    }
+
+    private void OnMediaImportStateChanged(MediaImportOwner owner)
+    {
+        if (this.OwnedByThisBlock(owner))
+            _ = this.InvokeAsync(this.StateHasChanged);
+    }
+
+    protected override void DisposeResources()
+    {
+        this.MediaTranscriptionService.StateChanged -= this.OnMediaImportStateChanged;
+        base.DisposeResources();
+    }
+
+    /// <summary>
+    /// Refreshes the block when assistant session activity changes.
+    /// </summary>
+    /// <typeparam name="T">The message payload type.</typeparam>
+    /// <param name="sendingComponent">The component that sent the message, if any.</param>
+    /// <param name="triggeredEvent">The event that was triggered.</param>
+    /// <param name="data">The message payload.</param>
+    /// <returns>A task that completes after the message was processed.</returns>
+    protected override Task ProcessIncomingMessage<T>(ComponentBase? sendingComponent, Event triggeredEvent, T? data) where T : default
+    {
+        if (triggeredEvent is Event.ASSISTANT_SESSION_CHANGED or Event.ASSISTANT_SESSION_FINISHED)
+            this.StateHasChanged();
+
+        return base.ProcessIncomingMessage(sendingComponent, triggeredEvent, data);
+    }
+}

app/MindWork AI Studio/Components/AssistantPluginDeleteAction.razor

@@ -0,0 +1,13 @@
+@inherits MSGComponentBase
+
+@if (this.CanDelete)
+{
+    <MudTooltip Text="@this.Tooltip">
+        <MudIconButton Icon="@Icons.Material.Filled.DeleteOutline"
+                       Color="Color.Error"
+                       Variant="Variant.Text"
+                       Size="Size.Medium"
+                       Disabled="@this.IsBlockedByActiveWork"
+                       OnClick="@this.DeleteAssistantPluginAsync" />
+    </MudTooltip>
+}

app/MindWork AI Studio/Components/AssistantPluginDeleteAction.razor.cs

@@ -0,0 +1,90 @@
+using AIStudio.Dialogs;
+using AIStudio.Tools.Media;
+using AIStudio.Tools.PluginSystem;
+using AIStudio.Tools.Services;
+using Microsoft.AspNetCore.Components;
+using DialogOptions = AIStudio.Dialogs.DialogOptions;
+
+namespace AIStudio.Components;
+
+public partial class AssistantPluginDeleteAction : MSGComponentBase
+{
+    [Parameter, EditorRequired]
+    public IAvailablePlugin Plugin { get; set; } = null!;
+
+    [Inject]
+    private IDialogService DialogService { get; init; } = null!;
+
+    [Inject]
+    private AssistantPluginInstallService AssistantPluginInstallService { get; init; } = null!;
+
+    [Inject]
+    private MediaTranscriptionService MediaTranscriptionService { get; init; } = null!;
+
+    [Inject]
+    private ILogger<AssistantPluginDeleteAction> Logger { get; init; } = null!;
+
+    private bool CanDelete => AssistantPluginInstallService.CanDeleteInstalledAssistant(this.Plugin);
+
+    private bool IsBlockedByActiveWork => this.AssistantPluginInstallService.HasActiveAssistantWork(this.Plugin.Id);
+
+    private string Tooltip => this.IsBlockedByActiveWork
+        ? this.T("The assistant cannot be deleted while background work is still running.")
+        : this.T("Delete assistant plugin");
+
+    protected override async Task OnInitializedAsync()
+    {
+        this.ApplyFilters([], [ Event.ASSISTANT_SESSION_CHANGED, Event.ASSISTANT_SESSION_FINISHED ]);
+        this.MediaTranscriptionService.StateChanged += this.OnMediaTranscriptionStateChanged;
+        await base.OnInitializedAsync();
+    }
+
+    private async Task DeleteAssistantPluginAsync()
+    {
+        if (!this.CanDelete || this.IsBlockedByActiveWork)
+            return;
+
+        var dialogParameters = new DialogParameters<ConfirmDialog>
+        {
+            {
+                x => x.Message,
+                string.Format(this.T("Do you really want to delete the assistant plugin '{0}'? This will permanently delete the local plugin files."), this.Plugin.Name)
+            },
+        };
+
+        var dialogReference = await this.DialogService.ShowAsync<ConfirmDialog>(this.T("Delete Assistant Plugin"), dialogParameters, DialogOptions.FULLSCREEN);
+        var dialogResult = await dialogReference.Result;
+        if (dialogResult is null || dialogResult.Canceled)
+            return;
+
+        var result = await this.AssistantPluginInstallService.DeleteInstalledAssistantAsync(this.Plugin, CancellationToken.None);
+        if (!result.Success)
+        {
+            this.Logger.LogError("Failed to delete assistant plugin '{PluginName}' ({PluginId}) from '{PluginDirectory}' with issue '{Issue}'.", result.PluginName, result.PluginId, result.PluginDirectory, result.Issue);
+            await this.MessageBus.SendError(new(Icons.Material.Filled.DeleteForever, string.Format(this.T("The assistant plugin '{0}' could not be deleted: {1}"), this.Plugin.Name, result.Issue)));
+            return;
+        }
+
+        await this.MessageBus.SendSuccess(new(Icons.Material.Filled.Check, string.Format(this.T("The '{0}' assistant plugin has been successfully removed."), result.PluginName)));
+    }
+
+    private void OnMediaTranscriptionStateChanged(MediaImportOwner owner)
+    {
+        if (owner.Kind is MediaImportOwnerKind.ASSISTANT && owner.Id.EndsWith($":{this.Plugin.Id}", StringComparison.Ordinal))
+            _ = this.InvokeAsync(this.StateHasChanged);
+    }
+
+    protected override Task ProcessIncomingMessage<T>(ComponentBase? sendingComponent, Event triggeredEvent, T? data) where T : default
+    {
+        if (triggeredEvent is Event.ASSISTANT_SESSION_CHANGED or Event.ASSISTANT_SESSION_FINISHED)
+            this.StateHasChanged();
+
+        return base.ProcessIncomingMessage(sendingComponent, triggeredEvent, data);
+    }
+
+    protected override void DisposeResources()
+    {
+        this.MediaTranscriptionService.StateChanged -= this.OnMediaTranscriptionStateChanged;
+        base.DisposeResources();
+    }
+}

app/MindWork AI Studio/Components/AssistantPluginSecurityCard.razor

@@ -33,6 +33,12 @@
                             <MudChip T="string" Size="Size.Small" Variant="Variant.Filled" Color="@state.AuditColor">
                                 @state.AuditLabel
                             </MudChip>
+                            @if (!string.IsNullOrWhiteSpace(state.SourceLabel))
+                            {
+                                <MudChip T="string" Size="Size.Small" Variant="Variant.Filled" Color="@state.SourceColor" Icon="@state.SourceIcon">
+                                    @state.SourceLabel
+                                </MudChip>
+                            }
                             @if (!string.IsNullOrWhiteSpace(state.AvailabilityLabel))
                             {
                                 <MudChip T="string" Size="Size.Small" Variant="Variant.Outlined" Color="@state.AvailabilityColor" Icon="@state.AvailabilityIcon">
@@ -53,18 +59,28 @@
 
                 <MudCardContent Class="pt-0 pb-2">
                     <MudStack Row="true" AlignItems="AlignItems.Center" Spacing="4" Class="flex-wrap">
-                        <MudStack Row="true" AlignItems="AlignItems.Center" Spacing="1">
-                            <MudIcon Icon="@Icons.Material.Filled.Speed" Size="Size.Small" />
-                            <MudText Typo="Typo.body2">@T("Confidence"):</MudText>
-                            <MudProgressLinear Color="@state.AuditColor"
-                                               Value="@this.GetConfidencePercentage()"
-                                               Rounded="@true"
-                                               Size="Size.Medium"
-                                               Style="width: 80px; min-width: 80px;" />
-                            <MudText Typo="Typo.caption" Class="mud-text-secondary">
-                                @this.GetConfidenceLabel()
-                            </MudText>
-                        </MudStack>
+                        @if (state.IsEnterpriseApproved)
+                        {
+                            <MudStack Row="true" AlignItems="AlignItems.Center" Spacing="1">
+                                <MudIcon Icon="@Icons.Material.Filled.Business" Size="Size.Small" Color="@state.SourceColor" />
+                                <MudText Typo="Typo.body2">@T("Enterprise approval is active")</MudText>
+                            </MudStack>
+                        }
+                        else
+                        {
+                            <MudStack Row="true" AlignItems="AlignItems.Center" Spacing="1">
+                                <MudIcon Icon="@Icons.Material.Filled.Speed" Size="Size.Small" />
+                                <MudText Typo="Typo.body2">@T("Confidence"):</MudText>
+                                <MudProgressLinear Color="@state.AuditColor"
+                                                   Value="@this.GetConfidencePercentage()"
+                                                   Rounded="@true"
+                                                   Size="Size.Medium"
+                                                   Style="width: 80px; min-width: 80px;" />
+                                <MudText Typo="Typo.caption" Class="mud-text-secondary">
+                                    @this.GetConfidenceLabel()
+                                </MudText>
+                            </MudStack>
+                        }
                         <MudDivider Vertical="@true" FlexItem="@true" />
                         <MudStack Row="true" AlignItems="AlignItems.Center" Spacing="1">
                             <MudIcon Icon="@Icons.Material.Filled.BugReport" Size="Size.Small" Color="@state.AuditColor" />
@@ -104,12 +120,63 @@
                                                 </td>
                                                 <td><code style="font-size: 0.8rem;">@this.Plugin.Id</code></td>
                                             </tr>
+                                            <tr>
+                                                <td>
+                                                    <MudText Typo="Typo.body2"><b>@T("Status source")</b></MudText>
+                                                </td>
+                                                <td><MudText Typo="Typo.body2">@state.SourceLabel</MudText></td>
+                                            </tr>
                                             <tr>
                                                 <td>
                                                     <MudText Typo="Typo.body2"><b>@T("Current hash")</b></MudText>
                                                 </td>
                                                 <td><code style="font-size: 0.8rem;">@GetShortHash(state.CurrentHash)</code></td>
                                             </tr>
+                                            @if (state.EnterpriseApproval is not null)
+                                            {
+                                                <tr>
+                                                    <td>
+                                                        <MudText Typo="Typo.body2"><b>@T("Approved hash")</b></MudText>
+                                                    </td>
+                                                    <td><code style="font-size: 0.8rem;">@GetShortHash(state.EnterpriseApproval.PluginHash)</code></td>
+                                                </tr>
+                                                @if (!string.IsNullOrWhiteSpace(state.EnterpriseApproval.DisplayName))
+                                                {
+                                                    <tr>
+                                                        <td>
+                                                            <MudText Typo="Typo.body2"><b>@T("Approved name")</b></MudText>
+                                                        </td>
+                                                        <td><MudText Typo="Typo.body2">@state.EnterpriseApproval.DisplayName</MudText></td>
+                                                    </tr>
+                                                }
+                                                @if (!string.IsNullOrWhiteSpace(state.EnterpriseApproval.ApprovedBy))
+                                                {
+                                                    <tr>
+                                                        <td>
+                                                            <MudText Typo="Typo.body2"><b>@T("Approved by")</b></MudText>
+                                                        </td>
+                                                        <td><MudText Typo="Typo.body2">@state.EnterpriseApproval.ApprovedBy</MudText></td>
+                                                    </tr>
+                                                }
+                                                @if (state.EnterpriseApproval.ApprovedAtUtc is not null)
+                                                {
+                                                    <tr>
+                                                        <td>
+                                                            <MudText Typo="Typo.body2"><b>@T("Approved at")</b></MudText>
+                                                        </td>
+                                                        <td><MudText Typo="Typo.body2">@this.FormatFileTimestamp(state.EnterpriseApproval.ApprovedAtUtc.Value.ToLocalTime().DateTime)</MudText></td>
+                                                    </tr>
+                                                }
+                                                @if (!string.IsNullOrWhiteSpace(state.EnterpriseApproval.Comment))
+                                                {
+                                                    <tr>
+                                                        <td>
+                                                            <MudText Typo="Typo.body2"><b>@T("Approval comment")</b></MudText>
+                                                        </td>
+                                                        <td><MudText Typo="Typo.body2">@state.EnterpriseApproval.Comment</MudText></td>
+                                                    </tr>
+                                                }
+                                            }
                                             @if (state.Audit is not null)
                                             {
                                                 <tr>
@@ -156,9 +223,18 @@
 
                             @if (state.Audit is null)
                             {
-                                <MudAlert Severity="Severity.Info" Variant="Variant.Text" Dense="@true">
-                                    @T("No stored audit details are available yet.")
-                                </MudAlert>
+                                @if (state.IsEnterpriseApproved)
+                                {
+                                    <MudAlert Severity="Severity.Success" Variant="Variant.Text" Dense="@true">
+                                        @T("This plugin is approved by your organization. A manual security audit is not required.")
+                                    </MudAlert>
+                                }
+                                else
+                                {
+                                    <MudAlert Severity="Severity.Info" Variant="Variant.Text" Dense="@true">
+                                        @T("No stored audit details are available yet.")
+                                    </MudAlert>
+                                }
                             }
                             else if (state.Audit.Findings.Count == 0)
                             {

app/MindWork AI Studio/Components/AssistantPluginSecurityCard.razor.cs

@@ -103,12 +103,23 @@ public partial class AssistantPluginSecurityCard : MSGComponentBase
 
     private string GetFindingSummary()
     {
+        if (this.SecurityState.IsEnterpriseApproved)
+            return this.T("No user audit required");
+
         var count = this.SecurityState.Audit?.Findings.Count ?? 0;
         return string.Format(this.T("{0} Finding(s)"), count);
     }
 
     private string GetAuditTimestampLabel()
     {
+        if (this.SecurityState.IsEnterpriseApproved)
+        {
+            var approvedAt = this.SecurityState.EnterpriseApproval?.ApprovedAtUtc;
+            return approvedAt is null
+                ? this.T("Company approved")
+                : this.FormatFileTimestamp(approvedAt.Value.ToLocalTime().DateTime);
+        }
+
         var auditedAt = this.SecurityState.Audit?.AuditedAtUtc;
         return auditedAt is null
             ? this.T("No audit yet")

app/MindWork AI Studio/Components/AttachDocuments.razor

@@ -2,57 +2,66 @@
 
 @if (this.UseSmallForm)
 {
-    <div @onmouseenter="@this.OnMouseEnter" @onmouseleave="@this.OnMouseLeave">
-        @if (this.isDraggingOver)
-        {
-            <MudBadge
-                Content="@this.DocumentPaths.Count"
-                Color="Color.Primary"
-                Overlap="true"
-                Class="cursor-pointer"
-                OnClick="@this.OpenAttachmentsDialog">
-                <MudLink OnClick="@this.AddFilesManually" Style="text-decoration: none;">
-                    <MudTextField T="string"
-                                  Text="@DROP_FILES_HERE_TEXT"
-                                  Adornment="Adornment.Start"
-                                  AdornmentIcon="@Icons.Material.Filled.AttachFile"
-                                  Typo="Typo.body2"
-                                  Variant="Variant.Outlined"
-                                  ReadOnly="true"
-                    />
-                </MudLink>
-            </MudBadge>
-        }
-        else if (this.DocumentPaths.Any())
-        {
-            <MudTooltip Text="@T("Click the paperclip to attach files, or click the number to see your attached files.")" Placement="@TOOLBAR_TOOLTIP_PLACEMENT">
+    <MudStack Spacing="0">
+        <div @onmouseenter="@this.OnMouseEnter" @onmouseleave="@this.OnMouseLeave">
+            @if (this.isDraggingOver)
+            {
                 <MudBadge
                     Content="@this.DocumentPaths.Count"
                     Color="Color.Primary"
                     Overlap="true"
                     Class="cursor-pointer"
                     OnClick="@this.OpenAttachmentsDialog">
+                    <MudLink OnClick="@this.AddFilesManually" Style="text-decoration: none;">
+                        <MudTextField T="string"
+                                      Text="@DROP_FILES_HERE_TEXT"
+                                      Adornment="Adornment.Start"
+                                      AdornmentIcon="@Icons.Material.Filled.AttachFile"
+                                      Typo="Typo.body2"
+                                      Variant="Variant.Outlined"
+                                      ReadOnly="true"
+                                      Disabled="@this.IsUnavailable"
+                        />
+                    </MudLink>
+                </MudBadge>
+            }
+            else if (this.DocumentPaths.Any())
+            {
+                <MudTooltip Text="@T("Click the paperclip to attach files, or click the number to see your attached files.")" Placement="@TOOLBAR_TOOLTIP_PLACEMENT">
+                    <MudBadge
+                        Content="@this.DocumentPaths.Count"
+                        Color="Color.Primary"
+                        Overlap="true"
+                        Class="cursor-pointer"
+                        OnClick="@this.OpenAttachmentsDialog">
+                        <MudIconButton
+                            Icon="@Icons.Material.Filled.AttachFile"
+                            Color="Color.Default"
+                            Disabled="@this.IsUnavailable"
+                            OnClick="@this.AddFilesManually"/>
+                    </MudBadge>
+                </MudTooltip>
+            }
+            else
+            {
+                <MudTooltip Text="@T("Click here to attach files.")" Placement="@TOOLBAR_TOOLTIP_PLACEMENT">
                     <MudIconButton
                         Icon="@Icons.Material.Filled.AttachFile"
                         Color="Color.Default"
+                        Disabled="@this.IsUnavailable"
                         OnClick="@this.AddFilesManually"/>
-                </MudBadge>
-            </MudTooltip>
-        }
-        else
+                </MudTooltip>
+            }
+        </div>
+        @if (this.ShowMediaStatus)
         {
-            <MudTooltip Text="@T("Click here to attach files.")" Placement="@TOOLBAR_TOOLTIP_PLACEMENT">
-                <MudIconButton
-                    Icon="@Icons.Material.Filled.AttachFile"
-                    Color="Color.Default"
-                    OnClick="@this.AddFilesManually"/>
-            </MudTooltip>
+            <MediaTranscriptionStatus Owner="@this.EffectiveImportOwner" TargetId="@this.EffectiveMediaImportTarget.TargetId" Compact="true"/>
         }
-    </div>
+    </MudStack>
 }
 else
 {
-    @if (!this.Disabled)
+    @if (!this.IsUnavailable)
     {
         <MudStack Row="true" AlignItems="AlignItems.Center" StretchItems="StretchItems.None" Wrap="Wrap.Wrap">
             <MudText Typo="Typo.body1" Inline="true">
@@ -69,11 +78,15 @@ else
             </MudButton>
         </MudStack>
     }
+    @if (this.ShowMediaStatus)
+    {
+        <MediaTranscriptionStatus Owner="@this.EffectiveImportOwner" TargetId="@this.EffectiveMediaImportTarget.TargetId"/>
+    }
     <div @onmouseenter="@this.OnMouseEnter" @onmouseleave="@this.OnMouseLeave">
         <MudPaper Height="20em" Outlined="true" Class="@this.dragClass" Style="overflow-y: auto;">
             @foreach (var fileAttachment in this.DocumentPaths)
             {
-                @if (this.Disabled)
+                @if (this.IsUnavailable)
                 {
                     <MudChip T="string" Color="Color.Dark" Text="@fileAttachment.FileName" tabindex="-1" Icon="@Icons.Material.Filled.Search" OnClick="@(() => this.InvestigateFile(fileAttachment))"/>
                 }
@@ -84,7 +97,7 @@ else
             }
         </MudPaper>
     </div>
-    @if (!this.Disabled)
+    @if (!this.IsUnavailable)
     {
         <MudButton OnClick="@(async () => await this.ClearAllFiles())" Variant="Variant.Filled" Color="Color.Info" Class="mt-2" StartIcon="@Icons.Material.Filled.Delete">
             @T("Clear file list")

app/MindWork AI Studio/Components/AttachDocuments.razor.cs

@@ -1,5 +1,6 @@
 using AIStudio.Chat;
 using AIStudio.Dialogs;
+using AIStudio.Tools.Media;
 using AIStudio.Tools.PluginSystem;
 using AIStudio.Tools.Rust;
 using AIStudio.Tools.Services;
@@ -13,6 +14,11 @@ using DialogOptions = Dialogs.DialogOptions;
 
 public partial class AttachDocuments : MSGComponentBase
 {
+    private readonly MediaImportOwner fallbackMediaImportOwner = new(MediaImportOwnerKind.CHAT, $"attachments:{Guid.NewGuid():N}");
+
+    [CascadingParameter]
+    private MediaImportOwner? ImportOwner { get; set; }
+
     private static string TB(string fallbackEN) => I18N.I.T(fallbackEN, typeof(AttachDocuments).Namespace, nameof(AttachDocuments));
 
     [Parameter]
@@ -47,10 +53,10 @@ public partial class AttachDocuments : MSGComponentBase
 
     [Parameter]
     public bool UseSmallForm { get; set; }
-    
+
+    /// <summary>Whether this control renders its own media status.</summary>
     [Parameter]
-    public FileType[]? AllowedFileTypes { get; set; }
-    
+    public bool ShowMediaStatus { get; set; } = true;
 
     [Parameter]
     public bool Disabled { get; set; }
@@ -67,6 +73,20 @@ public partial class AttachDocuments : MSGComponentBase
     [Parameter]
     public AIStudio.Settings.Provider? Provider { get; set; }
 
+    /// <summary>
+    /// Gets or sets the optional picker and drop filter applied before standard attachment validation.
+    /// </summary>
+    [Parameter]
+    public FileTypeFilter[]? AllowedFileTypes { get; set; }
+
+    /// <summary>Optional persisted chat that can own transcript files immediately.</summary>
+    [Parameter]
+    public ChatThread? OwnerChat { get; set; }
+
+    /// <summary>Creates and persists a draft owner after media import confirmation.</summary>
+    [Parameter]
+    public Func<string, Task<ChatThread?>> EnsureOwnerChatAsync { get; set; } = _ => Task.FromResult<ChatThread?>(null);
+
     [Inject]
     private ILogger<AttachDocuments> Logger { get; set; } = null!;
 
@@ -79,17 +99,29 @@ public partial class AttachDocuments : MSGComponentBase
     [Inject]
     private PandocAvailabilityService PandocAvailabilityService { get; init; } = null!;
 
+    [Inject]
+    private MediaTranscriptionService MediaTranscriptionService { get; init; } = null!;
+
     private const Placement TOOLBAR_TOOLTIP_PLACEMENT = Placement.Top;
     private static readonly string DROP_FILES_HERE_TEXT = TB("Drop files here to attach them.");
 
     private uint numDropAreasAboveThis;
     private bool isComponentHovered;
     private bool isDraggingOver;
+    private bool isFileDialogOpen;
+    private MediaImportOwner EffectiveImportOwner => this.OwnerChat is not null
+        ? MediaImportOwner.ForChat(this.OwnerChat.ChatId)
+        : this.ImportOwner ?? this.fallbackMediaImportOwner;
+
+    private MediaImportTarget EffectiveMediaImportTarget => new(this.EffectiveImportOwner, string.IsNullOrWhiteSpace(this.Name) ? "attachments" : this.Name);
+
+    private bool IsUnavailable => this.Disabled || this.isFileDialogOpen || this.MediaTranscriptionService.IsBusy(this.EffectiveImportOwner);
 
     #region Overrides of MSGComponentBase
 
     protected override async Task OnInitializedAsync()
     {
+        this.MediaTranscriptionService.StateChanged += this.OnMediaImportStateChanged;
         this.ApplyFilters([], [ Event.TAURI_EVENT_RECEIVED, Event.REGISTER_FILE_DROP_AREA, Event.UNREGISTER_FILE_DROP_AREA ]);
 
         // Register this drop area:
@@ -97,9 +129,105 @@ public partial class AttachDocuments : MSGComponentBase
         await base.OnInitializedAsync();
     }
 
+    /// <summary>Rehydrates results after the component is assigned another chat or target.</summary>
+    protected override async Task OnParametersSetAsync()
+    {
+        await base.OnParametersSetAsync();
+        await this.SyncCompletedMediaAttachmentsAsync();
+    }
+
+    /// <summary>Refreshes disabled controls when the shared import lane changes.</summary>
+    private void OnMediaImportStateChanged(MediaImportOwner owner)
+    {
+        if (owner == this.EffectiveImportOwner)
+            _ = this.InvokeAsync(async () =>
+            {
+                await this.SyncCompletedMediaAttachmentsAsync();
+                await this.ConsumeStandaloneMediaOutcomeAsync();
+                this.StateHasChanged();
+            });
+    }
+
+    /// <summary>Consumes outcomes for dialog-local controls that have no chat or assistant owner surface.</summary>
+    private async Task ConsumeStandaloneMediaOutcomeAsync()
+    {
+        if (this.ImportOwner is not null || this.OwnerChat is not null)
+            return;
+
+        var outcome = this.MediaTranscriptionService.TryConsumeOutcome(this.EffectiveImportOwner);
+        if (outcome is null)
+            return;
+
+        if (outcome.Failures.Count > 0)
+        {
+            var message = string.Join(Environment.NewLine, outcome.Failures.Select(failure => $"{failure.FileName}: {failure.UserMessage}"));
+            await this.MessageBus.SendError(new(Icons.Material.Filled.VoiceChat, message));
+        }
+        else if (outcome.Status is MediaImportStatus.FAILED)
+        {
+            await this.MessageBus.SendError(new(Icons.Material.Filled.VoiceChat, this.T("The media file could not be transcribed.")));
+        }
+
+        if (outcome.Warnings.Count > 0)
+        {
+            var message = string.Join(Environment.NewLine, outcome.Warnings.Select(warning => $"{warning.FileName}: {warning.UserMessage}"));
+            await this.MessageBus.SendWarning(new(Icons.Material.Filled.VoiceChat, message));
+        }
+
+        if (outcome.Status is MediaImportStatus.CANCELLED)
+        {
+            await this.MessageBus.SendWarning(new(Icons.Material.Filled.VoiceChat, this.T("The media transcription was canceled.")));
+        }
+    }
+
+    /// <summary>Reattaches completed owner results after progress updates or navigation.</summary>
+    private async Task SyncCompletedMediaAttachmentsAsync()
+    {
+        var delivery = this.MediaTranscriptionService.GetPendingDelivery(this.EffectiveMediaImportTarget);
+        // Owners that persist their own sources have already taken the media over when the batch
+        // started, so re-adding the delivered transcripts here would duplicate them.
+        var completed = this.EffectiveImportOwner.Kind.PersistsOwnSources()
+            ? Array.Empty<FileAttachment>()
+            : delivery?.Attachments ?? [];
+        var pending = this.OwnerChat?.PendingMediaTranscripts ?? [];
+        var changed = false;
+        var ownerPendingChanged = false;
+        
+        foreach (var attachment in completed.Concat(pending))
+            changed |= this.DocumentPaths.Add(attachment);
+
+        if (this.OwnerChat is not null)
+        {
+            foreach (var attachment in completed.OfType<ManagedTranscriptAttachment>())
+            {
+                if (this.OwnerChat.PendingMediaTranscripts.All(existing => existing.FilePath != attachment.FilePath))
+                {
+                    this.OwnerChat.PendingMediaTranscripts.Add(attachment);
+                    ownerPendingChanged = true;
+                }
+            }
+        }
+
+        if (changed || ownerPendingChanged)
+        {
+            await this.DocumentPathsChanged.InvokeAsync(this.DocumentPaths);
+            await this.OnChange(this.DocumentPaths);
+        }
+
+        if (delivery is not null)
+            this.MediaTranscriptionService.AcknowledgeDelivery(delivery);
+    }
+
+    /// <summary>Unsubscribes from the singleton media service.</summary>
+    protected override void DisposeResources()
+    {
+        this.MediaTranscriptionService.StateChanged -= this.OnMediaImportStateChanged;
+        base.DisposeResources();
+    }
+
     protected override async Task ProcessIncomingMessage<T>(ComponentBase? sendingComponent, Event triggeredEvent, T? data) where T : default
     {
-        if (this.Disabled && triggeredEvent == Event.TAURI_EVENT_RECEIVED)
+        if (this.IsUnavailable && triggeredEvent == Event.TAURI_EVENT_RECEIVED)
             return;
 
         switch (triggeredEvent)
@@ -172,29 +300,7 @@ public partial class AttachDocuments : MSGComponentBase
                     return;
                 }
 
-                // Ensure that Pandoc is installed and ready:
-                var pandocState = await this.PandocAvailabilityService.EnsureAvailabilityAsync(
-                    showSuccessMessage: false,
-                    showDialog: true);
-
-                // If Pandoc is not available (user cancelled installation), abort file drop:
-                if (!pandocState.IsAvailable)
-                {
-                    this.Logger.LogWarning("The user cancelled the Pandoc installation or Pandoc is not available. Aborting file drop.");
-                    this.isDraggingOver = false;
-                    this.ClearDragClass();
-                    this.StateHasChanged();
-                    return;
-                }
-
-                foreach (var path in paths)
-                {
-                    if(!await FileExtensionValidation.IsExtensionValidWithNotifyAsync(FileExtensionValidation.UseCase.ATTACHING_CONTENT, path, this.ValidateMediaFileTypes, this.Provider))
-                        continue;
-
-                    this.DocumentPaths.Add(FileAttachment.FromPath(path));
-                }
-
+                await this.AddFileBatchAsync(paths);
                 await this.DocumentPathsChanged.InvokeAsync(this.DocumentPaths);
                 await this.OnChange(this.DocumentPaths);
                 this.isDraggingOver = false;
@@ -212,54 +318,49 @@ public partial class AttachDocuments : MSGComponentBase
 
     private async Task AddFilesManually()
     {
-        if (this.Disabled)
+        if (this.IsUnavailable)
             return;
 
-        // Ensure that Pandoc is installed and ready:
-        var pandocState = await this.PandocAvailabilityService.EnsureAvailabilityAsync(
-            showSuccessMessage: false,
-            showDialog: true);
-
-        // If Pandoc is not available (user cancelled installation), abort file selection:
-        if (!pandocState.IsAvailable)
+        this.isFileDialogOpen = true;
+        try
         {
-            this.Logger.LogWarning("The user cancelled the Pandoc installation or Pandoc is not available. Aborting file selection.");
-            return;
+            var selectFiles = await this.RustService.SelectFiles(T("Select files to attach"), this.AllowedFileTypes);
+            if (selectFiles.UserCancelled)
+                return;
+
+            await this.AddFileBatchAsync(selectFiles.SelectedFilePaths);
+            await this.DocumentPathsChanged.InvokeAsync(this.DocumentPaths);
+            await this.OnChange(this.DocumentPaths);
         }
-
-        var selectFiles = await this.RustService.SelectFiles(T("Select files to attach"));
-        if (selectFiles.UserCancelled)
-            return;
-
-        foreach (var selectedFilePath in selectFiles.SelectedFilePaths)
+        finally
         {
-            if (!File.Exists(selectedFilePath))
-                continue;
-
-            if (!await FileExtensionValidation.IsExtensionValidWithNotifyAsync(FileExtensionValidation.UseCase.ATTACHING_CONTENT, selectedFilePath, this.ValidateMediaFileTypes, this.Provider))
-                continue;
-
-            this.DocumentPaths.Add(FileAttachment.FromPath(selectedFilePath));
+            this.isFileDialogOpen = false;
         }
-
-        await this.DocumentPathsChanged.InvokeAsync(this.DocumentPaths);
-        await this.OnChange(this.DocumentPaths);
     }
 
     private async Task OpenAttachmentsDialog()
     {
-        if (this.Disabled)
+        if (this.IsUnavailable)
             return;
 
+        var previousAttachments = this.DocumentPaths.ToHashSet();
         this.DocumentPaths = await ReviewAttachmentsDialog.OpenDialogAsync(this.DialogService, this.DocumentPaths);
+        foreach (var removedAttachment in previousAttachments.Except(this.DocumentPaths))
+            ManagedTranscriptAttachment.TryDeleteOwnedFile(removedAttachment);
+        
+        this.ReconcileOwnerPendingTranscripts();
     }
 
     private async Task ClearAllFiles()
     {
-        if (this.Disabled)
+        if (this.IsUnavailable)
             return;
 
+        foreach (var attachment in this.DocumentPaths)
+            ManagedTranscriptAttachment.TryDeleteOwnedFile(attachment);
+        
         this.DocumentPaths.Clear();
+        this.ReconcileOwnerPendingTranscripts();
         await this.DocumentPathsChanged.InvokeAsync(this.DocumentPaths);
         await this.OnChange(this.DocumentPaths);
     }
@@ -270,7 +371,7 @@ public partial class AttachDocuments : MSGComponentBase
 
     private void OnMouseEnter(EventArgs _)
     {
-        if(this.Disabled || this.PauseCatchingDrops)
+        if(this.IsUnavailable || this.PauseCatchingDrops)
             return;
 
         this.Logger.LogDebug("Attach documents component '{Name}' is hovered.", this.Name);
@@ -281,7 +382,7 @@ public partial class AttachDocuments : MSGComponentBase
 
     private void OnMouseLeave(EventArgs _)
     {
-        if(this.Disabled || this.PauseCatchingDrops)
+        if(this.IsUnavailable || this.PauseCatchingDrops)
             return;
 
         this.Logger.LogDebug("Attach documents component '{Name}' is no longer hovered.", this.Name);
@@ -292,15 +393,124 @@ public partial class AttachDocuments : MSGComponentBase
 
     private async Task RemoveDocument(FileAttachment fileAttachment)
     {
-        if (this.Disabled)
+        if (this.IsUnavailable)
             return;
 
         this.DocumentPaths.Remove(fileAttachment);
+        ManagedTranscriptAttachment.TryDeleteOwnedFile(fileAttachment);
+        this.ReconcileOwnerPendingTranscripts();
 
         await this.DocumentPathsChanged.InvokeAsync(this.DocumentPaths);
         await this.OnChange(this.DocumentPaths);
     }
 
+    /// <summary>Keeps persisted chat-draft transcript references aligned with the composer.</summary>
+    private void ReconcileOwnerPendingTranscripts()
+    {
+        if (this.OwnerChat is null)
+            return;
+
+        var retainedPaths = this.DocumentPaths.Select(attachment => attachment.FilePath).ToHashSet(StringComparer.Ordinal);
+        this.OwnerChat.PendingMediaTranscripts.RemoveAll(attachment => !retainedPaths.Contains(attachment.FilePath));
+    }
+
+    private async Task AddFileBatchAsync(IEnumerable<string> paths)
+    {
+        var pathList = paths.ToList();
+        if (this.AllowedFileTypes is { Length: > 0 })
+        {
+            var rejectedPaths = pathList.Where(path => !FileTypes.IsAllowedPath(path, this.AllowedFileTypes)).ToArray();
+            pathList.RemoveAll(path => rejectedPaths.Contains(path, StringComparer.Ordinal));
+            if (rejectedPaths.Length > 0)
+                await this.MessageBus.SendWarning(new(Icons.Material.Filled.Warning, this.T("Some files do not use an allowed format and were not attached.")));
+        }
+
+        var inaccessiblePaths = pathList.Where(path => !File.Exists(path)).ToList();
+        if (inaccessiblePaths.Count > 0)
+        {
+            this.Logger.LogWarning("Could not access {Count} dropped or selected file(s): {Paths}", inaccessiblePaths.Count, string.Join(", ", inaccessiblePaths));
+            await this.MessageBus.SendWarning(new(
+                Icons.Material.Filled.Warning,
+                this.T("Some files could not be accessed. Please select them with the file chooser instead.")));
+        }
+
+        var existingPaths = pathList.Except(inaccessiblePaths).ToList();
+        var mediaPaths = existingPaths.Where(IsTranscribableMedia).ToList();
+        var regularPaths = existingPaths.Except(mediaPaths).ToList();
+
+        var canAddRegularFiles = true;
+        if (regularPaths.Count > 0)
+        {
+            var pandocState = await this.PandocAvailabilityService.EnsureAvailabilityAsync(
+                showSuccessMessage: false,
+                showDialog: true);
+            canAddRegularFiles = pandocState.IsAvailable;
+        }
+
+        foreach (var path in regularPaths)
+        {
+            if (!canAddRegularFiles)
+                break;
+
+            if (!await FileExtensionValidation.IsExtensionValidWithNotifyAsync(FileExtensionValidation.UseCase.ATTACHING_CONTENT, path, this.ValidateMediaFileTypes, this.Provider))
+                continue;
+            
+            this.DocumentPaths.Add(FileAttachment.FromPath(path));
+        }
+
+        if (mediaPaths.Count is 0)
+            return;
+
+        if (string.IsNullOrWhiteSpace(this.SettingsManager.ConfigurationData.App.UseTranscriptionProvider))
+        {
+            await this.MessageBus.SendWarning(new(
+                Icons.Material.Filled.VoiceChat,
+                this.T("Media files require a configured transcription provider. Configure one in the transcription settings.")));
+            return;
+        }
+
+        var names = string.Join('\n', mediaPaths.Select(path => $"- {Markdown.EscapeInlineText(Path.GetFileName(path))}"));
+        var message = this.T("The selected audio and video files will be prepared locally. Their audio will then be uploaded to the configured transcription provider.");
+        var dialogParameters = new DialogParameters<ConfirmDialog>
+        {
+            {
+                x => x.MarkdownBody,
+                $"""
+                 {message}
+
+                 {names}
+                 """
+            },
+        };
+
+        var dialogReference = await this.DialogService.ShowAsync<ConfirmDialog>(
+            this.T("Transcribe media files"),
+            dialogParameters,
+            DialogOptions.FULLSCREEN);
+
+        var dialogResult = await dialogReference.Result;
+        if (dialogResult is null || dialogResult.Canceled)
+            return;
+
+        if (this.OwnerChat is null)
+            this.OwnerChat = await this.EnsureOwnerChatAsync(mediaPaths[0]);
+
+        // Owners that persist their own sources show the file right away and keep it next to the
+        // stored document, instead of waiting for the transcription to be delivered back.
+        if (this.EffectiveImportOwner.Kind.PersistsOwnSources())
+        {
+            foreach (var mediaPath in mediaPaths)
+                this.DocumentPaths.Add(FileAttachment.FromPath(mediaPath));
+            
+            await this.DocumentPathsChanged.InvokeAsync(this.DocumentPaths);
+            await this.OnChange(this.DocumentPaths);
+        }
+
+        this.MediaTranscriptionService.TryStartAttachmentBatch(mediaPaths, this.EffectiveMediaImportTarget, this.OwnerChat);
+    }
+
+    private static bool IsTranscribableMedia(string path) => FileTypes.IsAllowedPath(path, FileTypes.AUDIO) || FileTypes.IsAllowedPath(path, FileTypes.VIDEO);
+
     /// <summary>
     /// The user might want to check what we actually extract from his file and therefore give the LLM as an input.
     /// </summary>

app/MindWork AI Studio/Components/Changelog.Logs.cs

@@ -13,6 +13,9 @@ public partial class Changelog
     
     public static readonly Log[] LOGS = 
     [
+        new (250, "v26.7.3, build 250 (2026-07-21 12:45 UTC)", "v26.7.3.md"),
+        new (244, "v26.7.2, build 244 (2026-07-06 18:35 UTC)", "v26.7.2.md"),
+        new (243, "v26.7.1, build 243 (2026-07-05 16:39 UTC)", "v26.7.1.md"),
         new (242, "v26.6.2, build 242 (2026-06-21 14:07 UTC)", "v26.6.2.md"),
         new (241, "v26.6.1, build 241 (2026-06-11 13:49 UTC)", "v26.6.1.md"),
         new (240, "v26.5.5, build 240 (2026-05-25 18:52 UTC)", "v26.5.5.md"),

app/MindWork AI Studio/Components/ChatComponent.razor

@@ -33,6 +33,7 @@
         }
     </ChildContent>
     <FooterContent>
+        <MediaTranscriptionStatus Owner="@this.CurrentMediaImportOwner"/>
         <MudElement Style="flex: 0 0 auto;">
             <UserPromptComponent
                 T="string"
@@ -45,7 +46,7 @@
                 Label="@this.InputLabel"
                 Placeholder="@this.ProviderPlaceholder"
                 Adornment="Adornment.End"
-                AdornmentIcon="@Icons.Material.Filled.Send"
+                AdornmentIcon="@(this.MediaTranscriptionService.IsBusy(this.CurrentMediaImportOwner) ? Icons.Material.Filled.HourglassTop : Icons.Material.Filled.Send)"
                 OnAdornmentClick="() => this.SendMessage()"
                 Disabled="@this.IsInputForbidden()"
                 Immediate="@true"
@@ -103,7 +104,7 @@
                 </MudTooltip>
             }
             
-            <AttachDocuments Name="File Attachments" Layer="@DropLayers.PAGES" DocumentPaths="@this.ComposerState.FileAttachments" DocumentPathsChanged="@this.ComposerAttachmentsChanged" CatchAllDocuments="true" UseSmallForm="true" Provider="@this.Provider"/>
+            <AttachDocuments Name="File Attachments" Layer="@DropLayers.PAGES" DocumentPaths="@this.ComposerState.FileAttachments" DocumentPathsChanged="@this.ComposerAttachmentsChanged" CatchAllDocuments="true" UseSmallForm="true" ShowMediaStatus="false" Provider="@this.Provider" OwnerChat="@this.ChatThread" EnsureOwnerChatAsync="@this.EnsureMediaImportChatAsync" Disabled="@this.MediaTranscriptionService.IsBusy(this.CurrentMediaImportOwner)"/>
             
             <MudDivider Vertical="true" Style="height: 24px; align-self: center;"/>
             

app/MindWork AI Studio/Components/ChatComponent.razor.cs

@@ -4,7 +4,9 @@ using AIStudio.Provider;
 using AIStudio.Settings;
 using AIStudio.Settings.DataModel;
 using AIStudio.Tools.AIJobs;
+using AIStudio.Tools.Media;
 using AIStudio.Tools.Services;
+
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 
@@ -14,6 +16,7 @@ namespace AIStudio.Components;
 
 public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
 {
+    private readonly Guid draftMediaOwnerId = Guid.NewGuid();
     private const string CHAT_INPUT_ID = "chat-user-input";
     private const string MARKDOWN_CODE = "code";
     private const string MARKDOWN_BOLD = "bold";
@@ -56,11 +59,15 @@ public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
     [Inject]
     private AIJobService AIJobService { get; init; } = null!;
 
+    [Inject]
+    private MediaTranscriptionService MediaTranscriptionService { get; init; } = null!;
+
     private const Placement TOOLBAR_TOOLTIP_PLACEMENT = Placement.Top;
     private static readonly Dictionary<string, object?> USER_INPUT_ATTRIBUTES = new();
 
     private DataSourceSelection? dataSourceSelectionComponent;
     private DataSourceOptions earlyDataSourceOptions = new();
+    private DataSourceOptions lastAppliedStandardDataSourceOptions = new();
     private Profile currentProfile = Profile.NO_PROFILE;
     private ChatTemplate currentChatTemplate = ChatTemplate.NO_CHAT_TEMPLATE;
     private bool hasUnsavedChanges;
@@ -88,6 +95,8 @@ public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
         ? $"{this.T("Estimated amount of tokens:")} {this.tokenCount}"
         : string.Empty;
 
+    private MediaImportOwner CurrentMediaImportOwner => MediaImportOwner.ForChat(this.ChatThread?.ChatId ?? this.draftMediaOwnerId);
+
     // Unfortunately, we need the input field reference to blur the focus away. Without
     // this, we cannot clear the input field.
     private UserPromptComponent<string> inputField = null!;
@@ -111,6 +120,8 @@ public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
 
     protected override async Task OnInitializedAsync()
     {
+        this.MediaTranscriptionService.StateChanged += this.OnMediaImportStateChanged;
+        
         // Apply the filters for the message bus:
         this.ApplyFilters([], [ Event.HAS_CHAT_UNSAVED_CHANGES, Event.RESET_CHAT_STATE, Event.CHAT_STREAMING_DONE, Event.AI_JOB_CHANGED, Event.AI_JOB_FINISHED, Event.CHAT_GENERATION_CHANGED, Event.WORKSPACE_RENAMED, Event.CONFIGURATION_CHANGED ]);
         
@@ -126,6 +137,8 @@ public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
         if (!this.ComposerState.HasUserDraft && !this.ComposerState.HasComposerContent)
             this.ComposerState.ApplyTemplate(this.currentChatTemplate);
 
+        this.lastAppliedStandardDataSourceOptions = this.SettingsManager.ConfigurationData.Chat.PreselectedDataSourceOptions.CreateCopy();
+
         var deferredInput = MessageBus.INSTANCE.CheckDeferredMessages<string>(Event.SEND_TO_CHAT_INPUT).FirstOrDefault();
         if (!string.IsNullOrWhiteSpace(deferredInput))
             this.ComposerState.SetUserInput(deferredInput);
@@ -248,9 +261,50 @@ public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
         // Select the correct provider:
         await this.SelectProviderWhenLoadingChat();
         await this.SyncForegroundChatAsync();
+        await this.ConsumeMediaOutcomeAsync();
         await base.OnInitializedAsync();
     }
 
+    /// <summary>Refreshes send and attachment controls when the media import lane changes.</summary>
+    private void OnMediaImportStateChanged(MediaImportOwner owner)
+    {
+        if (owner == this.CurrentMediaImportOwner)
+            _ = this.InvokeAsync(async () =>
+            {
+                await this.ConsumeMediaOutcomeAsync();
+                this.StateHasChanged();
+            });
+    }
+
+    /// <summary>Consumes a terminal media notification when its chat is visible.</summary>
+    private async Task ConsumeMediaOutcomeAsync()
+    {
+        var outcome = this.MediaTranscriptionService.TryConsumeOutcome(this.CurrentMediaImportOwner);
+        if (outcome is null)
+            return;
+
+        if (outcome.Failures.Count > 0)
+        {
+            var message = string.Join(Environment.NewLine, outcome.Failures.Select(failure => $"{failure.FileName}: {failure.UserMessage}"));
+            await this.MessageBus.SendError(new(Icons.Material.Filled.VoiceChat, message));
+        }
+        else if (outcome.Status is MediaImportStatus.FAILED)
+        {
+            await this.MessageBus.SendError(new(Icons.Material.Filled.VoiceChat, this.T("The media file could not be transcribed.")));
+        }
+
+        if (outcome.Warnings.Count > 0)
+        {
+            var message = string.Join(Environment.NewLine, outcome.Warnings.Select(warning => $"{warning.FileName}: {warning.UserMessage}"));
+            await this.MessageBus.SendWarning(new(Icons.Material.Filled.VoiceChat, message));
+        }
+
+        if (outcome.Status is MediaImportStatus.CANCELLED)
+        {
+            await this.MessageBus.SendWarning(new(Icons.Material.Filled.VoiceChat, this.T("The media transcription was canceled.")));
+        }
+    }
+
     protected override async Task OnAfterRenderAsync(bool firstRender)
     {
         if (firstRender && this.ChatThread is not null && this.mustStoreChat)
@@ -326,6 +380,7 @@ public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
         if (providerChanged && this.HasCustomTokenizer && this.inputField is not null)
             await this.CalculateTokenCount();
 
+        await this.ConsumeMediaOutcomeAsync();
         await base.OnParametersSetAsync();
     }
 
@@ -473,12 +528,42 @@ public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
     private void ApplyStandardDataSourceOptions()
     {
         var chatDefaultOptions = this.SettingsManager.ConfigurationData.Chat.PreselectedDataSourceOptions.CreateCopy();
+        this.lastAppliedStandardDataSourceOptions = chatDefaultOptions.CreateCopy();
         this.earlyDataSourceOptions = chatDefaultOptions;
         if(this.ChatThread is not null)
             this.ChatThread.DataSourceOptions = chatDefaultOptions;
         
         this.dataSourceSelectionComponent?.ChangeOptionWithoutSaving(chatDefaultOptions);
     }
+
+    private async Task ApplyUpdatedStandardDataSourceOptionsAfterConfigurationChange()
+    {
+        var updatedStandardOptions = this.SettingsManager.ConfigurationData.Chat.PreselectedDataSourceOptions.CreateCopy();
+        var previousStandardOptions = this.lastAppliedStandardDataSourceOptions;
+        this.lastAppliedStandardDataSourceOptions = updatedStandardOptions.CreateCopy();
+
+        if (this.ChatThread is null)
+        {
+            this.earlyDataSourceOptions = updatedStandardOptions;
+            this.dataSourceSelectionComponent?.ChangeOptionWithoutSaving(updatedStandardOptions);
+            return;
+        }
+
+        if (!DataSourceOptionsAreEqual(this.ChatThread.DataSourceOptions, previousStandardOptions))
+            return;
+
+        await this.SetCurrentDataSourceOptions(updatedStandardOptions);
+        this.dataSourceSelectionComponent?.ChangeOptionWithoutSaving(updatedStandardOptions, this.ChatThread.AISelectedDataSources);
+        await this.ChatThreadChanged.InvokeAsync(this.ChatThread);
+    }
+
+    private static bool DataSourceOptionsAreEqual(DataSourceOptions left, DataSourceOptions right)
+    {
+        return left.DisableDataSources == right.DisableDataSources
+               && left.AutomaticDataSourceSelection == right.AutomaticDataSourceSelection
+               && left.AutomaticValidation == right.AutomaticValidation
+               && left.PreselectedDataSourceIds.ToHashSet(StringComparer.Ordinal).SetEquals(right.PreselectedDataSourceIds);
+    }
     
     private string ExtractThreadName(string firstUserInput)
     {
@@ -562,6 +647,8 @@ public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
 
         if (!this.ComposerState.HasUserDraft && previousChatTemplate != this.currentChatTemplate)
             this.ComposerState.ApplyTemplate(this.currentChatTemplate);
+
+        await this.ApplyUpdatedStandardDataSourceOptionsAfterConfigurationChange();
     }
 
     private IReadOnlyList<DataSourceAgentSelected> GetAgentSelectedDataSources()
@@ -663,9 +750,43 @@ public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
         this.ComposerState.MarkUserDraft();
         this.hasUnsavedChanges = true;
     }
+
+    /// <summary>Creates and stores a stable draft immediately after media import confirmation.</summary>
+    private async Task<ChatThread?> EnsureMediaImportChatAsync(string firstMediaPath)
+    {
+        if (this.ChatThread is not null)
+            return this.ChatThread;
+
+        this.RefreshCurrentProfileAndChatTemplate();
+        var promptName = this.ExtractThreadName(this.ComposerState.UserInput);
+        this.ChatThread = new()
+        {
+            IncludeDateTime = true,
+            SelectedProvider = this.Provider.Id,
+            SelectedProfile = this.currentProfile.Id,
+            SelectedChatTemplate = this.currentChatTemplate.Id,
+            SystemPrompt = SystemPrompts.DEFAULT,
+            WorkspaceId = this.currentWorkspaceId,
+            ChatId = Guid.NewGuid(),
+            DataSourceOptions = this.earlyDataSourceOptions,
+            Name = string.IsNullOrWhiteSpace(this.ComposerState.UserInput)
+                ? $"Transkription: {Path.GetFileName(firstMediaPath)}"
+                : promptName,
+            Blocks = this.currentChatTemplate == ChatTemplate.NO_CHAT_TEMPLATE ? [] : this.currentChatTemplate.ExampleConversation.Select(block => block.DeepClone()).ToList(),
+        };
+
+        await WorkspaceBehaviour.StoreChatAsync(this.ChatThread);
+        this.MarkCurrentChatAsLoadedParameter();
+        await this.ChatThreadChanged.InvokeAsync(this.ChatThread);
+        await this.SyncForegroundChatAsync();
+        return this.ChatThread;
+    }
     
     private async Task SendMessage(bool reuseLastUserPrompt = false)
     {
+        if (this.MediaTranscriptionService.IsBusy(this.CurrentMediaImportOwner))
+            return;
+
         if (!this.IsProviderSelected)
             return;
         
@@ -728,6 +849,7 @@ public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
                 Text = this.ComposerState.UserInput,
                 FileAttachments = normalizedAttachments,
             };
+            this.ChatThread.PendingMediaTranscripts.Clear();
 
             //
             // Add the user message to the thread:
@@ -970,12 +1092,8 @@ public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
         if (workspaceId == Guid.Empty)
             return;
         
-        // Delete the chat from the current workspace or the temporary storage:
-        await WorkspaceBehaviour.DeleteChatAsync(this.DialogService, this.ChatThread!.WorkspaceId, this.ChatThread.ChatId, askForConfirmation: false);
-        
-        this.ChatThread!.WorkspaceId = workspaceId;
+        await WorkspaceBehaviour.MoveChatAsync(this.ChatThread!, workspaceId);
         this.MarkCurrentChatAsLoadedParameter();
-        await this.SaveThread();
 
         await this.SyncWorkspaceHeaderWithChatThreadAsync();
     }
@@ -1224,6 +1342,7 @@ public partial class ChatComponent : MSGComponentBase, IAsyncDisposable
 
     public async ValueTask DisposeAsync()
     {
+        this.MediaTranscriptionService.StateChanged -= this.OnMediaImportStateChanged;
         if(this.SettingsManager.ConfigurationData.Workspace.StorageBehavior is WorkspaceStorageBehavior.STORE_CHATS_AUTOMATICALLY)
         {
             await this.SaveThread();

app/MindWork AI Studio/Components/CodeEditor.razor

@@ -0,0 +1,4 @@
+<div class="code-editor @this.Class" style="@this.CodeEditorThemeStyle">
+    <div @ref="this.lineNumbersElement" class="code-editor-line-numbers" aria-hidden="true"></div>
+    <div @ref="this.editorElement" class="code-editor-input"></div>
+</div>

app/MindWork AI Studio/Components/CodeEditor.razor.cs

@@ -0,0 +1,104 @@
+using Microsoft.AspNetCore.Components;
+
+namespace AIStudio.Components;
+
+public partial class CodeEditor : ComponentBase, IAsyncDisposable
+{
+    private static readonly CodeEditorTheme DARK_CODE_EDITOR_THEME = new("#191a1c", "#bdbdbd", "#404040", "#85c46c", "#c9a26d", "#ed94c0", "#6c95eb", "#39cc9b", "#66c3cc");
+    private static readonly CodeEditorTheme LIGHT_CODE_EDITOR_THEME = new("#fefcf6", "#383838", "#d8d8d8", "#248700", "#8c6c41", "#ab2f6b", "#0f54d6", "#00855f", "#0093a1");
+
+    [Inject]
+    private IJSRuntime JsRuntime { get; set; } = null!;
+
+    [Inject]
+    private global::AIStudio.Settings.SettingsManager SettingsManager { get; init; } = null!;
+
+    [Parameter]
+    public string Value { get; set; } = string.Empty;
+
+    [Parameter]
+    public CodeEditorLanguage Language { get; set; } = CodeEditorLanguage.PLAIN_TEXT;
+
+    [Parameter] 
+    public string Class { get; set; } = string.Empty;
+
+    private readonly string editorId = $"code-editor-{Guid.NewGuid():N}";
+    private const string CODE_EDITOR_MODULE = "./system/CodeEditor/code-editor.js?v=20260713-1";
+    private ElementReference editorElement;
+    private ElementReference lineNumbersElement;
+    private IJSObjectReference? module;
+    private string CodeEditorThemeStyle => this.GetCodeEditorThemeStyle();
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (!firstRender)
+            return;
+        
+        this.module = await this.JsRuntime.InvokeAsync<IJSObjectReference>("import", CODE_EDITOR_MODULE);
+        await this.module.InvokeVoidAsync("init", this.editorId, this.editorElement, this.lineNumbersElement, this.Value, this.Language.ToString());
+    }
+
+    public async ValueTask<string> GetCodeAsync()
+    {
+        if (this.module is null)
+            return this.Value;
+
+        return await this.module.InvokeAsync<string>("getCode", this.editorId);
+    }
+
+    public async ValueTask SetCodeAsync(string code)
+    {
+        this.Value = code;
+        if (this.module is null)
+            return;
+
+        await this.module.InvokeVoidAsync("setCode", this.editorId, code);
+    }
+
+    private string GetCodeEditorThemeStyle()
+    {
+        var codeEditorTheme = this.SettingsManager.IsDarkMode ? DARK_CODE_EDITOR_THEME : LIGHT_CODE_EDITOR_THEME;
+
+        return
+            $"--mw-code-editor-background: {codeEditorTheme.Background}; " +
+            $"--mw-code-editor-foreground: {codeEditorTheme.Foreground}; " +
+            $"--mw-code-editor-border: {codeEditorTheme.Border}; " +
+            $"--mw-code-editor-comment: {codeEditorTheme.Comment}; " +
+            $"--mw-code-editor-string: {codeEditorTheme.String}; " +
+            $"--mw-code-editor-number: {codeEditorTheme.Number}; " +
+            $"--mw-code-editor-keyword: {codeEditorTheme.Keyword}; " +
+            $"--mw-code-editor-literal: {codeEditorTheme.Keyword}; " +
+            $"--mw-code-editor-built-in: {codeEditorTheme.Function}; " +
+            $"--mw-code-editor-constant: {codeEditorTheme.Constant}; " +
+            $"--mw-code-editor-function: {codeEditorTheme.Function}; " +
+            $"--mw-code-editor-property: {codeEditorTheme.Function}; " +
+            $"--mw-code-editor-variable: {codeEditorTheme.Foreground};";
+    }
+    
+    public async ValueTask DisposeAsync()
+    {
+        if (this.module is null)
+            return;
+
+        try
+        {
+            await this.module.InvokeVoidAsync("destroy", this.editorId);
+            await this.module.DisposeAsync();
+        }
+        catch (JSDisconnectedException)
+        {
+            // The circuit can already be gone while Blazor disposes the component.
+        }
+    }
+
+    private sealed record CodeEditorTheme(
+        string Background,
+        string Foreground,
+        string Border,
+        string Comment,
+        string String,
+        string Number,
+        string Keyword,
+        string Function,
+        string Constant);
+}

app/MindWork AI Studio/Components/CodeEditorLanguage.cs

@@ -0,0 +1,12 @@
+namespace AIStudio.Components;
+
+/// <summary>
+/// Selects the syntax highlighter used by <see cref="CodeEditor"/>.
+/// The enum value is passed to the JavaScript module as a string, so a new
+/// language must also be handled in <c>wwwroot/system/CodeEditor/code-editor.js</c>.
+/// </summary>
+public enum CodeEditorLanguage
+{
+    PLAIN_TEXT,
+    LUA,
+}

app/MindWork AI Studio/Components/ConfigurationFile.razor

@@ -19,7 +19,7 @@
                Variant="Variant.Outlined"
                Color="Color.Primary"
                Size="Size.Small"
-               Disabled="@this.IsDisabled"
+               Disabled="@(this.IsDisabled || this.isFileDialogOpen)"
                Class="mb-1"
                OnClick="@this.OpenFileDialog">
         @T("Choose File")

app/MindWork AI Studio/Components/ConfigurationFile.razor.cs

@@ -49,6 +49,7 @@ public partial class ConfigurationFile : ConfigurationBaseCore
     private RustService RustService { get; init; } = null!;
 
     private string internalText = string.Empty;
+    private bool isFileDialogOpen;
     private readonly Timer timer = new(TimeSpan.FromMilliseconds(500))
     {
         AutoReset = false
@@ -90,13 +91,24 @@ public partial class ConfigurationFile : ConfigurationBaseCore
 
     private async Task OpenFileDialog()
     {
-        var response = await this.RustService.SelectFile(this.FileDialogTitle, this.Filter, string.IsNullOrWhiteSpace(this.internalText) ? null : this.internalText);
-        if (response.UserCancelled)
+        if (this.isFileDialogOpen)
             return;
 
-        this.timer.Stop();
-        this.internalText = response.SelectedFilePath;
-        await this.OptionChanged(response.SelectedFilePath);
+        this.isFileDialogOpen = true;
+        try
+        {
+            var response = await this.RustService.SelectFile(this.FileDialogTitle, this.Filter, string.IsNullOrWhiteSpace(this.internalText) ? null : this.internalText);
+            if (response.UserCancelled)
+                return;
+
+            this.timer.Stop();
+            this.internalText = response.SelectedFilePath;
+            await this.OptionChanged(response.SelectedFilePath);
+        }
+        finally
+        {
+            this.isFileDialogOpen = false;
+        }
     }
 
     private async Task OptionChanged(string updatedText)

app/MindWork AI Studio/Components/ConfigurationShortcut.razor.cs

@@ -15,7 +15,7 @@ public partial class ConfigurationShortcut : ConfigurationBaseCore
     private IDialogService DialogService { get; init; } = null!;
 
     [Inject]
-    private RustService RustService { get; init; } = null!;
+    private GlobalShortcutService GlobalShortcutService { get; init; } = null!;
 
     /// <summary>
     /// The shortcut binding data.
@@ -69,7 +69,7 @@ public partial class ConfigurationShortcut : ConfigurationBaseCore
     {
         // Suspend shortcut processing while the dialog is open, so the user can
         // press the current shortcut to re-enter it without triggering the action:
-        await this.RustService.SuspendShortcutProcessing();
+        await this.GlobalShortcutService.SuspendShortcutProcessing();
         
         try
         {
@@ -106,7 +106,7 @@ public partial class ConfigurationShortcut : ConfigurationBaseCore
         finally
         {
             // Resume the shortcut processing when the dialog is closed:
-            await this.RustService.ResumeShortcutProcessing();
+            await this.GlobalShortcutService.ResumeShortcutProcessing();
         }
     }
 }

app/MindWork AI Studio/Components/DataSourceSelection.razor

@@ -160,13 +160,13 @@ else if (this.SelectionMode is DataSourceSelectionMode.CONFIGURATION_MODE)
             </MudText>
         }
 
-        <MudTextSwitch Label="@T("Are data sources enabled?")" Value="@this.areDataSourcesEnabled" LabelOn="@T("Yes, I want to use data sources.")" LabelOff="@T("No, I don't want to use data sources.")" ValueChanged="@this.EnabledChanged"/>
+        <MudTextSwitch Label="@T("Are data sources enabled?")" Value="@this.areDataSourcesEnabled" LabelOn="@T("Yes, I want to use data sources.")" LabelOff="@T("No, I don't want to use data sources.")" ValueChanged="@this.EnabledChanged" Disabled="@this.IsPreselectedDataSourcesDisabledLocked()"/>
         @if (this.areDataSourcesEnabled)
         {
-            <MudTextSwitch Label="@T("AI-based data source selection")" Value="@this.aiBasedSourceSelection" LabelOn="@T("Yes, let the AI decide which data sources are needed.")" LabelOff="@T("No, I manually decide which data source to use.")" ValueChanged="@this.AutoModeChanged"/>
-            <MudTextSwitch Label="@T("AI-based data validation")" Value="@this.aiBasedValidation" LabelOn="@T("Yes, let the AI validate & filter the retrieved data.")" LabelOff="@T("No, use all data retrieved from the data sources.")" ValueChanged="@this.ValidationModeChanged"/>
-            <MudField Label="@T("Available Data Sources")" Variant="Variant.Outlined" Class="mb-3" Disabled="@this.aiBasedSourceSelection">
-                <MudList T="IDataSource" SelectionMode="@this.GetListSelectionMode()" @bind-SelectedValues:get="@this.selectedDataSources" @bind-SelectedValues:set="@(x => this.SelectionChanged(x))">
+            <MudTextSwitch Label="@T("AI-based data source selection")" Value="@this.aiBasedSourceSelection" LabelOn="@T("Yes, let the AI decide which data sources are needed.")" LabelOff="@T("No, I manually decide which data source to use.")" ValueChanged="@this.AutoModeChanged" Disabled="@this.IsPreselectedDataSourcesAutomaticSelectionLocked()"/>
+            <MudTextSwitch Label="@T("AI-based data validation")" Value="@this.aiBasedValidation" LabelOn="@T("Yes, let the AI validate & filter the retrieved data.")" LabelOff="@T("No, use all data retrieved from the data sources.")" ValueChanged="@this.ValidationModeChanged" Disabled="@this.IsPreselectedDataSourcesAutomaticValidationLocked()"/>
+            <MudField Label="@T("Available Data Sources")" Variant="Variant.Outlined" Class="mb-3" Disabled="@(this.aiBasedSourceSelection || this.IsPreselectedDataSourceIdsLocked())">
+                <MudList T="IDataSource" SelectionMode="@this.GetListSelectionMode()" @bind-SelectedValues:get="@this.selectedDataSources" @bind-SelectedValues:set="@(x => this.SelectionChanged(x))" ReadOnly="@this.IsPreselectedDataSourceIdsLocked()">
                     @foreach (var source in this.availableDataSources)
                     {
                         <MudListItem Value="@source">

app/MindWork AI Studio/Components/DataSourceSelection.razor.cs

@@ -52,6 +52,7 @@ public partial class DataSourceSelection : MSGComponentBase
     private bool aiBasedSourceSelection;
     private bool aiBasedValidation;
     private bool areDataSourcesEnabled;
+    private uint loadAndApplyFiltersGeneration;
     
     #region Overrides of ComponentBase
 
@@ -75,15 +76,7 @@ public partial class DataSourceSelection : MSGComponentBase
         // Right before the preselection would be used to kick off the
         // RAG process, we will filter the data sources as well.
         //
-        var preselectedSources = new List<IDataSource>(this.DataSourceOptions.PreselectedDataSourceIds.Count);
-        foreach (var preselectedDataSourceId in this.DataSourceOptions.PreselectedDataSourceIds)
-        {
-            var dataSource = this.SettingsManager.ConfigurationData.DataSources.FirstOrDefault(ds => ds.Id == preselectedDataSourceId);
-            if (dataSource is not null)
-                preselectedSources.Add(dataSource);
-        }
-        
-        this.selectedDataSources = preselectedSources;
+        this.selectedDataSources = this.GetDataSourcesFromConfiguredIds();
         await base.OnInitializedAsync();
     }
 
@@ -94,6 +87,7 @@ public partial class DataSourceSelection : MSGComponentBase
             this.aiBasedSourceSelection = this.DataSourceOptions.AutomaticDataSourceSelection;
             this.aiBasedValidation = this.DataSourceOptions.AutomaticValidation;
             this.areDataSourcesEnabled = !this.DataSourceOptions.DisableDataSources;
+            this.selectedDataSources = this.GetDataSourcesFromConfiguredIds();
         }
 
         switch (this.SelectionMode)
@@ -119,7 +113,7 @@ public partial class DataSourceSelection : MSGComponentBase
             // In configuration mode, we have to load all data sources:
             //
             case DataSourceSelectionMode.CONFIGURATION_MODE:
-                this.availableDataSources = this.SettingsManager.ConfigurationData.DataSources;
+                this.availableDataSources = this.GetConfiguredDataSourcesSnapshot();
                 break;
         }
         
@@ -156,7 +150,7 @@ public partial class DataSourceSelection : MSGComponentBase
         this.aiBasedSourceSelection = this.DataSourceOptions.AutomaticDataSourceSelection;
         this.aiBasedValidation = this.DataSourceOptions.AutomaticValidation;
         this.areDataSourcesEnabled = !this.DataSourceOptions.DisableDataSources;
-        this.selectedDataSources = this.SettingsManager.ConfigurationData.DataSources.Where(ds => this.DataSourceOptions.PreselectedDataSourceIds.Contains(ds.Id)).ToList();
+        this.selectedDataSources = this.GetDataSourcesFromConfiguredIds();
         this.waitingForDataSources = false;
 
         //
@@ -176,20 +170,38 @@ public partial class DataSourceSelection : MSGComponentBase
         this.showDataSourceSelection = false;
         this.StateHasChanged();
     }
+
+    private IReadOnlyList<IDataSource> GetConfiguredDataSourcesSnapshot() => this.SettingsManager.ConfigurationData.DataSources.ToList();
+
+    private IReadOnlyCollection<IDataSource> GetDataSourcesFromConfiguredIds()
+    {
+        var preselectedDataSourceIds = this.DataSourceOptions.PreselectedDataSourceIds.ToHashSet(StringComparer.Ordinal);
+        return this.GetConfiguredDataSourcesSnapshot().Where(ds => preselectedDataSourceIds.Contains(ds.Id)).ToList();
+    }
     
     private async Task LoadAndApplyFilters()
     {
         if(this.DataSourceOptions.DisableDataSources)
+        {
+            this.loadAndApplyFiltersGeneration++;
             return;
+        }
 
         if(this.SelectionMode is DataSourceSelectionMode.CONFIGURATION_MODE)
+        {
+            this.loadAndApplyFiltersGeneration++;
             return;
+        }
 
+        var generation = ++this.loadAndApplyFiltersGeneration;
         this.waitingForDataSources = true;
         this.StateHasChanged();
             
         // Load the data sources:
         var sources = await this.DataSourceService.GetDataSources(this.LLMProvider, this.selectedDataSources);
+        if (generation != this.loadAndApplyFiltersGeneration)
+            return;
+
         this.availableDataSources = sources.AllowedDataSources;
         this.selectedDataSources = sources.SelectedDataSources;
         this.waitingForDataSources = false;
@@ -230,9 +242,38 @@ public partial class DataSourceSelection : MSGComponentBase
         await this.OptionsChanged();
     }
 
+    private bool IsPreselectedDataSourcesDisabledLocked()
+    {
+        return this.SelectionMode is DataSourceSelectionMode.CONFIGURATION_MODE
+               && ManagedConfiguration.TryGet(x => x.Chat, x => x.PreselectedDataSourcesDisabled, out var meta)
+               && meta.IsLocked;
+    }
+
+    private bool IsPreselectedDataSourcesAutomaticSelectionLocked()
+    {
+        return this.SelectionMode is DataSourceSelectionMode.CONFIGURATION_MODE
+               && ManagedConfiguration.TryGet(x => x.Chat, x => x.PreselectedDataSourcesAutomaticSelection, out var meta)
+               && meta.IsLocked;
+    }
+
+    private bool IsPreselectedDataSourcesAutomaticValidationLocked()
+    {
+        return this.SelectionMode is DataSourceSelectionMode.CONFIGURATION_MODE
+               && ManagedConfiguration.TryGet(x => x.Chat, x => x.PreselectedDataSourcesAutomaticValidation, out var meta)
+               && meta.IsLocked;
+    }
+
+    private bool IsPreselectedDataSourceIdsLocked()
+    {
+        return this.SelectionMode is DataSourceSelectionMode.CONFIGURATION_MODE
+               && ManagedConfiguration.TryGet(x => x.Chat, x => x.PreselectedDataSourceIds, out var meta)
+               && meta.IsLocked;
+    }
+
     private async Task OptionsChanged()
     {
         this.internalChange = true;
+        this.loadAndApplyFiltersGeneration++;
         
         await this.DataSourceOptionsChanged.InvokeAsync(this.DataSourceOptions);
         

app/MindWork AI Studio/Components/EnumSelection.razor

@@ -2,7 +2,7 @@
 @inherits EnumSelectionBase
 
 <MudStack Row="@true" Class="mb-3">
-    <MudSelect T="@T" Value="@this.Value" ValueChanged="@this.SelectionChanged" AdornmentIcon="@this.Icon" Adornment="Adornment.Start" Label="@this.Label" Variant="Variant.Outlined" Margin="Margin.Dense" Validation="@this.ValidateSelection">
+    <MudSelect T="@T" Value="@this.Value" ValueChanged="@this.SelectionChanged" AdornmentIcon="@this.Icon" Adornment="Adornment.Start" IconSize="@this.IconSize" Label="@this.Label" Variant="Variant.Outlined" Margin="Margin.Dense" Validation="@this.ValidateSelection" Disabled="@this.Disabled">
         @foreach (var value in Enum.GetValues<T>())
         {
             <MudSelectItem Value="@value">
@@ -12,6 +12,6 @@
     </MudSelect>
     @if (this.AllowOther && this.Value.Equals(this.OtherValue))
     {
-        <MudTextField T="string" Text="@this.OtherInput" TextChanged="this.OtherValueChanged" Validation="@this.ValidateOther" Label="@this.LabelOther" Variant="Variant.Outlined" Margin="Margin.Dense" UserAttributes="@USER_INPUT_ATTRIBUTES" Immediate="@true"/>
+        <MudTextField T="string" Text="@this.OtherInput" TextChanged="this.OtherValueChanged" Validation="@this.ValidateOther" Label="@this.LabelOther" Variant="Variant.Outlined" Margin="Margin.Dense" UserAttributes="@USER_INPUT_ATTRIBUTES" Immediate="@true" Disabled="@this.Disabled"/>
     }
-</MudStack>
+</MudStack>

app/MindWork AI Studio/Components/EnumSelection.razor.cs

@@ -38,6 +38,15 @@ public partial class EnumSelection<T> : EnumSelectionBase where T : struct, Enum
     
     [Parameter]
     public string Icon { get; set; } = Icons.Material.Filled.ArrowDropDown;
+
+    /// <summary>
+    /// Gets or sets whether the selection controls are disabled.
+    /// </summary>
+    [Parameter]
+    public bool Disabled { get; set; }
+    
+    [Parameter]
+    public Size IconSize { get; set; } = Size.Medium;
     
     /// <summary>
     /// Gets or sets the custom name function for selecting the display name of an enum value.

app/MindWork AI Studio/Components/MediaTranscriptionStatus.razor

@@ -0,0 +1,34 @@
+@inherits MSGComponentBase
+@inject MediaTranscriptionService MediaTranscriptionService
+@using AIStudio.Tools.Services
+
+@if (this.Snapshot is { IsBusy: true } snapshot)
+{
+    @if (this.Compact)
+    {
+        <MudStack Row="true" AlignItems="AlignItems.Center" Class="pa-1">
+            <MudProgressCircular Size="Size.Small" Indeterminate="@(snapshot.Progress is null)" Value="@((snapshot.Progress ?? 0) * 100)"/>
+            <MudText Typo="Typo.body2">
+                @this.StatusText
+            </MudText>
+            <MudTooltip Text="@T("Stop media transcription")">
+                <MudIconButton Size="Size.Small" Icon="@Icons.Material.Filled.Stop" Color="Color.Error" OnClick="@(async () => await this.MediaTranscriptionService.StopAsync(this.Owner))"/>
+            </MudTooltip>
+        </MudStack>
+    }
+    else
+    {
+        <MudPaper Outlined="true" Class="pa-2 mb-2">
+            <MudStack Row="true" AlignItems="AlignItems.Center">
+                <MudProgressCircular Size="Size.Small" Indeterminate="@(snapshot.Progress is null)" Value="@((snapshot.Progress ?? 0) * 100)"/>
+                <MudText Typo="Typo.body2">
+                    @this.StatusText
+                </MudText>
+                <MudSpacer/>
+                <MudTooltip Text="@T("Stop media transcription")">
+                    <MudIconButton Icon="@Icons.Material.Filled.Stop" Color="Color.Error" OnClick="@(async () => await this.MediaTranscriptionService.StopAsync(this.Owner))"/>
+                </MudTooltip>
+            </MudStack>
+        </MudPaper>
+    }
+}

app/MindWork AI Studio/Components/MediaTranscriptionStatus.razor.cs

@@ -0,0 +1,73 @@
+using AIStudio.Tools.Media;
+using Microsoft.AspNetCore.Components;
+
+namespace AIStudio.Components;
+
+public partial class MediaTranscriptionStatus
+{
+    /// <summary>The surface owner whose operation is rendered.</summary>
+    [Parameter]
+    public MediaImportOwner Owner { get; set; }
+
+    /// <summary>Optional target filter used by embedded file controls.</summary>
+    [Parameter]
+    public string TargetId { get; set; } = string.Empty;
+
+    /// <summary>Renders the status without an enclosing paper surface.</summary>
+    [Parameter]
+    public bool Compact { get; set; }
+
+    private MediaImportSnapshot? Snapshot
+    {
+        get
+        {
+            var snapshot = this.MediaTranscriptionService.GetSnapshot(this.Owner);
+            return string.IsNullOrWhiteSpace(this.TargetId) || snapshot?.Target.TargetId == this.TargetId
+                ? snapshot
+                : null;
+        }
+    }
+
+    /// <summary>Gets the localized visible status for the active import.</summary>
+    private string StatusText
+    {
+        get
+        {
+            var snapshot = this.Snapshot;
+            if (snapshot is null)
+                return string.Empty;
+
+            return snapshot.Phase switch
+            {
+                MediaTranscriptionPhase.QUEUED => $"{this.T("Waiting to prepare media")}: {snapshot.CurrentFileName}",
+                MediaTranscriptionPhase.PROBING => $"{this.T("Inspecting media")}: {snapshot.CurrentFileName}",
+                MediaTranscriptionPhase.TRANSCODING => $"{this.T("Preparing audio")}: {snapshot.CurrentFileName}",
+                MediaTranscriptionPhase.UPLOADING => $"{this.T("Transcribing")}: {snapshot.CurrentFileName}",
+                MediaTranscriptionPhase.CANCELING => $"{this.T("Stopping media transcription")}: {snapshot.CurrentFileName}",
+
+                _ => snapshot.CurrentFileName,
+            };
+        }
+    }
+
+    /// <summary>Subscribes to singleton import state changes.</summary>
+    protected override async Task OnInitializedAsync()
+    {
+        this.MediaTranscriptionService.StateChanged += this.OnStateChanged;
+        await base.OnInitializedAsync();
+    }
+
+    /// <summary>Schedules a render after an import state transition.</summary>
+    private void OnStateChanged(MediaImportOwner owner)
+    {
+        if (owner == this.Owner)
+            _ = this.InvokeAsync(this.StateHasChanged);
+    }
+
+    /// <summary>Unsubscribes from singleton import state changes.</summary>
+    protected override void DisposeResources()
+    {
+        this.MediaTranscriptionService.StateChanged -= this.OnStateChanged;
+        base.DisposeResources();
+    }
+}

app/MindWork AI Studio/Components/MudCopyClipboardButton.razor.cs

@@ -38,10 +38,7 @@ public partial class MudCopyClipboardButton : ComponentBase
     /// </summary>
     [Parameter]
     public Size Size { get; set; } = Size.Small;
-    
-    [Inject]
-    private ISnackbar Snackbar { get; init; } = null!;
-    
+
     [Inject]
     private RustService RustService { get; init; } = null!;
     
@@ -58,7 +55,7 @@ public partial class MudCopyClipboardButton : ComponentBase
     /// </summary>
     private async Task CopyToClipboard(string textContent)
     {
-        await this.RustService.CopyText2Clipboard(this.Snackbar, textContent);
+        await this.RustService.CopyText2Clipboard(textContent);
     }
     
     /// <summary>
@@ -73,16 +70,13 @@ public partial class MudCopyClipboardButton : ComponentBase
         {
             case ContentType.TEXT:
                 var textContent = (ContentText) contentToCopy;
-                await this.RustService.CopyText2Clipboard(this.Snackbar, textContent.Text);
+                await this.RustService.CopyText2Clipboard(textContent.Text);
                 break;
             
             default:
-                this.Snackbar.Add(TB("Cannot copy this content type to clipboard."), Severity.Error, config =>
-                {
-                    config.Icon = Icons.Material.Filled.ContentCopy;
-                    config.IconSize = Size.Large;
-                    config.IconColor = Color.Error;
-                });
+                // This component is no MSGComponentBase, so it uses the shared bus instance the same
+                // way FileExtensionValidation does:
+                await MessageBus.INSTANCE.SendError(new(Icons.Material.Filled.ContentCopy, TB("Cannot copy this content type to clipboard.")));
                 break;
         }
     }

app/MindWork AI Studio/Components/MudStepperWithoutActions.razor

@@ -0,0 +1,17 @@
+<MudStepper ActiveIndex="@this.ActiveIndex"
+            ActiveIndexChanged="@this.ActiveIndexChanged"
+            CompletedStepColor="Color.Primary"
+            CurrentStepColor="Color.Primary"
+            ErrorStepColor="Color.Error"
+            NonLinear="@false"
+            ShowResetButton="@false"
+            OnPreviewInteraction="@this.PreviewInteractionAsync"
+            Class="@this.Classname">
+    <ChildContent>
+        @this.ChildContent
+    </ChildContent>
+    @* Empty on purpose: this is what keeps MudBlazor from rendering its Previous, Next, Skip, and
+       Complete buttons. The surrounding action bar still renders and is hidden through app.css. *@
+    <ActionContent Context="_">
+    </ActionContent>
+</MudStepper>

app/MindWork AI Studio/Components/MudStepperWithoutActions.razor.cs

@@ -0,0 +1,70 @@
+using Microsoft.AspNetCore.Components;
+
+namespace AIStudio.Components;
+
+/// <summary>
+/// A stepper that leaves the step navigation to the application instead of the user.
+/// </summary>
+/// <remarks>
+/// MudBlazor renders Previous, Next, Skip, and Complete buttons by default. AI Studio drives its
+/// steppers from application state — a running build, or an install flow that advances when each
+/// step succeeds — so those buttons have nothing to do and would only look broken when clicked.
+/// This component removes them once instead of once per assistant, and carries the shared step
+/// colors so the steppers stay visually consistent.
+/// </remarks>
+public partial class MudStepperWithoutActions : ComponentBase
+{
+    /// <summary>
+    /// Gets or sets the step the stepper points at.
+    /// </summary>
+    [Parameter]
+    public int ActiveIndex { get; set; }
+
+    /// <summary>
+    /// Gets or sets the callback raised when the active step changed.
+    /// </summary>
+    [Parameter]
+    public EventCallback<int> ActiveIndexChanged { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether the user must not change the active step.
+    /// </summary>
+    /// <remarks>
+    /// Set this when the displayed process runs on its own. The step headers stay visible, but
+    /// clicking them no longer moves the stepper away from the step the application selected.
+    /// </remarks>
+    [Parameter]
+    public bool ReadOnly { get; set; }
+
+    /// <summary>
+    /// Gets or sets additional CSS classes for the stepper.
+    /// </summary>
+    [Parameter]
+    public string Class { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the steps to render.
+    /// </summary>
+    [Parameter]
+    public RenderFragment? ChildContent { get; set; }
+
+    /// <summary>
+    /// The marker class that lets app.css hide the action bar MudBlazor renders around the actions.
+    /// </summary>
+    private const string MARKER_CLASS = "mud-stepper-without-actions";
+
+    private string Classname => string.IsNullOrWhiteSpace(this.Class) ? MARKER_CLASS : $"{MARKER_CLASS} {this.Class}";
+
+    /// <summary>
+    /// Blocks step changes that the user triggered while the stepper is read-only.
+    /// </summary>
+    /// <param name="args">The interaction to inspect.</param>
+    /// <returns>A completed task.</returns>
+    private Task PreviewInteractionAsync(StepperInteractionEventArgs args)
+    {
+        if (this.ReadOnly)
+            args.Cancel = true;
+
+        return Task.CompletedTask;
+    }
+}

app/MindWork AI Studio/Components/ProviderSelection.razor

@@ -1,8 +1,23 @@
 @using AIStudio.Settings
 @inherits MSGComponentBase
-<MudSelect T="Provider" Value="@this.ProviderSettings" ValueChanged="@this.SelectionChanged" Validation="@this.ValidateProvider" Adornment="Adornment.Start" AdornmentIcon="@Icons.Material.Filled.Apps" Margin="Margin.Dense" Label="@T("Provider")" Class="mb-3 rounded-lg" OuterClass="flex-grow-0" Variant="Variant.Outlined">
-    @foreach (var provider in this.GetAvailableProviders())
+<MudSelect T="Provider" Value="@this.ProviderSettings" ValueChanged="@this.SelectionChanged" Validation="@this.ValidateProvider" Adornment="Adornment.Start" AdornmentIcon="@Icons.Material.Filled.Apps" Margin="Margin.Dense" Label="@T("Provider")" Class="mb-3 rounded-lg" OuterClass="flex-grow-0" Variant="Variant.Outlined" Disabled="@this.Disabled">
+    @foreach (var providerItem in this.GetAvailableProviderSelectionItems())
     {
-        <MudSelectItem Value="@provider"/>
+        <MudSelectItem Value="@providerItem.Provider">
+            <MudStack Row="true" AlignItems="AlignItems.Center" Justify="Justify.SpaceBetween" Class="w-100" Wrap="Wrap.NoWrap">
+                <MudText Class="me-2">@providerItem.Provider</MudText>
+                @if (providerItem.CapabilityIcons.Count > 0)
+                {
+                    <MudStack Row="true" AlignItems="AlignItems.Center" Spacing="1" Wrap="Wrap.NoWrap" Class="flex-grow-0">
+                        @foreach (var capabilityIcon in providerItem.CapabilityIcons)
+                        {
+                            <MudTooltip Text="@capabilityIcon.Tooltip">
+                                <MudIcon Icon="@capabilityIcon.Icon" Size="Size.Small" Color="Color.Default" />
+                            </MudTooltip>
+                        }
+                    </MudStack>
+                }
+            </MudStack>
+        </MudSelectItem>
     }
 </MudSelect>

app/MindWork AI Studio/Components/ProviderSelection.razor.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 
 using AIStudio.Provider;
+using AIStudio.Settings;
 
 using Microsoft.AspNetCore.Components;
 
@@ -20,6 +21,12 @@ public partial class ProviderSelection : MSGComponentBase
     [Parameter]
     public Func<AIStudio.Settings.Provider, string?> ValidateProvider { get; set; } = _ => null;
 
+    /// <summary>
+    /// Gets or sets whether provider selection is disabled.
+    /// </summary>
+    [Parameter]
+    public bool Disabled { get; set; }
+
     [Parameter]
     public ConfidenceLevel ExplicitMinimumConfidence { get; set; } = ConfidenceLevel.UNKNOWN;
     
@@ -41,6 +48,40 @@ public partial class ProviderSelection : MSGComponentBase
         this.ProviderSettings = provider;
         await this.ProviderSettingsChanged.InvokeAsync(provider);
     }
+
+    private IEnumerable<ProviderSelectionItem> GetAvailableProviderSelectionItems()
+    {
+        foreach (var provider in this.GetAvailableProviders())
+            yield return new(provider, this.GetCapabilityIcons(provider));
+    }
+
+    private IReadOnlyList<CapabilityIcon> GetCapabilityIcons(AIStudio.Settings.Provider provider)
+    {
+        var capabilities = provider.GetModelCapabilities();
+        List<CapabilityIcon> capabilityIcons = [];
+
+        if (capabilities.Contains(Capability.AUDIO_INPUT))
+            capabilityIcons.Add(new(Icons.Material.Filled.GraphicEq, this.T("Audio input possible")));
+
+        if (capabilities.Contains(Capability.SINGLE_IMAGE_INPUT) || capabilities.Contains(Capability.MULTIPLE_IMAGE_INPUT))
+            capabilityIcons.Add(new(Icons.Material.Filled.Image, this.T("Image input possible")));
+
+        if (capabilities.Contains(Capability.SPEECH_INPUT))
+            capabilityIcons.Add(new(Icons.Material.Filled.Mic, this.T("Speech input possible")));
+
+        var reasoningIndicatorState = provider.GetReasoningIndicatorState();
+        if (reasoningIndicatorState is not ReasoningIndicatorState.NONE)
+            capabilityIcons.Add(new(Icons.Material.Filled.Psychology, this.GetReasoningTooltip(reasoningIndicatorState)));
+
+        return capabilityIcons;
+    }
+
+    private string GetReasoningTooltip(ReasoningIndicatorState reasoningIndicatorState) => reasoningIndicatorState switch
+    {
+        ReasoningIndicatorState.DEFAULT_ON => this.T("Uses reasoning (thinking) by default"),
+        ReasoningIndicatorState.CONFIGURED => this.T("Uses reasoning (thinking) configured by settings"),
+        _ => this.T("Uses reasoning (thinking)"),
+    };
     
     [SuppressMessage("Usage", "MWAIS0001:Direct access to `Providers` is not allowed")]
     private IEnumerable<AIStudio.Settings.Provider> GetAvailableProviders()
@@ -84,4 +125,8 @@ public partial class ProviderSelection : MSGComponentBase
     }
 
     #endregion
+
+    private readonly record struct CapabilityIcon(string Icon, string Tooltip);
+
+    private readonly record struct ProviderSelectionItem(AIStudio.Settings.Provider Provider, IReadOnlyList<CapabilityIcon> CapabilityIcons);
 }

app/MindWork AI Studio/Components/ReadFileContent.razor

@@ -1,11 +1,61 @@
 @inherits MSGComponentBase
-<MudButton StartIcon="@Icons.Material.Filled.Description" OnClick="@(async () => await this.SelectFile())" Variant="Variant.Filled" Class="mb-3" Disabled="@this.Disabled">
-    @if (string.IsNullOrWhiteSpace(this.Text))
-    {
-        @T("Use file content as input")        
-    }
-    else
-    {
-        @this.Text
-    }
-</MudButton>
+
+@if (this.EnableDragDrop)
+{
+    <div @onmouseenter="@this.OnMouseEnter" @onmouseleave="@this.OnMouseLeave">
+        <MudPaper Outlined="true" Class="@this.dragClass">
+            <MudStack Row="true" AlignItems="AlignItems.Center" StretchItems="StretchItems.None" Wrap="Wrap.Wrap">
+                @if (this.ShowAttachedDocumentState && this.hasLoadedFileContent)
+                {
+                    <MudTooltip Text="@this.FileLoadedTooltip()">
+                        <MudBadge Icon="@Icons.Material.Filled.Check" Color="Color.Success" Overlap="true">
+                            <MudButton StartIcon="@Icons.Material.Filled.Description" OnClick="@(async () => await this.SelectFile())" Variant="Variant.Filled" Disabled="@this.IsUnavailable">
+                                @this.ButtonText
+                            </MudButton>
+                        </MudBadge>
+                    </MudTooltip>
+                }
+                else
+                {
+                    <MudButton StartIcon="@Icons.Material.Filled.Description" OnClick="@(async () => await this.SelectFile())" Variant="Variant.Filled" Disabled="@this.IsUnavailable">
+                        @this.ButtonText
+                    </MudButton>
+                }
+                
+                @if (this.IsCurrentTargetBusy)
+                {
+                    <MediaTranscriptionStatus Owner="@this.EffectiveImportOwner" TargetId="@this.EffectiveMediaImportTarget.TargetId" Compact="true"/>
+                }
+                else
+                {
+                    <MudText Typo="Typo.body2">
+                        @T("Drop one file here to load its content.")
+                    </MudText>
+                }
+            </MudStack>
+        </MudPaper>
+    </div>
+}
+else
+{
+    <MudStack Row="true" AlignItems="AlignItems.Center" StretchItems="StretchItems.None" Wrap="Wrap.Wrap" Class="mb-3">
+        @if (this.ShowAttachedDocumentState && this.hasLoadedFileContent)
+        {
+            <MudTooltip Text="@this.FileLoadedTooltip()">
+                <MudBadge Icon="@Icons.Material.Filled.Check" Color="Color.Success" Overlap="true">
+                    <MudButton StartIcon="@Icons.Material.Filled.Description" OnClick="@(async () => await this.SelectFile())" Variant="Variant.Filled" Disabled="@this.IsUnavailable">
+                        @this.ButtonText
+                    </MudButton>
+                </MudBadge>
+            </MudTooltip>
+        }
+        else
+        {
+            <MudButton StartIcon="@Icons.Material.Filled.Description" OnClick="@(async () => await this.SelectFile())" Variant="Variant.Filled" Disabled="@this.IsUnavailable">
+                @this.ButtonText
+            </MudButton>
+        }
+
+        <MediaTranscriptionStatus Owner="@this.EffectiveImportOwner" TargetId="@this.EffectiveMediaImportTarget.TargetId" Compact="true"/>
+    </MudStack>
+}

app/MindWork AI Studio/Components/ReadFileContent.razor.cs

@@ -1,3 +1,6 @@
+using AIStudio.Dialogs;
+using AIStudio.Tools.Media;
+using AIStudio.Tools.Rust;
 using AIStudio.Tools.Services;
 using AIStudio.Tools.Validation;
 
@@ -7,6 +10,14 @@ namespace AIStudio.Components;
 
 public partial class ReadFileContent : MSGComponentBase
 {
+    private readonly MediaImportOwner fallbackMediaImportOwner = new(MediaImportOwnerKind.ASSISTANT, $"read-file-content:{Guid.NewGuid():N}");
+
+    [CascadingParameter]
+    private MediaImportOwner? ImportOwner { get; set; }
+
+    [Parameter]
+    public string MediaImportTargetId { get; set; } = string.Empty;
+
     [Parameter]
     public string Text { get; set; } = string.Empty;
     
@@ -16,8 +27,29 @@ public partial class ReadFileContent : MSGComponentBase
     [Parameter]
     public EventCallback<string> FileContentChanged { get; set; }
 
+    /// <summary>
+    /// If true, the component will display the state of the attached document (if any).
+    /// </summary>
+    [Parameter]
+    public bool ShowAttachedDocumentState { get; set; }
+
     [Parameter]
     public bool Disabled { get; set; }
+
+    [Parameter]
+    public bool EnableDragDrop { get; set; }
+
+    /// <summary>
+    /// On which layer to register the drop area. Higher layers have priority over lower layers.
+    /// </summary>
+    [Parameter]
+    public int Layer { get; set; }
+
+    /// <summary>
+    /// Catch all documents that are hovered over the AI Studio window and not only over the drop zone.
+    /// </summary>
+    [Parameter]
+    public bool CatchAllDocuments { get; set; }
     
     [Inject]
     private RustService RustService { get; init; } = null!;
@@ -30,12 +62,207 @@ public partial class ReadFileContent : MSGComponentBase
 
     [Inject]
     private PandocAvailabilityService PandocAvailabilityService { get; init; } = null!;
+
+    [Inject]
+    private MediaTranscriptionService MediaTranscriptionService { get; init; } = null!;
+
+    private const string DEFAULT_DRAG_CLASS = "relative rounded-lg border-2 border-dashed pa-3 mb-3 mud-width-full";
+
+    private string ButtonText => string.IsNullOrWhiteSpace(this.Text) ? T("Use file content as input") : this.Text;
+    private string dragClass = DEFAULT_DRAG_CLASS;
+    private uint numDropAreasAboveThis;
+    private bool isComponentHovered;
+    private bool isFileDialogOpen;
+    private bool hasLoadedFileContent;
+    private string loadedFileName = string.Empty;
+    
+    private bool IsCurrentTargetBusy => this.MediaTranscriptionService.GetSnapshot(this.EffectiveImportOwner) is { IsBusy: true } snapshot
+                                        && snapshot.Target == this.EffectiveMediaImportTarget;
+    
+    private bool IsUnavailable => this.Disabled || this.isFileDialogOpen || this.MediaTranscriptionService.IsBusy(this.EffectiveImportOwner);
+
+    private MediaImportOwner EffectiveImportOwner => this.ImportOwner ?? this.fallbackMediaImportOwner;
+    
+    private string EffectiveMediaImportTargetId => string.IsNullOrWhiteSpace(this.MediaImportTargetId)
+        ? string.IsNullOrWhiteSpace(this.Text) ? "primary" : this.Text
+        : this.MediaImportTargetId;
+
+    private MediaImportTarget EffectiveMediaImportTarget => new(this.EffectiveImportOwner, this.EffectiveMediaImportTargetId);
+    
+    #region Overrides of MSGComponentBase
+
+    protected override void OnParametersSet()
+    {
+        if (string.IsNullOrWhiteSpace(this.FileContent))
+        {
+            this.hasLoadedFileContent = false;
+            this.loadedFileName = string.Empty;
+        }
+
+        base.OnParametersSet();
+    }
+
+    protected override async Task OnInitializedAsync()
+    {
+        this.MediaTranscriptionService.StateChanged += this.OnMediaImportStateChanged;
+        if (this.EnableDragDrop)
+        {
+            this.ApplyFilters([], [ Event.TAURI_EVENT_RECEIVED, Event.REGISTER_FILE_DROP_AREA, Event.UNREGISTER_FILE_DROP_AREA ]);
+            await this.MessageBus.SendMessage(this, Event.REGISTER_FILE_DROP_AREA, this.Layer);
+        }
+
+        await base.OnInitializedAsync();
+        await this.SyncCompletedMediaTextAsync();
+    }
+
+    /// <summary>Refreshes disabled controls when the shared import lane changes.</summary>
+    private void OnMediaImportStateChanged(MediaImportOwner owner)
+    {
+        if (owner == this.EffectiveImportOwner)
+            _ = this.InvokeAsync(async () =>
+            {
+                await this.SyncCompletedMediaTextAsync();
+                await this.ConsumeStandaloneMediaOutcomeAsync();
+                this.StateHasChanged();
+            });
+    }
+
+    /// <summary>Consumes outcomes for dialog-local controls that have no assistant owner surface.</summary>
+    private async Task ConsumeStandaloneMediaOutcomeAsync()
+    {
+        if (this.ImportOwner is not null)
+            return;
+
+        var outcome = this.MediaTranscriptionService.TryConsumeOutcome(this.EffectiveImportOwner);
+        if (outcome is null)
+            return;
+
+        if (outcome.Failures.Count > 0)
+        {
+            var message = string.Join(Environment.NewLine, outcome.Failures.Select(failure => $"{failure.FileName}: {failure.UserMessage}"));
+            await this.MessageBus.SendError(new(Icons.Material.Filled.VoiceChat, message));
+        }
+        else if (outcome.Status is MediaImportStatus.FAILED)
+        {
+            await this.MessageBus.SendError(new(Icons.Material.Filled.VoiceChat, this.T("The media file could not be transcribed.")));
+        }
+
+        if (outcome.Warnings.Count > 0)
+        {
+            var message = string.Join(Environment.NewLine, outcome.Warnings.Select(warning => $"{warning.FileName}: {warning.UserMessage}"));
+            await this.MessageBus.SendWarning(new(Icons.Material.Filled.VoiceChat, message));
+        }
+
+        if (outcome.Status is MediaImportStatus.CANCELLED)
+        {
+            await this.MessageBus.SendWarning(new(Icons.Material.Filled.VoiceChat, this.T("The media transcription was canceled.")));
+        }
+    }
+
+    /// <summary>Applies a completed target transcript after progress or navigation.</summary>
+    private async Task SyncCompletedMediaTextAsync()
+    {
+        var delivery = this.MediaTranscriptionService.GetPendingDelivery(this.EffectiveMediaImportTarget);
+        if (delivery is null || delivery.Text is not { } text)
+            return;
+
+        var fileName = this.MediaTranscriptionService.GetSnapshot(this.EffectiveImportOwner) is { Target: var target } snapshot
+                       && target == this.EffectiveMediaImportTarget
+            ? snapshot.CurrentFileName
+            : string.Empty;
+        await this.ApplyFileContentAsync(text, fileName);
+        this.MediaTranscriptionService.AcknowledgeDelivery(delivery);
+    }
+
+    /// <summary>Unsubscribes from the singleton media service.</summary>
+    protected override void DisposeResources()
+    {
+        this.MediaTranscriptionService.StateChanged -= this.OnMediaImportStateChanged;
+        base.DisposeResources();
+    }
+
+    protected override async Task ProcessIncomingMessage<T>(ComponentBase? sendingComponent, Event triggeredEvent, T? data) where T : default
+    {
+        if (!this.EnableDragDrop)
+            return;
+
+        if (this.IsUnavailable && triggeredEvent == Event.TAURI_EVENT_RECEIVED)
+            return;
+
+        switch (triggeredEvent)
+        {
+            case Event.REGISTER_FILE_DROP_AREA when sendingComponent != this:
+            {
+                if(data is int layer && layer > this.Layer)
+                {
+                    this.numDropAreasAboveThis++;
+                    this.ClearDragClass();
+                }
+
+                break;
+            }
+
+            case Event.UNREGISTER_FILE_DROP_AREA when sendingComponent != this:
+            {
+                if(data is int layer && layer > this.Layer && this.numDropAreasAboveThis > 0)
+                    this.numDropAreasAboveThis--;
+
+                break;
+            }
+
+            case Event.TAURI_EVENT_RECEIVED when data is TauriEvent { EventType: TauriEventType.FILE_DROP_HOVERED }:
+                if(!this.CanCatchDroppedFile())
+                    return;
+
+                this.SetDragClass();
+                this.StateHasChanged();
+                break;
+
+            case Event.TAURI_EVENT_RECEIVED when data is TauriEvent { EventType: TauriEventType.FILE_DROP_CANCELED }:
+            case Event.TAURI_EVENT_RECEIVED when data is TauriEvent { EventType: TauriEventType.WINDOW_NOT_FOCUSED }:
+                this.isComponentHovered = false;
+                this.ClearDragClass();
+                this.StateHasChanged();
+                break;
+
+            case Event.TAURI_EVENT_RECEIVED when data is TauriEvent { EventType: TauriEventType.FILE_DROP_DROPPED, Payload: var paths }:
+                if(!this.CanCatchDroppedFile())
+                    return;
+
+                await this.LoadFirstValidFile(paths);
+                this.ClearDragClass();
+                this.StateHasChanged();
+                break;
+        }
+    }
+
+    #endregion
     
     private async Task SelectFile()
     {
-        if (this.Disabled)
+        if (this.IsUnavailable)
             return;
 
+        this.isFileDialogOpen = true;
+        try
+        {
+            var selectedFile = await this.RustService.SelectFile(T("Select file to read its content"));
+            if (selectedFile.UserCancelled)
+            {
+                this.Logger.LogInformation("User cancelled the file selection");
+                return;
+            }
+
+            await this.LoadFileIfValid(selectedFile.SelectedFilePath);
+        }
+        finally
+        {
+            this.isFileDialogOpen = false;
+        }
+    }
+
+    private async Task<bool> EnsurePandocAvailability()
+    {
         // Ensure that Pandoc is installed and ready:
         var pandocState = await this.PandocAvailabilityService.EnsureAvailabilityAsync(
             showSuccessMessage: false,
@@ -45,38 +272,144 @@ public partial class ReadFileContent : MSGComponentBase
         if (!pandocState.IsAvailable)
         {
             this.Logger.LogWarning("The user cancelled the Pandoc installation or Pandoc is not available. Aborting file selection.");
-            return;
+            return false;
         }
 
-        var selectedFile = await this.RustService.SelectFile(T("Select file to read its content"));
-        if (selectedFile.UserCancelled)
+        return true;
+    }
+
+    private async Task LoadFirstValidFile(List<string> paths)
+    {
+        var inaccessiblePaths = paths.Where(path => !File.Exists(path)).ToList();
+        if (inaccessiblePaths.Count > 0)
         {
-            this.Logger.LogInformation("User cancelled the file selection");
-            return;
+            this.Logger.LogWarning("Could not access {Count} dropped file(s): {Paths}", inaccessiblePaths.Count, string.Join(", ", inaccessiblePaths));
+            await this.MessageBus.SendWarning(new(
+                Icons.Material.Filled.Warning,
+                this.T("Some dropped files could not be accessed. Please select them with the file chooser instead.")));
         }
 
-        if(!File.Exists(selectedFile.SelectedFilePath))
+        foreach (var path in paths)
         {
-            this.Logger.LogWarning("Selected file does not exist: '{FilePath}'", selectedFile.SelectedFilePath);
-            return;
+            if (await this.LoadFileIfValid(path))
+                return;
+        }
+    }
+
+    private async Task<bool> LoadFileIfValid(string filePath)
+    {
+        if(!File.Exists(filePath))
+        {
+            this.Logger.LogWarning("Selected file does not exist: '{FilePath}'", filePath);
+            return false;
         }
 
-        if (!await FileExtensionValidation.IsExtensionValidWithNotifyAsync(FileExtensionValidation.UseCase.DIRECTLY_LOADING_CONTENT, selectedFile.SelectedFilePath))
+        if (FileTypes.IsAllowedPath(filePath, FileTypes.AUDIO) || FileTypes.IsAllowedPath(filePath, FileTypes.VIDEO))
+            return await this.LoadMediaTranscriptAsync(filePath);
+
+        if (!await this.EnsurePandocAvailability())
+            return false;
+
+        if (!await FileExtensionValidation.IsExtensionValidWithNotifyAsync(FileExtensionValidation.UseCase.DIRECTLY_LOADING_CONTENT, filePath))
         {
-            this.Logger.LogWarning("User attempted to load unsupported file: {FilePath}", selectedFile.SelectedFilePath);
-            return;
+            this.Logger.LogWarning("User attempted to load unsupported file: {FilePath}", filePath);
+            return false;
         }
 
         try
         {
-            var fileContent = await UserFile.LoadFileData(selectedFile.SelectedFilePath, this.RustService, this.DialogService);
-            await this.FileContentChanged.InvokeAsync(fileContent);
-            this.Logger.LogInformation("Successfully loaded file content: {FilePath}", selectedFile.SelectedFilePath);
+            var fileContent = await UserFile.LoadFileData(filePath, this.RustService, this.DialogService);
+            await this.ApplyFileContentAsync(fileContent, filePath);
+            this.Logger.LogInformation("Successfully loaded file content: {FilePath}", filePath);
+            return true;
         }
         catch (Exception ex)
         {
-            this.Logger.LogError(ex, "Failed to load file content: {FilePath}", selectedFile.SelectedFilePath);
+            this.Logger.LogError(ex, "Failed to load file content: {FilePath}", filePath);
             await MessageBus.INSTANCE.SendError(new(Icons.Material.Filled.Error, T("Failed to load file content")));
+            return false;
         }
     }
-}
+
+    private async Task ApplyFileContentAsync(string fileContent, string filePath)
+    {
+        await this.FileContentChanged.InvokeAsync(fileContent);
+        this.loadedFileName = Path.GetFileName(filePath);
+        this.hasLoadedFileContent = true;
+    }
+
+    private async Task<bool> LoadMediaTranscriptAsync(string filePath)
+    {
+        if (string.IsNullOrWhiteSpace(this.SettingsManager.ConfigurationData.App.UseTranscriptionProvider))
+        {
+            await this.MessageBus.SendWarning(new(
+                Icons.Material.Filled.VoiceChat,
+                this.T("Media files require a configured transcription provider. Configure one in the transcription settings.")));
+            return false;
+        }
+
+        var message = this.T("The selected media file will be prepared locally. Its audio will then be uploaded to the configured transcription provider.");
+        var dialogParameters = new DialogParameters<ConfirmDialog>
+        {
+            {
+                x => x.MarkdownBody,
+                $"""
+                 {message}
+
+                 - {Markdown.EscapeInlineText(Path.GetFileName(filePath))}
+                 """
+            },
+        };
+        var dialogReference = await this.DialogService.ShowAsync<ConfirmDialog>(
+            this.T("Transcribe media file"),
+            dialogParameters,
+            Dialogs.DialogOptions.FULLSCREEN);
+
+        var dialogResult = await dialogReference.Result;
+        if (dialogResult is null || dialogResult.Canceled)
+            return false;
+
+        return this.MediaTranscriptionService.TryStartTextImport(
+            filePath,
+            this.EffectiveMediaImportTarget);
+    }
+
+    private string FileLoadedTooltip()
+    {
+        if (!this.hasLoadedFileContent)
+            return string.Empty;
+
+        if (string.IsNullOrWhiteSpace(this.loadedFileName))
+            return this.T("File content loaded");
+
+        return string.Format(this.T("Attached file '{0}'."), this.loadedFileName);
+    }
+
+    private bool CanCatchDroppedFile() => this.numDropAreasAboveThis is 0 && (this.isComponentHovered || this.CatchAllDocuments);
+
+    private void SetDragClass() => this.dragClass = $"{DEFAULT_DRAG_CLASS} mud-border-primary border-2";
+
+    private void ClearDragClass() => this.dragClass = DEFAULT_DRAG_CLASS;
+
+    private void OnMouseEnter(EventArgs _)
+    {
+        if(this.IsUnavailable || this.numDropAreasAboveThis > 0)
+            return;
+
+        this.Logger.LogDebug("Read file content component is hovered.");
+        this.isComponentHovered = true;
+        this.SetDragClass();
+        this.StateHasChanged();
+    }
+
+    private void OnMouseLeave(EventArgs _)
+    {
+        if(this.IsUnavailable)
+            return;
+
+        this.Logger.LogDebug("Read file content component is no longer hovered.");
+        this.isComponentHovered = false;
+        this.ClearDragClass();
+        this.StateHasChanged();
+    }
+}

app/MindWork AI Studio/Components/SelectDirectory.razor

@@ -13,7 +13,7 @@
         Variant="Variant.Outlined"
     />
     
-    <MudButton StartIcon="@Icons.Material.Filled.FolderOpen" Variant="Variant.Outlined" Color="Color.Primary" Disabled="this.Disabled" OnClick="@this.OpenDirectoryDialog">
+    <MudButton StartIcon="@Icons.Material.Filled.FolderOpen" Variant="Variant.Outlined" Color="Color.Primary" Disabled="@(this.Disabled || this.isDirectoryDialogOpen)" OnClick="@this.OpenDirectoryDialog">
         @T("Choose Directory")
     </MudButton>
 </MudStack>

app/MindWork AI Studio/Components/SelectDirectory.razor.cs

@@ -31,6 +31,7 @@ public partial class SelectDirectory : MSGComponentBase
     protected ILogger<SelectDirectory> Logger { get; init; } = null!;
     
     private static readonly Dictionary<string, object?> SPELLCHECK_ATTRIBUTES = new();
+    private bool isDirectoryDialogOpen;
     
     #region Overrides of ComponentBase
 
@@ -51,10 +52,21 @@ public partial class SelectDirectory : MSGComponentBase
 
     private async Task OpenDirectoryDialog()
     {
-        var response = await this.RustService.SelectDirectory(this.DirectoryDialogTitle, string.IsNullOrWhiteSpace(this.Directory) ? null : this.Directory);
-        this.Logger.LogInformation($"The user selected the directory '{response.SelectedDirectory}'.");
+        if (this.isDirectoryDialogOpen)
+            return;
 
-        if (!response.UserCancelled)
-            this.InternalDirectoryChanged(response.SelectedDirectory);
+        this.isDirectoryDialogOpen = true;
+        try
+        {
+            var response = await this.RustService.SelectDirectory(this.DirectoryDialogTitle, string.IsNullOrWhiteSpace(this.Directory) ? null : this.Directory);
+            this.Logger.LogInformation("The user selected the directory '{SelectedDirectory}'.", response.SelectedDirectory);
+
+            if (!response.UserCancelled)
+                this.InternalDirectoryChanged(response.SelectedDirectory);
+        }
+        finally
+        {
+            this.isDirectoryDialogOpen = false;
+        }
     }
 }

app/MindWork AI Studio/Components/SelectFile.razor

@@ -1,42 +1,19 @@
-@inherits MSGComponentBase
+@inherits MSGComponentBase
 
-<style>
-    .select-file-button-wrapper {
-        height: 56px;
-        min-height: 56px;
-        max-height: 56px;
-        display: flex;
-        align-items: center;
-        align-self: flex-start;
-        flex-shrink: 0;
-        margin-top: 8px;
-    }
-</style>
-
-<MudStack Row="@true" Spacing="3" Class="mb-3" StretchItems="StretchItems.None" AlignItems="AlignItems.Start">
+<MudStack Row="@true" Spacing="3" Class="mb-3" StretchItems="StretchItems.None" AlignItems="AlignItems.Center">
     <MudTextField
         T="string"
         Text="@this.File"
         Label="@this.Label"
-        ReadOnly="@(!this.IsClearable)"
+        ReadOnly="@true"
         Validation="@this.Validation"
         Adornment="Adornment.Start"
         AdornmentIcon="@Icons.Material.Filled.AttachFile"
         UserAttributes="@SPELLCHECK_ATTRIBUTES"
         Variant="Variant.Outlined"
-        Clearable="@this.IsClearable"
-        Error="@this.Error"
-        ErrorText="@this.ErrorText"
-        OnClearButtonClick="@this.OnClear"
     />
     
-    <div class="select-file-button-wrapper">
-        <MudButton StartIcon="@Icons.Material.Filled.FolderOpen"
-                   Variant="Variant.Outlined"
-                   Color="Color.Primary"
-                   Disabled="@this.Disabled"
-                   OnClick="@this.OpenFileDialog">
-            @T("Choose File")
-        </MudButton>
-    </div>
-</MudStack>
+    <MudButton StartIcon="@Icons.Material.Filled.FolderOpen" Variant="Variant.Outlined" Color="Color.Primary" Disabled="@(this.Disabled || this.isFileDialogOpen)" OnClick="@this.OpenFileDialog">
+        @T("Choose File")
+    </MudButton>
+</MudStack>

app/MindWork AI Studio/Components/SelectFile.razor.cs

@@ -2,7 +2,6 @@ using AIStudio.Tools.Rust;
 using AIStudio.Tools.Services;
 
 using Microsoft.AspNetCore.Components;
-using Microsoft.AspNetCore.Components.Web;
 
 namespace AIStudio.Components;
 
@@ -28,19 +27,7 @@ public partial class SelectFile : MSGComponentBase
     
     [Parameter]
     public Func<string, string?> Validation { get; set; } = _ => null;
-    
-    [Parameter]
-    public bool IsClearable { get; set; } = false;
-    
-    [Parameter]
-    public bool Error { get; set; } = false;
-    
-    [Parameter]
-    public string ErrorText { get; set; } = string.Empty;
-    
-    [Parameter]
-    public Func<MouseEventArgs, Task> OnClear { get; set; } = _ => Task.CompletedTask;
-    
+
     [Inject]
     public RustService RustService { get; set; } = null!;
     
@@ -48,6 +35,7 @@ public partial class SelectFile : MSGComponentBase
     protected ILogger<SelectFile> Logger { get; init; } = null!;
     
     private static readonly Dictionary<string, object?> SPELLCHECK_ATTRIBUTES = new();
+    private bool isFileDialogOpen;
     
     #region Overrides of ComponentBase
 
@@ -65,13 +53,24 @@ public partial class SelectFile : MSGComponentBase
         this.File = file;
         this.FileChanged.InvokeAsync(file);
     }
-    
+
     private async Task OpenFileDialog()
     {
-        var response = await this.RustService.SelectFile(this.FileDialogTitle, this.Filter, string.IsNullOrWhiteSpace(this.File) ? null : this.File);
-        this.Logger.LogInformation($"The user selected the file '{response.SelectedFilePath}'.");
+        if (this.isFileDialogOpen)
+            return;
 
-        if (!response.UserCancelled)
-            this.InternalFileChanged(response.SelectedFilePath);
+        this.isFileDialogOpen = true;
+        try
+        {
+            var response = await this.RustService.SelectFile(this.FileDialogTitle, this.Filter, string.IsNullOrWhiteSpace(this.File) ? null : this.File);
+            this.Logger.LogInformation("The user selected the file '{SelectedFilePath}'.", response.SelectedFilePath);
+
+            if (!response.UserCancelled)
+                this.InternalFileChanged(response.SelectedFilePath);
+        }
+        finally
+        {
+            this.isFileDialogOpen = false;
+        }
     }
 }

app/MindWork AI Studio/Components/Settings/SettingsPanelAgentDataSourceSelection.razor

@@ -1,3 +1,4 @@
+@using AIStudio.Settings
 @inherits SettingsPanelBase
 
 <ExpansionPanel HeaderIcon="@Icons.Material.Filled.SelectAll" HeaderText="@T("Agent: Data Source Selection Options")">
@@ -5,7 +6,7 @@
         <MudJustifiedText Typo="Typo.body1" Class="mb-3">
             @T("Use Case: this agent is used to select the appropriate data sources for the current prompt.")
         </MudJustifiedText>
-        <ConfigurationOption OptionDescription="@T("Preselect data source selection options?")" LabelOn="@T("Options are preselected")" LabelOff="@T("No options are preselected")" State="@(() => this.SettingsManager.ConfigurationData.AgentDataSourceSelection.PreselectAgentOptions)" StateUpdate="@(updatedState => this.SettingsManager.ConfigurationData.AgentDataSourceSelection.PreselectAgentOptions = updatedState)" OptionHelp="@T("When enabled, you can preselect some agent options. This is might be useful when you prefer an LLM.")"/>
-        <ConfigurationProviderSelection Data="@this.AvailableLLMProvidersFunc()" Disabled="@(() => !this.SettingsManager.ConfigurationData.AgentDataSourceSelection.PreselectAgentOptions)" SelectedValue="@(() => this.SettingsManager.ConfigurationData.AgentDataSourceSelection.PreselectedAgentProvider)" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.AgentDataSourceSelection.PreselectedAgentProvider = selectedValue)"/>
+        <ConfigurationOption OptionDescription="@T("Preselect data source selection options?")" LabelOn="@T("Options are preselected")" LabelOff="@T("No options are preselected")" State="@(() => this.SettingsManager.ConfigurationData.AgentDataSourceSelection.PreselectAgentOptions)" StateUpdate="@(updatedState => this.SettingsManager.ConfigurationData.AgentDataSourceSelection.PreselectAgentOptions = updatedState)" OptionHelp="@T("When enabled, you can preselect some agent options. This is might be useful when you prefer an LLM.")" IsLocked="() => ManagedConfiguration.TryGet(x => x.AgentDataSourceSelection, x => x.PreselectAgentOptions, out var meta) && meta.IsLocked"/>
+        <ConfigurationProviderSelection Data="@this.AvailableLLMProvidersFunc()" Disabled="@(() => !this.SettingsManager.ConfigurationData.AgentDataSourceSelection.PreselectAgentOptions)" SelectedValue="@(() => this.SettingsManager.ConfigurationData.AgentDataSourceSelection.PreselectedAgentProvider)" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.AgentDataSourceSelection.PreselectedAgentProvider = selectedValue)" IsLocked="() => ManagedConfiguration.TryGet(x => x.AgentDataSourceSelection, x => x.PreselectedAgentProvider, out var meta) && meta.IsLocked"/>
     </MudPaper>
 </ExpansionPanel>

app/MindWork AI Studio/Components/Settings/SettingsPanelAgentRetrievalContextValidation.razor

@@ -1,16 +1,17 @@
+@using AIStudio.Settings
 @inherits SettingsPanelBase
 
 <ExpansionPanel HeaderIcon="@Icons.Material.Filled.Assessment" HeaderText="@T("Agent: Retrieval Context Validation Options")">
     <MudJustifiedText Typo="Typo.body1" Class="mb-3">
         @T("Use Case: this agent is used to validate any retrieval context of any retrieval process. Perhaps there are many of these retrieval contexts and you want to validate them all. Therefore, you might want to use a cheap and fast LLM for this job. When using a local or self-hosted LLM, look for a small (e.g. 3B) and fast model.")
     </MudJustifiedText>
-    <ConfigurationOption OptionDescription="@T("Enable the retrieval context validation agent?")" LabelOn="@T("The validation agent is enabled")" LabelOff="@T("No validation is performed")" State="@(() => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.EnableRetrievalContextValidation)" StateUpdate="@(updatedState => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.EnableRetrievalContextValidation = updatedState)" OptionHelp="@T("When enabled, the retrieval context validation agent will check each retrieval context of any retrieval process, whether a context makes sense for the given prompt.")"/>
+    <ConfigurationOption OptionDescription="@T("Enable the retrieval context validation agent?")" LabelOn="@T("The validation agent is enabled")" LabelOff="@T("No validation is performed")" State="@(() => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.EnableRetrievalContextValidation)" StateUpdate="@(updatedState => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.EnableRetrievalContextValidation = updatedState)" OptionHelp="@T("When enabled, the retrieval context validation agent will check each retrieval context of any retrieval process, whether a context makes sense for the given prompt.")" IsLocked="() => ManagedConfiguration.TryGet(x => x.AgentRetrievalContextValidation, x => x.EnableRetrievalContextValidation, out var meta) && meta.IsLocked"/>
     @if (this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.EnableRetrievalContextValidation)
     {
         <MudPaper Class="pa-3 mb-8 border-dashed border rounded-lg">
-            <ConfigurationOption OptionDescription="@T("Preselect retrieval context validation options?")" LabelOn="@T("Options are preselected")" LabelOff="@T("No options are preselected")" State="@(() => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.PreselectAgentOptions)" StateUpdate="@(updatedState => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.PreselectAgentOptions = updatedState)" OptionHelp="@T("When enabled, you can preselect some agent options. This is might be useful when you prefer an LLM.")"/>
-            <ConfigurationSlider T="int" OptionDescription="@T("How many validation agents should work simultaneously?")" Min="1" Max="100" Step="1" Unit="@T("agents")" Value="@(() => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.NumParallelValidations)" ValueUpdate="@(updatedValue => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.NumParallelValidations = updatedValue)" OptionHelp="@T("More active agents also mean that a corresponding number of requests are made simultaneously. Some providers limit the number of requests per minute. When you are unsure, choose a low setting between 1 to 6 agents.")"/>
-            <ConfigurationProviderSelection Data="@this.AvailableLLMProvidersFunc()" Disabled="@(() => !this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.PreselectAgentOptions)" SelectedValue="@(() => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.PreselectedAgentProvider)" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.PreselectedAgentProvider = selectedValue)"/>
+            <ConfigurationOption OptionDescription="@T("Preselect retrieval context validation options?")" LabelOn="@T("Options are preselected")" LabelOff="@T("No options are preselected")" State="@(() => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.PreselectAgentOptions)" StateUpdate="@(updatedState => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.PreselectAgentOptions = updatedState)" OptionHelp="@T("When enabled, you can preselect some agent options. This is might be useful when you prefer an LLM.")" IsLocked="() => ManagedConfiguration.TryGet(x => x.AgentRetrievalContextValidation, x => x.PreselectAgentOptions, out var meta) && meta.IsLocked"/>
+            <ConfigurationSlider T="int" OptionDescription="@T("How many validation agents should work simultaneously?")" Min="1" Max="100" Step="1" Unit="@T("agents")" Value="@(() => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.NumParallelValidations)" ValueUpdate="@(updatedValue => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.NumParallelValidations = updatedValue)" OptionHelp="@T("More active agents also mean that a corresponding number of requests are made simultaneously. Some providers limit the number of requests per minute. When you are unsure, choose a low setting between 1 to 6 agents.")" IsLocked="() => ManagedConfiguration.TryGet(x => x.AgentRetrievalContextValidation, x => x.NumParallelValidations, out var meta) && meta.IsLocked"/>
+            <ConfigurationProviderSelection Data="@this.AvailableLLMProvidersFunc()" Disabled="@(() => !this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.PreselectAgentOptions)" SelectedValue="@(() => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.PreselectedAgentProvider)" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.AgentRetrievalContextValidation.PreselectedAgentProvider = selectedValue)" IsLocked="() => ManagedConfiguration.TryGet(x => x.AgentRetrievalContextValidation, x => x.PreselectedAgentProvider, out var meta) && meta.IsLocked"/>
         </MudPaper>
     }
 </ExpansionPanel>

app/MindWork AI Studio/Components/Settings/SettingsPanelApp.razor

@@ -15,8 +15,8 @@
     <ConfigurationOption OptionDescription="@T("Save energy?")" LabelOn="@T("Energy saving is enabled")" LabelOff="@T("Energy saving is disabled")" State="@(() => this.SettingsManager.ConfigurationData.App.IsSavingEnergy)" StateUpdate="@(updatedState => this.SettingsManager.ConfigurationData.App.IsSavingEnergy = updatedState)" OptionHelp="@T("When enabled, streamed content from the AI is updated once every third second. When disabled, streamed content will be updated as soon as it is available.")"/>
     <ConfigurationOption OptionDescription="@T("Enable spellchecking?")" LabelOn="@T("Spellchecking is enabled")" LabelOff="@T("Spellchecking is disabled")" State="@(() => this.SettingsManager.ConfigurationData.App.EnableSpellchecking)" StateUpdate="@(updatedState => this.SettingsManager.ConfigurationData.App.EnableSpellchecking = updatedState)" OptionHelp="@T("When enabled, spellchecking will be active in all input fields. Depending on your operating system, errors may not be visually highlighted, but right-clicking may still offer possible corrections.")"/>
     <ConfigurationSlider T="int" OptionDescription="@T("Request timeout")" Min="@ExternalHttpClientTimeout.MIN_HTTP_CLIENT_TIMEOUT_SECONDS" Max="@ExternalHttpClientTimeout.MAX_HTTP_CLIENT_TIMEOUT_SECONDS" Step="60" Unit="@T("seconds")" Value="@(() => this.SettingsManager.ConfigurationData.App.HttpClientTimeoutSeconds)" ValueUpdate="@(updatedValue => this.SettingsManager.ConfigurationData.App.HttpClientTimeoutSeconds = updatedValue)" OptionHelp="@T("How long AI Studio waits for external HTTP requests, such as AI providers, embeddings, transcription, ERI data sources, and enterprise configuration downloads.")" IsLocked="() => ManagedConfiguration.TryGet(x => x.App, x => x.HttpClientTimeoutSeconds, out var meta) && meta.IsLocked"/>
-    <ConfigurationSelect OptionDescription="@T("Check for updates")" SelectedValue="@(() => this.SettingsManager.ConfigurationData.App.UpdateInterval)" Data="@ConfigurationSelectDataFactory.GetUpdateIntervalData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.App.UpdateInterval = selectedValue)" OptionHelp="@T("How often should we check for app updates?")" IsLocked="() => ManagedConfiguration.TryGet(x => x.App, x => x.UpdateInterval, out var meta) && meta.IsLocked"/>
-    <ConfigurationSelect OptionDescription="@T("Update installation method")" SelectedValue="@(() => this.SettingsManager.ConfigurationData.App.UpdateInstallation)" Data="@ConfigurationSelectDataFactory.GetUpdateBehaviourData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.App.UpdateInstallation = selectedValue)" OptionHelp="@T("Should updates be installed automatically or manually?")" IsLocked="() => ManagedConfiguration.TryGet(x => x.App, x => x.UpdateInstallation, out var meta) && meta.IsLocked"/>
+    <ConfigurationSelect OptionDescription="@T("Check for updates")" SelectedValue="@(() => this.DisplayedUpdateInterval)" Data="@ConfigurationSelectDataFactory.GetManagedUpdateIntervalData(this.DisplayedUpdateInterval)" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.App.UpdateInterval = selectedValue)" OptionHelp="@this.UpdateIntervalHelp" IsLocked="@this.IsUpdateIntervalLocked"/>
+    <ConfigurationSelect OptionDescription="@T("Update installation method")" SelectedValue="@(() => this.DisplayedUpdateInstallation)" Data="@ConfigurationSelectDataFactory.GetUpdateBehaviourData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.App.UpdateInstallation = selectedValue)" OptionHelp="@this.UpdateInstallationHelp" IsLocked="@this.IsUpdateInstallationLocked"/>
     <ConfigurationSelect OptionDescription="@T("Navigation bar behavior")" SelectedValue="@(() => this.SettingsManager.ConfigurationData.App.NavigationBehavior)" Data="@ConfigurationSelectDataFactory.GetNavBehaviorData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.App.NavigationBehavior = selectedValue)" OptionHelp="@T("Select the desired behavior for the navigation bar.")"/>
     <ConfigurationSelect OptionDescription="@T("Start page")" SelectedValue="@(() => this.SettingsManager.ConfigurationData.App.StartPage)" Data="@ConfigurationSelectDataFactory.GetStartPageData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.App.StartPage = selectedValue)" OptionHelp="@this.GetStartPageHelpText()" IsLocked="() => ManagedConfiguration.TryGet(x => x.App, x => x.StartPage, out var meta) && meta.IsLocked"/>
     <ConfigurationOption OptionDescription="@T("Show administration settings?")" LabelOn="@T("Administration settings are visible")" LabelOff="@T("Administration settings are not visible")" State="@(() => this.SettingsManager.ConfigurationData.App.ShowAdminSettings)" StateUpdate="@(updatedState => this.SettingsManager.ConfigurationData.App.ShowAdminSettings = updatedState)" OptionHelp="@T("When enabled, additional administration options become visible. These options are intended for IT staff to manage organization-wide configuration, e.g. configuring and exporting providers for an entire organization.")" IsLocked="() => ManagedConfiguration.TryGet(x => x.App, x => x.ShowAdminSettings, out var meta) && meta.IsLocked"/>

app/MindWork AI Studio/Components/Settings/SettingsPanelApp.razor.cs

@@ -2,11 +2,65 @@ using AIStudio.Provider;
 using AIStudio.Settings;
 using AIStudio.Settings.DataModel;
 using AIStudio.Tools.Rust;
+using AIStudio.Tools.Services;
+
+using Microsoft.AspNetCore.Components;
 
 namespace AIStudio.Components.Settings;
 
 public partial class SettingsPanelApp : SettingsPanelBase
 {
+    [Inject]
+    private UpdatePolicy UpdatePolicy { get; init; } = null!;
+
+    private UpdatePolicyMode updatePolicyMode;
+
+    private UpdateInterval DisplayedUpdateInterval => this.updatePolicyMode is UpdatePolicyMode.FLATPAK
+        ? UpdateInterval.NO_CHECK
+        : this.SettingsManager.ConfigurationData.App.UpdateInterval;
+
+    private UpdateInstallation DisplayedUpdateInstallation => this.updatePolicyMode is UpdatePolicyMode.FLATPAK
+        ? UpdateInstallation.MANUAL
+        : this.SettingsManager.ConfigurationData.App.UpdateInstallation;
+
+    private string UpdateIntervalHelp => this.updatePolicyMode switch
+    {
+        UpdatePolicyMode.ENTERPRISE_DISABLED => T("Your organization has disabled update checks and installations."),
+        UpdatePolicyMode.FLATPAK => T("AI Studio cannot check for updates when running as a Flatpak. Updates are managed outside the app."),
+        _ => T("How often should we check for app updates?")
+    };
+
+    private string UpdateInstallationHelp => this.updatePolicyMode switch
+    {
+        UpdatePolicyMode.ENTERPRISE_DISABLED => T("This setting has no effect while updates are disabled by your organization."),
+        UpdatePolicyMode.FLATPAK => T("AI Studio cannot install updates when running as a Flatpak. Use the update method provided by your Flatpak distribution."),
+        _ => T("Should updates be installed automatically or manually?")
+    };
+
+    private bool IsUpdateIntervalLocked() => this.updatePolicyMode is UpdatePolicyMode.ENTERPRISE_DISABLED or UpdatePolicyMode.FLATPAK ||
+        ManagedConfiguration.TryGet(x => x.App, x => x.UpdateInterval, out var meta) && meta.IsLocked;
+
+    private bool IsUpdateInstallationLocked() => this.updatePolicyMode is UpdatePolicyMode.ENTERPRISE_DISABLED or UpdatePolicyMode.FLATPAK ||
+        ManagedConfiguration.TryGet(x => x.App, x => x.UpdateInstallation, out var meta) && meta.IsLocked;
+
+    protected override async Task OnInitializedAsync()
+    {
+        this.ApplyFilters([], [ Event.CONFIGURATION_CHANGED, Event.GLOBAL_SHORTCUT_CHANGED ]);
+        await base.OnInitializedAsync();
+        this.updatePolicyMode = this.UpdatePolicy.CurrentMode;
+    }
+
+    protected override async Task ProcessIncomingMessage<T>(ComponentBase? sendingComponent, Event triggeredEvent, T? data) where T : default
+    {
+        if (triggeredEvent is Event.CONFIGURATION_CHANGED)
+            this.updatePolicyMode = this.UpdatePolicy.CurrentMode;
+
+        if (triggeredEvent is Event.GLOBAL_SHORTCUT_CHANGED)
+            this.StateHasChanged();
+
+        await base.ProcessIncomingMessage(sendingComponent, triggeredEvent, data);
+    }
+
     private ConfigurationShortcutData VoiceRecordingShortcut => new()
     {
         Id = Shortcut.VOICE_RECORDING_TOGGLE,
@@ -20,7 +74,7 @@ public partial class SettingsPanelApp : SettingsPanelBase
     private async Task GenerateEncryptionSecret()
     {
         var secret = EnterpriseEncryption.GenerateSecret();
-        await this.RustService.CopyText2Clipboard(this.Snackbar, secret);
+        await this.RustService.CopyText2Clipboard(secret);
     }
     
     private string GetStartPageHelpText()
@@ -121,4 +175,4 @@ public partial class SettingsPanelApp : SettingsPanelBase
         this.SettingsManager.ConfigurationData.App.LanguagePluginId = pluginId;
         await this.MessageBus.SendMessage<bool>(this, Event.PLUGINS_RELOADED);
     }
-}
+}

app/MindWork AI Studio/Components/Settings/SettingsPanelBase.cs

@@ -16,6 +16,4 @@ public abstract class SettingsPanelBase : MSGComponentBase
     [Inject]
     protected RustService RustService { get; init; } = null!;
     
-    [Inject]
-    protected ISnackbar Snackbar { get; init; } = null!;
 }

app/MindWork AI Studio/Components/Settings/SettingsPanelProviderBase.cs

@@ -47,7 +47,7 @@ public abstract class SettingsPanelProviderBase : SettingsPanelBase
                 else
                 {
                     // No encryption secret available - inform the user:
-                    this.Snackbar.Add(TB("Cannot export the encrypted API key: No enterprise encryption secret is configured."), Severity.Warning);
+                    await this.MessageBus.SendWarning(new(Icons.Material.Filled.Key, TB("Cannot export the encrypted API key: No enterprise encryption secret is configured.")));
                 }
             }
         }
@@ -56,6 +56,6 @@ public abstract class SettingsPanelProviderBase : SettingsPanelBase
         if (string.IsNullOrWhiteSpace(luaCode))
             return;
 
-        await this.RustService.CopyText2Clipboard(this.Snackbar, luaCode);
+        await this.RustService.CopyText2Clipboard(luaCode);
     }
 }

app/MindWork AI Studio/Components/Settings/SettingsPanelProviders.razor.cs

@@ -75,6 +75,7 @@ public partial class SettingsPanelProviders : SettingsPanelProviderBase
             { x => x.HFInferenceProviderId, provider.HFInferenceProvider },
             { x => x.AdditionalJsonApiParameters, provider.AdditionalJsonApiParameters },
             { x => x.DataTokenizerPath, provider.TokenizerPath },
+            { x => x.DataCapabilityOverrides, provider.CapabilityOverrides },
         };
 
         var dialogReference = await this.DialogService.ShowAsync<ProviderDialog>(T("Edit LLM Provider"), dialogParameters, DialogOptions.FULLSCREEN);

app/MindWork AI Studio/Components/TextInfoLine.razor.cs

@@ -23,9 +23,6 @@ public partial class TextInfoLine : MSGComponentBase
     
     [Inject]
     private RustService RustService { get; init; } = null!;
-    
-    [Inject]
-    private ISnackbar Snackbar { get; init; } = null!;
 
     #region Overrides of ComponentBase
 
@@ -43,5 +40,5 @@ public partial class TextInfoLine : MSGComponentBase
     
     private string ClipboardTooltip => string.Format(T("Copy {0} to the clipboard"), this.ClipboardTooltipSubject);
     
-    private async Task CopyToClipboard(string content) => await this.RustService.CopyText2Clipboard(this.Snackbar, content);
+    private async Task CopyToClipboard(string content) => await this.RustService.CopyText2Clipboard(content);
 }

app/MindWork AI Studio/Components/TextInfoLines.razor.cs

@@ -26,9 +26,6 @@ public partial class TextInfoLines : MSGComponentBase
     
     [Inject]
     private RustService RustService { get; init; } = null!;
-    
-    [Inject]
-    private ISnackbar Snackbar { get; init; } = null!;
 
     #region Overrides of ComponentBase
 
@@ -46,7 +43,7 @@ public partial class TextInfoLines : MSGComponentBase
     
     private string ClipboardTooltip => string.Format(T("Copy {0} to the clipboard"), this.ClipboardTooltipSubject);
     
-    private async Task CopyToClipboard(string content) => await this.RustService.CopyText2Clipboard(this.Snackbar, content);
+    private async Task CopyToClipboard(string content) => await this.RustService.CopyText2Clipboard(content);
     
     private string GetColor()
     {

app/MindWork AI Studio/Components/VoiceRecorder.razor.cs

@@ -1,6 +1,7 @@
-using AIStudio.Provider;
+using System.Buffers.Binary;
+
 using AIStudio.Settings.DataModel;
-using AIStudio.Tools.MIME;
+using AIStudio.Tools.Media;
 using AIStudio.Tools.Rust;
 using AIStudio.Tools.Services;
 
@@ -10,6 +11,8 @@ namespace AIStudio.Components;
 
 public partial class VoiceRecorder : MSGComponentBase
 {
+    private const int PCM_WAV_HEADER_SIZE = 44;
+
     [Inject]
     private ILogger<VoiceRecorder> Logger { get; init; } = null!;
 
@@ -20,15 +23,20 @@ public partial class VoiceRecorder : MSGComponentBase
     private RustService RustService { get; init; } = null!;
 
     [Inject]
-    private ISnackbar Snackbar { get; init; } = null!;
+    private GlobalShortcutService GlobalShortcutService { get; init; } = null!;
 
     [Inject]
     private VoiceRecordingAvailabilityService VoiceRecordingAvailabilityService { get; init; } = null!;
 
+    [Inject]
+    private MediaTranscriptionService MediaTranscriptionService { get; init; } = null!;
+
     #region Overrides of MSGComponentBase
 
     protected override async Task OnInitializedAsync()
     {
+        this.GlobalShortcutService.RuntimeStateChanged += this.OnShortcutRuntimeStateChanged;
+
         // Register for global shortcut events:
         this.ApplyFilters([], [Event.TAURI_EVENT_RECEIVED, Event.VOICE_RECORDING_AVAILABILITY_CHANGED]);
 
@@ -37,8 +45,15 @@ public partial class VoiceRecorder : MSGComponentBase
 
     protected override async Task OnAfterRenderAsync(bool firstRender)
     {
-        if (firstRender && this.ShouldRenderVoiceRecording)
-            await this.EnsureSoundEffectsAvailableAsync("during the first interactive render");
+        if (firstRender)
+        {
+            this.localShortcutDotNetReference = DotNetObjectReference.Create(this);
+            this.localShortcutInteropReady = true;
+            await this.ApplyLocalShortcutState(this.GlobalShortcutService.GetRuntimeState(Shortcut.VOICE_RECORDING_TOGGLE));
+
+            if (this.ShouldRenderVoiceRecording)
+                await this.EnsureSoundEffectsAvailableAsync("during the first interactive render");
+        }
 
         await base.OnAfterRenderAsync(firstRender);
     }
@@ -63,6 +78,36 @@ public partial class VoiceRecorder : MSGComponentBase
         }
     }
 
+    private async Task OnShortcutRuntimeStateChanged(GlobalShortcutRuntimeState runtimeState)
+    {
+        try
+        {
+            await this.InvokeAsync(() => this.ApplyLocalShortcutState(runtimeState));
+        }
+        catch (ObjectDisposedException)
+        {
+            this.Logger.LogDebug("Ignoring a shortcut state change after the voice recorder was disposed.");
+        }
+        catch (InvalidOperationException ex)
+        {
+            this.Logger.LogDebug(ex, "The focused-window shortcut listener could not be updated because the component dispatcher is unavailable.");
+        }
+    }
+
+    [JSInvokable]
+    public async Task OnLocalShortcutPressed()
+    {
+        var runtimeState = this.GlobalShortcutService.GetRuntimeState(Shortcut.VOICE_RECORDING_TOGGLE);
+        if (runtimeState.Backend is not ShortcutBackend.LOCAL || runtimeState.IsSuspended)
+        {
+            this.Logger.LogDebug("Ignoring a stale focused-window shortcut event.");
+            return;
+        }
+
+        this.Logger.LogInformation("Focused-window shortcut triggered for voice recording toggle.");
+        await this.ToggleRecordingFromShortcut();
+    }
+
     /// <summary>
     /// Toggles the recording state when triggered by a global shortcut.
     /// </summary>
@@ -93,9 +138,50 @@ public partial class VoiceRecorder : MSGComponentBase
     private bool isTranscribing;
     private FileStream? currentRecordingStream;
     private string? currentRecordingPath;
-    private string? currentRecordingMimeType;
     private string? finalRecordingPath;
     private DotNetObjectReference<VoiceRecorder>? dotNetReference;
+    private DotNetObjectReference<VoiceRecorder>? localShortcutDotNetReference;
+    private bool localShortcutInteropReady;
+
+    private async Task ApplyLocalShortcutState(GlobalShortcutRuntimeState runtimeState)
+    {
+        if (!this.localShortcutInteropReady
+            || this.localShortcutDotNetReference is null
+            || runtimeState.ShortcutId is not Shortcut.VOICE_RECORDING_TOGGLE)
+        {
+            return;
+        }
+
+        try
+        {
+            if (runtimeState.Backend is ShortcutBackend.LOCAL
+                && !runtimeState.IsSuspended
+                && !string.IsNullOrWhiteSpace(runtimeState.Shortcut))
+            {
+                await this.JsRuntime.InvokeVoidAsync(
+                    "localShortcut.register",
+                    "voice-recording-toggle",
+                    runtimeState.Shortcut,
+                    this.localShortcutDotNetReference);
+            }
+            else
+            {
+                await this.JsRuntime.InvokeVoidAsync("localShortcut.unregister", "voice-recording-toggle");
+            }
+        }
+        catch (JSDisconnectedException)
+        {
+            this.Logger.LogDebug("The focused-window shortcut listener could not be updated because the JS runtime disconnected.");
+        }
+        catch (OperationCanceledException)
+        {
+            this.Logger.LogDebug("Updating the focused-window shortcut listener was canceled.");
+        }
+        catch (JSException ex)
+        {
+            this.Logger.LogWarning(ex, "Failed to update the focused-window shortcut listener.");
+        }
+    }
 
     private bool ShouldRenderVoiceRecording => PreviewFeatures.PRE_SPEECH_TO_TEXT_2026.IsEnabled(this.SettingsManager)
                                                && !string.IsNullOrWhiteSpace(this.SettingsManager.ConfigurationData.App.UseTranscriptionProvider);
@@ -131,17 +217,7 @@ public partial class VoiceRecorder : MSGComponentBase
                 return;
             }
 
-            var mimeTypes = GetPreferredMimeTypes(
-                Builder.Create().UseAudio().UseSubtype(AudioSubtype.WEBM).Build(),
-                Builder.Create().UseAudio().UseSubtype(AudioSubtype.OGG).Build(),
-                Builder.Create().UseAudio().UseSubtype(AudioSubtype.AAC).Build(),
-                Builder.Create().UseAudio().UseSubtype(AudioSubtype.MP3).Build(),
-                Builder.Create().UseAudio().UseSubtype(AudioSubtype.AIFF).Build(),
-                Builder.Create().UseAudio().UseSubtype(AudioSubtype.WAV).Build(),
-                Builder.Create().UseAudio().UseSubtype(AudioSubtype.FLAC).Build()
-            );
-
-            this.Logger.LogInformation("Starting audio recording with preferred MIME types: '{PreferredMimeTypes}'.", string.Join<MIMEType>(", ", mimeTypes));
+            this.Logger.LogInformation("Starting PCM/WAV audio recording.");
 
             // Create a DotNetObjectReference to pass to JavaScript:
             this.dotNetReference = DotNetObjectReference.Create(this);
@@ -151,13 +227,8 @@ public partial class VoiceRecorder : MSGComponentBase
 
             try
             {
-                var mimeTypeStrings = mimeTypes.ToStringArray();
-                var actualMimeType = await this.JsRuntime.InvokeAsync<string>("audioRecorder.start", this.dotNetReference, mimeTypeStrings);
-
-                // Store the MIME type for later use:
-                this.currentRecordingMimeType = actualMimeType;
-
-                this.Logger.LogInformation("Audio recording started with MIME type: '{ActualMimeType}'.", actualMimeType);
+                await this.JsRuntime.InvokeVoidAsync("audioRecorder.start", this.dotNetReference);
+                this.Logger.LogInformation("PCM/WAV audio recording started.");
                 this.isPreparing = false;
                 this.isRecording = true;
             }
@@ -168,6 +239,7 @@ public partial class VoiceRecorder : MSGComponentBase
 
                 // Clean up the recording stream if starting failed:
                 await this.FinalizeRecordingStream();
+                await this.ReleaseMicrophoneAsync();
             }
             finally
             {
@@ -176,11 +248,11 @@ public partial class VoiceRecorder : MSGComponentBase
         }
         else
         {
+            var recordingStoppedSuccessfully = false;
             try
             {
-                var result = await this.JsRuntime.InvokeAsync<AudioRecordingResult>("audioRecorder.stop");
-                if (result.ChangedMimeType)
-                    this.Logger.LogWarning("The recorded audio MIME type was changed to '{ResultMimeType}'.", result.MimeType);
+                await this.JsRuntime.InvokeVoidAsync("audioRecorder.stop");
+                recordingStoppedSuccessfully = true;
             }
             catch (Exception e)
             {
@@ -194,28 +266,21 @@ public partial class VoiceRecorder : MSGComponentBase
             this.isRecording = false;
             this.StateHasChanged();
 
-            // Start transcription if we have a recording and a configured provider:
-            if (this.finalRecordingPath is not null)
-                await this.TranscribeRecordingAsync();
-        }
-    }
+            if (!recordingStoppedSuccessfully || this.finalRecordingPath is null)
+            {
+                if (recordingStoppedSuccessfully)
+                {
+                    this.Logger.LogWarning("The audio recorder did not produce any data.");
+                    await this.MessageBus.SendError(new(Icons.Material.Filled.MicOff, this.T("Failed to stop audio recording.")));
+                }
 
-    private static MIMEType[] GetPreferredMimeTypes(params MIMEType[] mimeTypes)
-    {
-        // Default list if no parameters provided:
-        if (mimeTypes.Length is 0)
-        {
-            var audioBuilder = Builder.Create().UseAudio();
-            return
-            [
-                audioBuilder.UseSubtype(AudioSubtype.WEBM).Build(),
-                audioBuilder.UseSubtype(AudioSubtype.OGG).Build(),
-                audioBuilder.UseSubtype(AudioSubtype.MP4).Build(),
-                audioBuilder.UseSubtype(AudioSubtype.MPEG).Build(),
-            ];
-        }
+                this.DeleteFinalRecording();
+                await this.ReleaseMicrophoneAsync();
+                return;
+            }
 
-        return mimeTypes;
+            await this.TranscribeRecordingAsync();
+        }
     }
 
     private async Task InitializeRecordingStream()
@@ -226,7 +291,7 @@ public partial class VoiceRecorder : MSGComponentBase
         if (!Directory.Exists(recordingDirectory))
             Directory.CreateDirectory(recordingDirectory);
 
-        var fileName = $"recording_{DateTime.UtcNow:yyyyMMdd_HHmmss}.audio";
+        var fileName = $"recording_{DateTime.UtcNow:yyyyMMdd_HHmmss}.wav";
         this.currentRecordingPath = Path.Combine(recordingDirectory, fileName);
         this.currentRecordingStream = new FileStream(this.currentRecordingPath, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: 8192, useAsync: true);
 
@@ -253,6 +318,7 @@ public partial class VoiceRecorder : MSGComponentBase
         catch (Exception ex)
         {
             this.Logger.LogError(ex, "Error writing audio chunk to stream.");
+            throw;
         }
     }
 
@@ -262,45 +328,56 @@ public partial class VoiceRecorder : MSGComponentBase
         if (this.currentRecordingStream is not null)
         {
             await this.currentRecordingStream.FlushAsync();
+            var hasPcmAudioData = await this.FinalizePcmWavHeaderAsync(this.currentRecordingStream);
             await this.currentRecordingStream.DisposeAsync();
             this.currentRecordingStream = null;
 
-            // Rename the file with the correct extension based on MIME type:
-            if (this.currentRecordingPath is not null && this.currentRecordingMimeType is not null)
+            if (this.currentRecordingPath is not null && File.Exists(this.currentRecordingPath))
             {
-                var extension = GetFileExtension(this.currentRecordingMimeType);
-                var newPath = Path.ChangeExtension(this.currentRecordingPath, extension);
+                var fileSize = new FileInfo(this.currentRecordingPath).Length;
 
-                if (File.Exists(this.currentRecordingPath))
+                if (hasPcmAudioData)
                 {
-                    File.Move(this.currentRecordingPath, newPath, overwrite: true);
-                    this.finalRecordingPath = newPath;
-                    this.Logger.LogInformation("Finalized audio recording over {NumChunks} streamed audio chunks to the file '{RecordingPath}'.", this.numReceivedChunks, newPath);
+                    this.finalRecordingPath = this.currentRecordingPath;
+                    this.Logger.LogInformation("Finalized audio recording over {NumChunks} streamed audio chunks to the file '{RecordingPath}' with {FileSize} bytes.", this.numReceivedChunks, this.currentRecordingPath, fileSize);
+                }
+                else
+                {
+                    this.Logger.LogWarning("Discarding a PCM/WAV audio recording without audio data ({FileSize} bytes).", fileSize);
+                    File.Delete(this.currentRecordingPath);
                 }
             }
         }
 
         this.currentRecordingPath = null;
-        this.currentRecordingMimeType = null;
 
         // Dispose the .NET reference:
         this.dotNetReference?.Dispose();
         this.dotNetReference = null;
     }
 
-    private static string GetFileExtension(string mimeType)
+    private async Task<bool> FinalizePcmWavHeaderAsync(FileStream recordingStream)
     {
-        var baseMimeType = mimeType.Split(';')[0].Trim().ToLowerInvariant();
-        return baseMimeType switch
-        {
-            "audio/webm" => ".webm",
-            "audio/ogg" => ".ogg",
-            "audio/mp4" => ".m4a",
-            "audio/mpeg" => ".mp3",
-            "audio/wav" => ".wav",
-            "audio/x-wav" => ".wav",
-            _ => ".audio" // Fallback
-        };
+        if (recordingStream.Length <= PCM_WAV_HEADER_SIZE)
+            return false;
+
+        var pcmDataSize = recordingStream.Length - PCM_WAV_HEADER_SIZE;
+        if (pcmDataSize > uint.MaxValue - 36)
+            throw new InvalidDataException("The streamed PCM recording exceeds the WAV size limit.");
+
+        var valueBuffer = new byte[sizeof(uint)];
+        BinaryPrimitives.WriteUInt32LittleEndian(valueBuffer, checked((uint)(36 + pcmDataSize)));
+        recordingStream.Seek(4, SeekOrigin.Begin);
+        await recordingStream.WriteAsync(valueBuffer);
+
+        BinaryPrimitives.WriteUInt32LittleEndian(valueBuffer, checked((uint)pcmDataSize));
+        recordingStream.Seek(40, SeekOrigin.Begin);
+        await recordingStream.WriteAsync(valueBuffer);
+        recordingStream.Seek(0, SeekOrigin.End);
+        await recordingStream.FlushAsync();
+
+        this.Logger.LogInformation("Finalized a streamed PCM/WAV header for {PcmDataSize} bytes of audio data.", pcmDataSize);
+        return true;
     }
 
     private async Task TranscribeRecordingAsync()
@@ -317,58 +394,22 @@ public partial class VoiceRecorder : MSGComponentBase
 
         try
         {
-            // Get the configured transcription provider ID:
-            var transcriptionProviderId = this.SettingsManager.ConfigurationData.App.UseTranscriptionProvider;
-            if (string.IsNullOrWhiteSpace(transcriptionProviderId))
+            var transcriptionResult = await this.MediaTranscriptionService.TranscribeVoiceAsync(this.finalRecordingPath);
+            if (transcriptionResult.Status is not MediaTranscriptionResultStatus.SUCCEEDED)
             {
-                this.Logger.LogWarning("No transcription provider is configured.");
-                await this.MessageBus.SendError(new(Icons.Material.Filled.VoiceChat, this.T("No transcription provider is configured.")));
-                return;
-            }
+                if (transcriptionResult.Status is MediaTranscriptionResultStatus.CANCELLED)
+                    return;
 
-            // Find the transcription provider in the list of configured providers:
-            var transcriptionProviderSettings = this.SettingsManager.ConfigurationData.TranscriptionProviders
-                .FirstOrDefault(x => x.Id == transcriptionProviderId);
+                if (transcriptionResult.Status is MediaTranscriptionResultStatus.NO_AUDIBLE_SIGNAL)
+                {
+                    await this.MessageBus.SendWarning(new(Icons.Material.Filled.VoiceChat, transcriptionResult.UserMessage));
+                    return;
+                }
 
-            if (transcriptionProviderSettings is null)
-            {
-                this.Logger.LogWarning("The configured transcription provider with ID '{ProviderId}' was not found.", transcriptionProviderId);
-                await this.MessageBus.SendError(new(Icons.Material.Filled.VoiceChat, this.T("The configured transcription provider was not found.")));
-                return;
-            }
-
-            // Check the confidence level:
-            var minimumLevel = this.SettingsManager.GetMinimumConfidenceLevel(Tools.Components.NONE);
-            var providerConfidence = transcriptionProviderSettings.UsedLLMProvider.GetConfidence(this.SettingsManager);
-            if (providerConfidence.Level < minimumLevel)
-            {
-                this.Logger.LogWarning(
-                    "The configured transcription provider '{ProviderName}' has a confidence level of '{ProviderLevel}', which is below the minimum required level of '{MinimumLevel}'.",
-                    transcriptionProviderSettings.UsedLLMProvider,
-                    providerConfidence.Level,
-                    minimumLevel);
-                await this.MessageBus.SendError(new(Icons.Material.Filled.VoiceChat, this.T("The configured transcription provider does not meet the minimum confidence level.")));
-                return;
-            }
-
-            // Create the provider instance:
-            var provider = transcriptionProviderSettings.CreateProvider();
-            if (provider.Provider is LLMProviders.NONE)
-            {
-                this.Logger.LogError("Failed to create the transcription provider instance.");
-                await this.MessageBus.SendError(new(Icons.Material.Filled.VoiceChat, this.T("Failed to create the transcription provider.")));
-                return;
-            }
-
-            // Call the transcription API:
-            this.Logger.LogInformation("Starting transcription with provider '{ProviderName}' and model '{ModelName}'.", transcriptionProviderSettings.UsedLLMProvider, transcriptionProviderSettings.Model.ToString());
-            var transcriptionResult = await provider.TranscribeAudioAsync(transcriptionProviderSettings.Model, this.finalRecordingPath, this.SettingsManager);
-            if (!transcriptionResult.Success)
-            {
                 this.Logger.LogWarning("The transcription request failed.");
-                var userMessage = string.IsNullOrWhiteSpace(transcriptionResult.ErrorMessage)
+                var userMessage = string.IsNullOrWhiteSpace(transcriptionResult.UserMessage)
                     ? this.T("Unfortunately, there was an error communicating with the AI system.")
-                    : transcriptionResult.ErrorMessage;
+                    : transcriptionResult.UserMessage;
                 await this.MessageBus.SendError(new(Icons.Material.Filled.VoiceChat, userMessage));
                 return;
             }
@@ -404,21 +445,8 @@ public partial class VoiceRecorder : MSGComponentBase
             }
 
             // Copy the transcribed text to the clipboard:
-            await this.RustService.CopyText2Clipboard(this.Snackbar, transcribedText);
+            await this.RustService.CopyText2Clipboard(transcribedText);
 
-            // Delete the recording file:
-            try
-            {
-                if (File.Exists(this.finalRecordingPath))
-                {
-                    File.Delete(this.finalRecordingPath);
-                    this.Logger.LogInformation("Deleted the recording file '{RecordingPath}'.", this.finalRecordingPath);
-                }
-            }
-            catch (Exception ex)
-            {
-                this.Logger.LogError(ex, "Failed to delete the recording file '{RecordingPath}'.", this.finalRecordingPath);
-            }
         }
         catch (Exception ex)
         {
@@ -428,13 +456,31 @@ public partial class VoiceRecorder : MSGComponentBase
         finally
         {
             await this.ReleaseMicrophoneAsync();
-
-            this.finalRecordingPath = null;
+            this.DeleteFinalRecording();
             this.isTranscribing = false;
             this.StateHasChanged();
         }
     }
 
+    private void DeleteFinalRecording()
+    {
+        var recordingPath = this.finalRecordingPath;
+        this.finalRecordingPath = null;
+
+        if (recordingPath is null)
+            return;
+
+        try
+        {
+            if (File.Exists(recordingPath))
+                File.Delete(recordingPath);
+        }
+        catch (Exception ex)
+        {
+            this.Logger.LogError(ex, "Failed to delete the recording file '{RecordingPath}'.", recordingPath);
+        }
+    }
+
     private async Task ReleaseMicrophoneAsync()
     {
         // Wait a moment for any queued sounds to finish playing, then release the microphone.
@@ -517,6 +563,15 @@ public partial class VoiceRecorder : MSGComponentBase
 
     protected override void DisposeResources()
     {
+        this.GlobalShortcutService.RuntimeStateChanged -= this.OnShortcutRuntimeStateChanged;
+
+        if (this.localShortcutInteropReady)
+            _ = this.JsRuntime.InvokeVoidAsync("localShortcut.unregister", "voice-recording-toggle");
+
+        this.localShortcutDotNetReference?.Dispose();
+        this.localShortcutDotNetReference = null;
+        this.localShortcutInteropReady = false;
+
         // Clean up recording resources if still active:
         if (this.currentRecordingStream is not null)
         {
@@ -530,4 +585,4 @@ public partial class VoiceRecorder : MSGComponentBase
     }
 
     #endregion
-}
+}

app/MindWork AI Studio/Components/Workspaces.razor.cs

@@ -4,6 +4,8 @@ using System.Text.Json;
 using AIStudio.Chat;
 using AIStudio.Dialogs;
 using AIStudio.Tools.AIJobs;
+using AIStudio.Tools.Media;
+using AIStudio.Tools.Services;
 
 using Microsoft.AspNetCore.Components;
 
@@ -21,6 +23,9 @@ public partial class Workspaces : MSGComponentBase
 
     [Inject]
     private AIJobService AIJobService { get; init; } = null!;
+
+    [Inject]
+    private MediaTranscriptionService MediaTranscriptionService { get; init; } = null!;
     
     [Parameter]
     public ChatThread? CurrentChatThread { get; set; }
@@ -55,6 +60,7 @@ public partial class Workspaces : MSGComponentBase
 
     protected override async Task OnInitializedAsync()
     {
+        this.MediaTranscriptionService.StateChanged += this.OnMediaImportStateChanged;
         await base.OnInitializedAsync();
         this.ApplyFilters([], [ Event.AI_JOB_CHANGED, Event.AI_JOB_FINISHED, Event.CHAT_GENERATION_CHANGED, Event.WORKSPACE_CREATED ]);
         _ = this.LoadTreeItemsAsync(startPrefetch: true);
@@ -376,12 +382,26 @@ public partial class Workspaces : MSGComponentBase
 
     private bool IsChatTreeItemBusy(TreeItemData treeItem)
     {
-        return treeItem.Type is TreeItemType.CHAT && this.AIJobService.IsChatGenerationActive(treeItem.ChatId);
+        return treeItem.Type is TreeItemType.CHAT
+               && (this.AIJobService.IsChatGenerationActive(treeItem.ChatId)
+                   || this.MediaTranscriptionService.IsBusy(MediaImportOwner.ForChat(treeItem.ChatId)));
     }
 
     private string GetChatTreeItemTextStyle(TreeItemData treeItem)
     {
-        return this.IsCurrentChatTreeItem(treeItem) ? "justify-self: start; font-weight: 700;" : "justify-self: start;";
+        var status = this.MediaTranscriptionService.GetSnapshot(MediaImportOwner.ForChat(treeItem.ChatId))?.Status;
+        var color = status switch
+        {
+            MediaImportStatus.QUEUED or MediaImportStatus.RUNNING or MediaImportStatus.CANCELING => " color: var(--mud-palette-info);",
+            MediaImportStatus.SUCCEEDED => " color: var(--mud-palette-success);",
+            MediaImportStatus.WARNING => " color: var(--mud-palette-warning);",
+            MediaImportStatus.FAILED => " color: var(--mud-palette-error);",
+            MediaImportStatus.CANCELLED => " color: var(--mud-palette-warning);",
+            _ => string.Empty,
+        };
+        
+        var weight = this.IsCurrentChatTreeItem(treeItem) ? " font-weight: 700;" : string.Empty;
+        return $"justify-self: start;{weight}{color}";
     }
 
     private bool IsCurrentChatTreeItem(TreeItemData treeItem)
@@ -394,6 +414,22 @@ public partial class Workspaces : MSGComponentBase
 
     private string GetChatTreeIcon(Guid chatId, string defaultIcon)
     {
+        var mediaStatus = this.MediaTranscriptionService.GetSnapshot(MediaImportOwner.ForChat(chatId))?.Status;
+        if (mediaStatus is not null)
+        {
+            return mediaStatus switch
+            {
+                MediaImportStatus.QUEUED => Icons.Material.Filled.HourglassTop,
+                MediaImportStatus.RUNNING or MediaImportStatus.CANCELING => Icons.Material.Filled.ChangeCircle,
+                MediaImportStatus.SUCCEEDED => Icons.Material.Filled.TaskAlt,
+                MediaImportStatus.WARNING => Icons.Material.Filled.WarningAmber,
+                MediaImportStatus.FAILED => Icons.Material.Filled.Error,
+                MediaImportStatus.CANCELLED => Icons.Material.Filled.Cancel,
+                
+                _ => defaultIcon,
+            };
+        }
+
         var snapshot = this.AIJobService.TryGetChatSnapshot(chatId);
         if (snapshot is null || !snapshot.IsActive)
             return defaultIcon;
@@ -406,6 +442,12 @@ public partial class Workspaces : MSGComponentBase
         };
     }
 
+    private void OnMediaImportStateChanged(MediaImportOwner owner)
+    {
+        if (owner.Kind is MediaImportOwnerKind.CHAT)
+            _ = this.SafeStateHasChanged();
+    }
+
     private async Task SafeStateHasChanged()
     {
         if (this.isDisposed)
@@ -668,7 +710,8 @@ public partial class Workspaces : MSGComponentBase
         if (chat is null)
             return;
 
-        if (this.AIJobService.IsChatGenerationActive(chat.ChatId))
+        var mediaOwner = MediaImportOwner.ForChat(chat.ChatId);
+        if (this.AIJobService.IsChatGenerationActive(chat.ChatId) || this.MediaTranscriptionService.IsBusy(mediaOwner))
             return;
 
         if (askForConfirmation)
@@ -692,6 +735,7 @@ public partial class Workspaces : MSGComponentBase
         }
 
         await WorkspaceBehaviour.DeleteChatAsync(this.DialogService, chat.WorkspaceId, chat.ChatId, askForConfirmation: false);
+        this.MediaTranscriptionService.ClearOwnerState(mediaOwner);
         await this.LoadTreeItemsAsync(startPrefetch: false);
         
         if (unloadChat && this.CurrentChatThread?.ChatId == chat.ChatId)
@@ -845,16 +889,13 @@ public partial class Workspaces : MSGComponentBase
         if (workspaceId == Guid.Empty)
             return;
         
-        await WorkspaceBehaviour.DeleteChatAsync(this.DialogService, chat.WorkspaceId, chat.ChatId, askForConfirmation: false);
-        
-        chat.WorkspaceId = workspaceId;
+        await WorkspaceBehaviour.MoveChatAsync(chat, workspaceId);
         if (this.CurrentChatThread?.ChatId == chat.ChatId)
         {
             this.CurrentChatThread = chat;
             await this.CurrentChatThreadChanged.InvokeAsync(this.CurrentChatThread);
         }
-        
-        await WorkspaceBehaviour.StoreChatAsync(chat);
+
         await this.LoadTreeItemsAsync(startPrefetch: false);
     }
     
@@ -914,6 +955,7 @@ public partial class Workspaces : MSGComponentBase
 
     protected override void DisposeResources()
     {
+        this.MediaTranscriptionService.StateChanged -= this.OnMediaImportStateChanged;
         this.isDisposed = true;
         this.prefetchCancellationTokenSource?.Cancel();
         this.prefetchCancellationTokenSource?.Dispose();