Added Fireworks provider (#43)

README.md

@@ -5,14 +5,14 @@ MindWork AI Studio is a desktop application available for macOS, Windows, and Li
 
 **Key advantages:**
 - **Free of charge**: The app is free to use, both for personal and commercial purposes.
-- **Independence**: Users are not tied to any single provider. The initial version supports OpenAI models (like GPT-4o, GPT-4, GPT-4 Turbo, etc.). Future versions will support other providers such as Mistral or Google Gemini.
+- **Independence**: You are not tied to any single provider. Instead, you can choose the provider that best suits their needs. Right now, we support OpenAI (GPT4o etc.), Mistral, Anthropic (Claude), and self-hosted models using [llama.cpp](https://github.com/ggerganov/llama.cpp), [ollama](https://github.com/ollama/ollama), [LM Studio](https://lmstudio.ai/), or [Fireworks](https://fireworks.ai/). Support for Google Gemini, and [Replicate](https://replicate.com/) is planned.
 - **Unrestricted usage**: Unlike services like ChatGPT, which impose limits after intensive use, MindWork AI Studio offers unlimited usage through the providers API.
 - **Cost-effective**: You only pay for what you use, which can be cheaper than monthly subscription services like ChatGPT Plus, especially if used infrequently. But beware, here be dragons: For extremely intensive usage, the API costs can be significantly higher. Unfortunately, providers currently do not offer a way to display current costs in the app. Therefore, check your account with the respective provider to see how your costs are developing. When available, use prepaid and set a cost limit.
 - **Privacy**: The data entered into the app is not used for training by the providers since we are using the provider's API.
 - **Flexibility**: Choose the provider and model best suited for your current task.
 - **No bloatware**: The app requires minimal storage for installation and operates with low memory usage. Additionally, it has a minimal impact on system resources, which is beneficial for battery life.
 
-**Ready to get started 🤩?** [Download the appropriate setup for your operating system here](documentation/Setup.md).
+## **Ready to get started 🤩?** [Download the appropriate setup for your operating system here](documentation/Setup.md).
 
 ## Support the Project
 Thank you for using MindWork AI Studio and considering supporting its development 😀. Your support helps keep the project alive and ensures continuous improvements and new features.
@@ -30,9 +30,7 @@ Your support, whether big or small, keeps the wheels turning and is deeply appre
 
 ## Planned Features
 Here's an exciting look at some of the features we're planning to add to MindWork AI Studio in future releases:
-- **More providers**: We plan to add support for additional LLM providers, such as Mistral and Google Gemini, giving you more options to choose from.
-- **Persistent chats**: Your chats will be stored locally, allowing you to continue conversations at any time without starting from scratch.
-- **Local LLMs**: We aim to support local LLMs, enabling you to use options like LM Studio, `ollama`, or `llama.cpp` for a more private and self-contained experience.
+- **More providers**: We plan to add support for additional LLM providers, such as Google Gemini, giving you more options to choose from.
 - **System prompts**: Integration of a system prompt library will allow you to control the behavior of the LLM with predefined prompts, ensuring consistency and efficiency.
 - **Text replacement for better privacy**: Define keywords that will be replaced in your chats before sending content to the provider, enhancing your privacy.
 - **Advanced interactions**: We're full of ideas for advanced interactions tailored for specific use cases, whether in a business context or for writers and other professionals.

app/MindWork AI Studio.sln.DotSettings

@@ -1,4 +1,6 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=AI/@EntryIndexedValue">AI</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=LM/@EntryIndexedValue">LM</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=MSG/@EntryIndexedValue">MSG</s:String>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=ollama/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=tauri_0027s/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

app/MindWork AI Studio/Chat/ChatThread.cs

@@ -3,29 +3,35 @@ namespace AIStudio.Chat;
 /// <summary>
 /// Data structure for a chat thread.
 /// </summary>
-/// <param name="name">The name of the chat thread.</param>
-/// <param name="seed">The seed for the chat thread. Some providers use this to generate deterministic results.</param>
-/// <param name="systemPrompt">The system prompt for the chat thread.</param>
-/// <param name="blocks">The content blocks of the chat thread.</param>
-public sealed class ChatThread(string name, int seed, string systemPrompt, IEnumerable<ContentBlock> blocks)
+public sealed class ChatThread
 {
+    /// <summary>
+    /// The unique identifier of the chat thread.
+    /// </summary>
+    public Guid ChatId { get; init; }
+    
+    /// <summary>
+    /// The unique identifier of the workspace.
+    /// </summary>
+    public Guid WorkspaceId { get; set; }
+
     /// <summary>
     /// The name of the chat thread. Usually generated by an AI model or manually edited by the user.
     /// </summary>
-    public string Name { get; set; } = name;
+    public string Name { get; set; } = string.Empty;
 
     /// <summary>
     /// The seed for the chat thread. Some providers use this to generate deterministic results.
     /// </summary>
-    public int Seed { get; set; } = seed;
+    public int Seed { get; init; }
     
     /// <summary>
     /// The current system prompt for the chat thread.
     /// </summary>
-    public string SystemPrompt { get; set; } = systemPrompt;
-    
+    public string SystemPrompt { get; init; } = string.Empty;
+
     /// <summary>
     /// The content blocks of the chat thread.
     /// </summary>
-    public List<ContentBlock> Blocks { get; init; } = blocks.ToList();
+    public List<ContentBlock> Blocks { get; init; } = [];
 }

app/MindWork AI Studio/Chat/ContentBlock.cs

@@ -3,25 +3,22 @@ namespace AIStudio.Chat;
 /// <summary>
 /// A block of content in a chat thread. Might be any type of content, e.g., text, image, voice, etc.
 /// </summary>
-/// <param name="time">Time when the content block was created.</param>
-/// <param name="type">Type of the content block, e.g., text, image, voice, etc.</param>
-/// <param name="content">The content of the block.</param>
-public class ContentBlock(DateTimeOffset time, ContentType type, IContent content)
+public class ContentBlock
 {
     /// <summary>
     /// Time when the content block was created.
     /// </summary>
-    public DateTimeOffset Time => time;
+    public DateTimeOffset Time { get; init; }
     
     /// <summary>
     /// Type of the content block, e.g., text, image, voice, etc.
     /// </summary>
-    public ContentType ContentType => type;
+    public ContentType ContentType { get; init; } = ContentType.NONE;
     
     /// <summary>
     /// The content of the block.
     /// </summary>
-    public IContent Content => content;
+    public IContent? Content { get; init; } = null;
 
     /// <summary>
     /// The role of the content block in the chat thread, e.g., user, AI, etc.

app/MindWork AI Studio/Chat/ContentBlockComponent.razor

@@ -1,7 +1,7 @@
 @using AIStudio.Tools
 @using MudBlazor
 
-<MudCard Class="my-2 rounded-lg" Outlined="@true">
+<MudCard Class="@this.CardClasses" Outlined="@true">
     <MudCardHeader>
         <CardHeaderAvatar>
             <MudAvatar Color="@this.Role.ToColor()">

app/MindWork AI Studio/Chat/ContentBlockComponent.razor.cs

@@ -33,6 +33,12 @@ public partial class ContentBlockComponent : ComponentBase
     [Parameter]
     public DateTimeOffset Time { get; init; }
     
+    /// <summary>
+    /// Optional CSS classes.
+    /// </summary>
+    [Parameter]
+    public string Class { get; set; } = string.Empty;
+    
     [Inject]
     private Rust Rust { get; init; } = null!;
     
@@ -107,4 +113,6 @@ public partial class ContentBlockComponent : ComponentBase
                 break;
         }
     }
+    
+    private string CardClasses => $"my-2 rounded-lg {this.Class}";
 }

app/MindWork AI Studio/Chat/ContentImage.cs

@@ -1,3 +1,5 @@
+using System.Text.Json.Serialization;
+
 using AIStudio.Provider;
 using AIStudio.Settings;
 
@@ -11,15 +13,19 @@ public sealed class ContentImage : IContent
     #region Implementation of IContent
 
     /// <inheritdoc />
+    [JsonIgnore]
     public bool InitialRemoteWait { get; set; } = false;
 
     /// <inheritdoc />
+    [JsonIgnore]
     public bool IsStreaming { get; set; } = false;
 
     /// <inheritdoc />
+    [JsonIgnore]
     public Func<Task> StreamingDone { get; set; } = () => Task.CompletedTask;
 
     /// <inheritdoc />
+    [JsonIgnore]
     public Func<Task> StreamingEvent { get; set; } = () => Task.CompletedTask;
 
     /// <inheritdoc />

app/MindWork AI Studio/Chat/ContentText.cs

@@ -1,3 +1,5 @@
+using System.Text.Json.Serialization;
+
 using AIStudio.Provider;
 using AIStudio.Settings;
 
@@ -17,14 +19,19 @@ public sealed class ContentText : IContent
     #region Implementation of IContent
 
     /// <inheritdoc />
+    [JsonIgnore]
     public bool InitialRemoteWait { get; set; }
 
     /// <inheritdoc />
+    // [JsonIgnore]
     public bool IsStreaming { get; set; }
 
     /// <inheritdoc />
+    [JsonIgnore]
     public Func<Task> StreamingDone { get; set; } = () => Task.CompletedTask;
 
+    /// <inheritdoc />
+    [JsonIgnore]
     public Func<Task> StreamingEvent { get; set; } = () => Task.CompletedTask;
 
     /// <inheritdoc />

app/MindWork AI Studio/Chat/IContent.cs

@@ -1,3 +1,5 @@
+using System.Text.Json.Serialization;
+
 using AIStudio.Provider;
 using AIStudio.Settings;
 
@@ -6,6 +8,8 @@ namespace AIStudio.Chat;
 /// <summary>
 /// The interface for any content in the chat.
 /// </summary>
+[JsonDerivedType(typeof(ContentText), typeDiscriminator: "text")]
+[JsonDerivedType(typeof(ContentImage), typeDiscriminator: "image")]
 public interface IContent
 {
     /// <summary>
@@ -13,22 +17,26 @@ public interface IContent
     /// Does not indicate that the stream is finished; it only indicates that we are
     /// waiting for the first response, i.e., wait for the remote to pick up the request.
     /// </summary>
+    [JsonIgnore]
     public bool InitialRemoteWait { get; set; }
 
     /// <summary>
     /// Indicates whether the content is streaming right now. False, if the content is
     /// either static or the stream has finished.
     /// </summary>
+    [JsonIgnore]
     public bool IsStreaming { get; set; }
 
     /// <summary>
     /// An action that is called when the content was changed during streaming.
     /// </summary>
+    [JsonIgnore]
     public Func<Task> StreamingEvent { get; set; }
 
     /// <summary>
     /// An action that is called when the streaming is done.
     /// </summary>
+    [JsonIgnore]
     public Func<Task> StreamingDone { get; set; }
     
     /// <summary>

app/MindWork AI Studio/Components/AssistantBase.razor

@@ -0,0 +1,39 @@
+@using AIStudio.Chat
+<MudText Typo="Typo.h3" Class="mb-2 mr-3">
+    @this.Title
+</MudText>
+
+<InnerScrolling HeaderHeight="12.3em">
+    <ChildContent>
+        <MudForm @ref="@this.form" @bind-IsValid="@this.inputIsValid" @bind-Errors="@this.inputIssues" Class="pr-2">
+            <MudText Typo="Typo.body1" Align="Align.Justify" Class="mb-6">
+                @this.Description
+            </MudText>
+
+            @if (this.Body is not null)
+            {
+                @this.Body
+            }
+        </MudForm>
+
+        @if (this.inputIssues.Any())
+        {
+            <MudPaper Class="pr-2 mt-3" Outlined="@true">
+                <MudText Typo="Typo.h6">Issues</MudText>
+                <MudList T="string">
+                    @foreach (var issue in this.inputIssues)
+                    {
+                        <MudListItem Icon="@Icons.Material.Filled.Error" IconColor="Color.Error">
+                            @issue
+                        </MudListItem>
+                    }
+                </MudList>
+            </MudPaper>
+        }
+
+        @if (this.resultingContentBlock is not null)
+        {
+            <ContentBlockComponent Role="@this.resultingContentBlock.Role" Type="@this.resultingContentBlock.ContentType" Time="@this.resultingContentBlock.Time" Content="@this.resultingContentBlock.Content" Class="mr-2"/>
+        }
+    </ChildContent>
+</InnerScrolling>

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

@@ -0,0 +1,122 @@
+using AIStudio.Chat;
+using AIStudio.Provider;
+using AIStudio.Settings;
+
+using Microsoft.AspNetCore.Components;
+
+namespace AIStudio.Components;
+
+public abstract partial class AssistantBase : ComponentBase
+{
+    [Inject]
+    protected SettingsManager SettingsManager { get; set; } = null!;
+    
+    [Inject]
+    protected IJSRuntime JsRuntime { get; init; } = null!;
+
+    [Inject]
+    protected Random RNG { get; set; } = null!;
+    
+    protected abstract string Title { get; }
+    
+    protected abstract string Description { get; }
+    
+    protected abstract string SystemPrompt { get; }
+    
+    private protected virtual RenderFragment? Body => null;
+
+    protected static readonly Dictionary<string, object?> USER_INPUT_ATTRIBUTES = new();
+    
+    protected AIStudio.Settings.Provider providerSettings;
+    protected MudForm? form;
+    protected bool inputIsValid;
+    
+    private ChatThread? chatThread;
+    private ContentBlock? resultingContentBlock;
+    private string[] inputIssues = [];
+    
+    #region Overrides of ComponentBase
+
+    protected override async Task OnParametersSetAsync()
+    {
+        // Configure the spellchecking for the user input:
+        this.SettingsManager.InjectSpellchecking(USER_INPUT_ATTRIBUTES);
+        
+        await base.OnParametersSetAsync();
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        // Reset the validation when not editing and on the first render.
+        // We don't want to show validation errors when the user opens the dialog.
+        if(firstRender)
+            this.form?.ResetValidation();
+        
+        await base.OnAfterRenderAsync(firstRender);
+    }
+
+    #endregion
+    
+    protected string? ValidatingProvider(AIStudio.Settings.Provider provider)
+    {
+        if(provider.UsedProvider == Providers.NONE)
+            return "Please select a provider.";
+        
+        return null;
+    }
+    
+    protected void CreateChatThread()
+    {
+        this.chatThread = new()
+        {
+            WorkspaceId = Guid.Empty,
+            ChatId = Guid.NewGuid(),
+            Name = string.Empty,
+            Seed = this.RNG.Next(),
+            SystemPrompt = this.SystemPrompt,
+            Blocks = [],
+        };
+    }
+    
+    protected DateTimeOffset AddUserRequest(string request)
+    {
+        var time = DateTimeOffset.Now;
+        this.chatThread!.Blocks.Add(new ContentBlock
+        {
+            Time = time,
+            ContentType = ContentType.TEXT,
+            Role = ChatRole.USER,
+            Content = new ContentText
+            {
+                Text = request,
+            },
+        });
+        
+        return time;
+    }
+
+    protected async Task AddAIResponseAsync(DateTimeOffset time)
+    {
+        var aiText = new ContentText
+        {
+            // We have to wait for the remote
+            // for the content stream: 
+            InitialRemoteWait = true,
+        };
+
+        this.resultingContentBlock = new ContentBlock
+        {
+            Time = time,
+            ContentType = ContentType.TEXT,
+            Role = ChatRole.AI,
+            Content = aiText,
+        };
+        
+        this.chatThread?.Blocks.Add(this.resultingContentBlock);
+        
+        // Use the selected provider to get the AI response.
+        // By awaiting this line, we wait for the entire
+        // content to be streamed.
+        await aiText.CreateFromProviderAsync(this.providerSettings.CreateProvider(), this.JsRuntime, this.SettingsManager, this.providerSettings.Model, this.chatThread);
+    }
+}

app/MindWork AI Studio/Components/AssistantBaseCore.cs

@@ -0,0 +1,19 @@
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Rendering;
+
+namespace AIStudio.Components;
+
+//
+// See https://stackoverflow.com/a/77300384/2258393 for why this class is needed
+//
+
+public abstract class AssistantBaseCore : AssistantBase
+{
+    private protected sealed override RenderFragment Body => this.BuildRenderTree;
+
+    // Allow content to be provided by a .razor file but without 
+    // overriding the content of the base class
+    protected new virtual void BuildRenderTree(RenderTreeBuilder builder)
+    {
+    }
+}

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

@@ -0,0 +1,26 @@
+<MudItem xs="3">
+    <MudCard Outlined="@true" Style="border-width: 2px; border-color: #0d47a1; border-radius: 12px; border-style: solid;">
+        <MudCardHeader>
+            <CardHeaderContent>
+                <MudStack AlignItems="AlignItems.Center" Row="@true">
+                    <MudIcon Icon="@this.Icon" Size="Size.Large" Color="Color.Primary"/>
+                    <MudText Typo="Typo.h6">
+                        @this.Name
+                    </MudText>
+                </MudStack>
+            </CardHeaderContent>
+        </MudCardHeader>
+        <MudCardContent>
+            <MudStack>
+                <MudText>
+                    @this.Description
+                </MudText>
+            </MudStack>
+        </MudCardContent>
+        <MudCardActions>
+            <MudButton Size="Size.Large" Variant="Variant.Filled" StartIcon="@this.Icon" Color="Color.Default" Href="@this.Link">
+                @this.ButtonText
+            </MudButton>
+        </MudCardActions>
+    </MudCard>
+</MudItem>

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

@@ -0,0 +1,21 @@
+using Microsoft.AspNetCore.Components;
+
+namespace AIStudio.Components.Blocks;
+
+public partial class AssistantBlock : ComponentBase
+{
+    [Parameter]
+    public string Name { get; set; } = string.Empty;
+    
+    [Parameter]
+    public string Description { get; set; } = string.Empty;
+    
+    [Parameter]
+    public string Icon { get; set; } = Icons.Material.Filled.DisabledByDefault;
+    
+    [Parameter]
+    public string ButtonText { get; set; } = "Start";
+    
+    [Parameter]
+    public string Link { get; set; } = string.Empty;
+}

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

@@ -13,6 +13,15 @@ public partial class Changelog
     
     public static readonly Log[] LOGS = 
     [
+        new (165, "v0.8.3, build 165 (2024-07-25 13:25 UTC)", "v0.8.3.md"),
+        new (164, "v0.8.2, build 164 (2024-07-16 18:03 UTC)", "v0.8.2.md"),
+        new (163, "v0.8.1, build 163 (2024-07-16 08:32 UTC)", "v0.8.1.md"),
+        new (162, "v0.8.0, build 162 (2024-07-14 19:39 UTC)", "v0.8.0.md"),
+        new (161, "v0.7.1, build 161 (2024-07-13 11:42 UTC)", "v0.7.1.md"),
+        new (160, "v0.7.0, build 160 (2024-07-13 08:21 UTC)", "v0.7.0.md"),
+        new (159, "v0.6.3, build 159 (2024-07-03 18:26 UTC)", "v0.6.3.md"),
+        new (158, "v0.6.2, build 158 (2024-07-01 18:03 UTC)", "v0.6.2.md"),
+        new (157, "v0.6.1, build 157 (2024-06-30 19:00 UTC)", "v0.6.1.md"),
         new (156, "v0.6.0, build 156 (2024-06-30 12:49 UTC)", "v0.6.0.md"),
         new (155, "v0.5.2, build 155 (2024-06-25 18:07 UTC)", "v0.5.2.md"),
         new (154, "v0.5.1, build 154 (2024-06-25 15:35 UTC)", "v0.5.1.md"),

app/MindWork AI Studio/Components/Blocks/ExpansionPanel.razor

@@ -1,4 +1,4 @@
-<MudExpansionPanel Class="border-solid border rounded-lg" IsInitiallyExpanded="@this.IsExpanded">
+<MudExpansionPanel Class="border-solid border rounded-lg" Expanded="@this.IsExpanded">
     <TitleContent>
         <div class="d-flex align-center">
             <MudIcon Icon="@this.HeaderIcon" Size="@this.IconSize" Color="@this.IconColor" class="mr-3"/>

app/MindWork AI Studio/Components/Blocks/ITreeItem.cs

@@ -0,0 +1,3 @@
+namespace AIStudio.Components.Blocks;
+
+public interface ITreeItem;

app/MindWork AI Studio/Components/Blocks/InnerScrolling.razor

@@ -1,4 +1,4 @@
-@inherits AIStudio.Tools.MSGComponentBase
+@inherits MSGComponentBase
 
 <div class="d-flex flex-column" style="@this.Height">
     <div class="flex-auto overflow-auto">

app/MindWork AI Studio/Components/Blocks/InnerScrolling.razor.cs

@@ -51,6 +51,11 @@ public partial class InnerScrolling : MSGComponentBase
         return Task.CompletedTask;
     }
 
+    public override Task<TResult?> ProcessMessageWithResult<TPayload, TResult>(ComponentBase? sendingComponent, Event triggeredEvent, TPayload? data) where TResult : default where TPayload : default
+    {
+        return Task.FromResult(default(TResult));
+    }
+
     #endregion
 
     private string Height => $"height: calc(100vh - {this.HeaderHeight} - {this.MainLayout.AdditionalHeight});";

app/MindWork AI Studio/Components/Blocks/MudTextList.razor

@@ -1,7 +1,7 @@
-<MudList Clickable="@this.Clickable" Class="@this.Classes">
+<MudList T="string" ReadOnly="@(!this.Clickable)" Class="@this.Classes">
     @foreach(var item in this.Items)
     {
-        <MudListItem Icon="@this.Icon" Style="display: flex; align-items: flex-start;">
+        <MudListItem T="string" Icon="@this.Icon" Style="display: flex; align-items: flex-start;">
             <MudText Typo="Typo.body1" Style="text-align: justify; hyphens: auto;"><b>@item.Header:</b> @item.Text</MudText>
         </MudListItem>
     }

app/MindWork AI Studio/Components/Blocks/TreeButton.cs

@@ -0,0 +1,3 @@
+namespace AIStudio.Components.Blocks;
+
+public readonly record struct TreeButton(WorkspaceBranch Branch, int Depth, string Text, string Icon, Func<Task> Action) : ITreeItem;

app/MindWork AI Studio/Components/Blocks/TreeDivider.cs

@@ -0,0 +1,3 @@
+namespace AIStudio.Components.Blocks;
+
+public readonly record struct TreeDivider : ITreeItem;

app/MindWork AI Studio/Components/Blocks/TreeItemData.cs

@@ -0,0 +1,22 @@
+namespace AIStudio.Components.Blocks;
+
+public class TreeItemData : ITreeItem
+{
+    public WorkspaceBranch Branch { get; init; } = WorkspaceBranch.NONE;
+    
+    public int Depth { get; init; }
+    
+    public string Text { get; init; } = string.Empty;
+    
+    public string ShortenedText => Text.Length > 30 ? this.Text[..30] + "..." : this.Text;
+
+    public string Icon { get; init; } = string.Empty;
+
+    public TreeItemType Type { get; init; }
+
+    public string Path { get; init; } = string.Empty;
+
+    public bool Expandable { get; init; } = true;
+
+    public IReadOnlyCollection<TreeItemData<ITreeItem>> Children { get; init; } = [];
+}

app/MindWork AI Studio/Components/Blocks/TreeItemType.cs

@@ -0,0 +1,9 @@
+namespace AIStudio.Components.Blocks;
+
+public enum TreeItemType
+{
+    NONE,
+    
+    CHAT,
+    WORKSPACE,
+}

app/MindWork AI Studio/Components/Blocks/WorkspaceBranch.cs

@@ -0,0 +1,9 @@
+namespace AIStudio.Components.Blocks;
+
+public enum WorkspaceBranch
+{
+    NONE,
+    
+    WORKSPACES,
+    TEMPORARY_CHATS,
+}

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

@@ -0,0 +1,88 @@
+<MudTreeView T="ITreeItem" Items="@this.treeItems" SelectionMode="SelectionMode.SingleSelection" Hover="@true" ExpandOnClick="@true">
+    <ItemTemplate Context="item">
+        @switch (item.Value)
+        {
+            case TreeDivider:
+                <li style="min-height: 1em;">
+                    <MudDivider Style="margin-top: 1em; width: 90%; border-width: 3pt;"/>
+                </li>
+                break;
+                
+            case TreeItemData treeItem:
+                @if (treeItem.Type is TreeItemType.CHAT)
+                {
+                    <MudTreeViewItem T="ITreeItem" Icon="@treeItem.Icon" Value="@item.Value" CanExpand="@treeItem.Expandable" Items="@treeItem.Children" OnClick="() => this.LoadChat(treeItem.Path, true)">
+                        <BodyContent>
+                            <div style="display: grid; grid-template-columns: 1fr auto; align-items: center; width: 100%">
+                                <MudText Style="justify-self: start;">
+                                    @if (string.IsNullOrWhiteSpace(treeItem.Text))
+                                    {
+                                        @("Empty chat")
+                                    }
+                                    else
+                                    {
+                                        @treeItem.ShortenedText
+                                    }
+                                </MudText>
+                                <div style="justify-self: end;">
+                                    
+                                    <MudTooltip Text="Move to workspace" Placement="@WORKSPACE_ITEM_TOOLTIP_PLACEMENT">
+                                        <MudIconButton Icon="@Icons.Material.Filled.MoveToInbox" Size="Size.Medium" Color="Color.Inherit" OnClick="() => this.MoveChat(treeItem.Path)"/>
+                                    </MudTooltip>
+                                    
+                                    <MudTooltip Text="Rename" Placement="@WORKSPACE_ITEM_TOOLTIP_PLACEMENT">
+                                        <MudIconButton Icon="@Icons.Material.Filled.Edit" Size="Size.Medium" Color="Color.Inherit" OnClick="() => this.RenameChat(treeItem.Path)"/>
+                                    </MudTooltip>
+
+                                    <MudTooltip Text="Delete" Placement="@WORKSPACE_ITEM_TOOLTIP_PLACEMENT">
+                                        <MudIconButton Icon="@Icons.Material.Filled.Delete" Size="Size.Medium" Color="Color.Inherit" OnClick="() => this.DeleteChat(treeItem.Path)"/>
+                                    </MudTooltip>
+                                </div>
+                            </div>
+                        </BodyContent>
+                    </MudTreeViewItem>
+                }
+                else if (treeItem.Type is TreeItemType.WORKSPACE)
+                {
+                    <MudTreeViewItem T="ITreeItem" Icon="@treeItem.Icon" Value="@item.Value" CanExpand="@treeItem.Expandable" Items="@treeItem.Children">
+                        <BodyContent>
+                            <div style="display: grid; grid-template-columns: 1fr auto; align-items: center; width: 100%">
+                                <MudText Style="justify-self: start;">@treeItem.Text</MudText>
+                                <div style="justify-self: end;">
+                                    <MudTooltip Text="Rename" Placement="@WORKSPACE_ITEM_TOOLTIP_PLACEMENT">
+                                        <MudIconButton Icon="@Icons.Material.Filled.Edit" Size="Size.Medium" Color="Color.Inherit" OnClick="() => this.RenameWorkspace(treeItem.Path)"/>
+                                    </MudTooltip>
+
+                                    <MudTooltip Text="Delete" Placement="@WORKSPACE_ITEM_TOOLTIP_PLACEMENT">
+                                        <MudIconButton Icon="@Icons.Material.Filled.Delete" Size="Size.Medium" Color="Color.Inherit" OnClick="() => this.DeleteWorkspace(treeItem.Path)"/>
+                                    </MudTooltip>
+                                </div>
+                            </div>
+                        </BodyContent>
+                    </MudTreeViewItem>
+                }
+                else
+                {
+                    <MudTreeViewItem T="ITreeItem" Icon="@treeItem.Icon" Value="@item.Value" CanExpand="@treeItem.Expandable" Items="@treeItem.Children">
+                        <BodyContent>
+                            <div style="display: grid; grid-template-columns: 1fr auto; align-items: center; width: 100%">
+                                <MudText Style="justify-self: start;">@treeItem.Text</MudText>
+                            </div>
+                        </BodyContent>
+                    </MudTreeViewItem>
+                }
+                break;
+                
+            case TreeButton treeButton:
+                <li>
+                    <div class="mud-treeview-item-content" style="background-color: unset;">
+                        <div class="mud-treeview-item-arrow"></div>
+                        <MudButton StartIcon="@treeButton.Icon" Variant="Variant.Filled" OnClick="treeButton.Action">
+                            @treeButton.Text
+                        </MudButton>
+                    </div>
+                </li>
+                break;
+        }
+    </ItemTemplate>
+</MudTreeView>

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

@@ -0,0 +1,533 @@
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+using AIStudio.Chat;
+using AIStudio.Components.CommonDialogs;
+using AIStudio.Settings;
+using AIStudio.Tools;
+
+using Microsoft.AspNetCore.Components;
+
+using DialogOptions = AIStudio.Components.CommonDialogs.DialogOptions;
+
+namespace AIStudio.Components.Blocks;
+
+public partial class Workspaces : ComponentBase
+{
+    [Inject]
+    private SettingsManager SettingsManager { get; set; } = null!;
+    
+    [Inject]
+    private IDialogService DialogService { get; set; } = null!;
+    
+    [Inject]
+    public Random RNG { get; set; } = null!;
+    
+    [Parameter]
+    public ChatThread? CurrentChatThread { get; set; }
+    
+    [Parameter]
+    public EventCallback<ChatThread> CurrentChatThreadChanged { get; set; }
+
+    [Parameter]
+    public Func<Task> LoadedChatWasChanged { get; set; } = () => Task.CompletedTask;
+
+    private const Placement WORKSPACE_ITEM_TOOLTIP_PLACEMENT = Placement.Bottom;
+    
+    private static readonly JsonSerializerOptions JSON_OPTIONS = new()
+    {
+        WriteIndented = true,
+        AllowTrailingCommas = true,
+        PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
+        DictionaryKeyPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true,
+        Converters =
+        {
+            new JsonStringEnumConverter(JsonNamingPolicy.SnakeCaseUpper),
+        }
+    };
+
+    private readonly List<TreeItemData<ITreeItem>> treeItems = new();
+    
+    #region Overrides of ComponentBase
+
+    protected override async Task OnInitializedAsync()
+    {
+        //
+        // Notice: In order to get the server-based loading to work, we need to respect the following rules:
+        // - We must have initial tree items
+        // - Those initial tree items cannot have children
+        // - When assigning the tree items to the MudTreeViewItem component, we must set the Value property to the value of the item
+        //
+        
+        await this.LoadTreeItems();
+        await base.OnInitializedAsync();
+    }
+
+    #endregion
+
+    private async Task LoadTreeItems()
+    {
+        this.treeItems.Clear();
+        this.treeItems.Add(new TreeItemData<ITreeItem>
+        {
+            Expandable = true,
+            Value = new TreeItemData
+            {
+                Depth = 0,
+                Branch = WorkspaceBranch.WORKSPACES,
+                Text = "Workspaces",
+                Icon = Icons.Material.Filled.Folder,
+                Expandable = true,
+                Path = "root",
+                Children = await this.LoadWorkspaces(),
+            },
+        });
+
+        this.treeItems.Add(new TreeItemData<ITreeItem>
+        {
+            Expandable = false,
+            Value = new TreeDivider(),
+        });
+        
+        this.treeItems.Add(new TreeItemData<ITreeItem>
+        {
+            Expandable = true,
+            Value = new TreeItemData
+            {
+                Depth = 0,
+                Branch = WorkspaceBranch.TEMPORARY_CHATS,
+                Text = "Temporary chats",
+                Icon = Icons.Material.Filled.Timer,
+                Expandable = true,
+                Path = "temp",
+                Children = await this.LoadTemporaryChats(),
+            },
+        });
+    }
+
+    private async Task<IReadOnlyCollection<TreeItemData<ITreeItem>>> LoadTemporaryChats()
+    {
+        var tempChildren = new List<TreeItemData<ITreeItem>>();
+
+        //
+        // Search for workspace folders in the data directory:
+        //
+                        
+        // Get the workspace root directory: 
+        var temporaryDirectories = Path.Join(SettingsManager.DataDirectory, "tempChats");
+                        
+        // Ensure the directory exists:
+        Directory.CreateDirectory(temporaryDirectories);
+                        
+        // Enumerate the workspace directories:
+        foreach (var tempChatDirPath in Directory.EnumerateDirectories(temporaryDirectories))
+        {
+            // Read the `name` file:
+            var chatNamePath = Path.Join(tempChatDirPath, "name");
+            var chatName = await File.ReadAllTextAsync(chatNamePath, Encoding.UTF8);
+                            
+            tempChildren.Add(new TreeItemData<ITreeItem>
+            {
+                Expandable = false,
+                Value = new TreeItemData
+                {
+                    Type = TreeItemType.CHAT,
+                    Depth = 1,
+                    Branch = WorkspaceBranch.TEMPORARY_CHATS,
+                    Text = chatName,
+                    Icon = Icons.Material.Filled.Timer,
+                    Expandable = false,
+                    Path = tempChatDirPath,
+                },
+            });
+        }
+                        
+        return tempChildren;
+    }
+    
+    public async Task<string> LoadWorkspaceName(Guid workspaceId)
+    {
+        if(workspaceId == Guid.Empty)
+            return string.Empty;
+        
+        var workspacePath = Path.Join(SettingsManager.DataDirectory, "workspaces", workspaceId.ToString());
+        var workspaceNamePath = Path.Join(workspacePath, "name");
+        return await File.ReadAllTextAsync(workspaceNamePath, Encoding.UTF8);
+    }
+    
+    private async Task<IReadOnlyCollection<TreeItemData<ITreeItem>>> LoadWorkspaces()
+    {
+        var workspaces = new List<TreeItemData<ITreeItem>>();
+        
+        //
+        // Search for workspace folders in the data directory:
+        //
+
+        // Get the workspace root directory: 
+        var workspaceDirectories = Path.Join(SettingsManager.DataDirectory, "workspaces");
+
+        // Ensure the directory exists:
+        Directory.CreateDirectory(workspaceDirectories);
+
+        // Enumerate the workspace directories:
+        foreach (var workspaceDirPath in Directory.EnumerateDirectories(workspaceDirectories))
+        {
+            // Read the `name` file:
+            var workspaceNamePath = Path.Join(workspaceDirPath, "name");
+            var workspaceName = await File.ReadAllTextAsync(workspaceNamePath, Encoding.UTF8);
+                                
+            workspaces.Add(new TreeItemData<ITreeItem>
+            {
+                Expandable = true,
+                Value = new TreeItemData
+                {
+                    Type = TreeItemType.WORKSPACE,
+                    Depth = 1,
+                    Branch = WorkspaceBranch.WORKSPACES,
+                    Text = workspaceName,
+                    Icon = Icons.Material.Filled.Description,
+                    Expandable = true,
+                    Path = workspaceDirPath,
+                    Children = await this.LoadWorkspaceChats(workspaceDirPath),
+                },
+            });
+        }
+                            
+        workspaces.Add(new TreeItemData<ITreeItem>
+        {
+            Expandable = false,
+            Value = new TreeButton(WorkspaceBranch.WORKSPACES, 1, "Add workspace",Icons.Material.Filled.LibraryAdd, this.AddWorkspace),
+        });
+        return workspaces;
+    }
+
+    private async Task<IReadOnlyCollection<TreeItemData<ITreeItem>>> LoadWorkspaceChats(string workspacePath)
+    {
+        var workspaceChats = new List<TreeItemData<ITreeItem>>();
+        
+        // Enumerate the workspace directory:
+        foreach (var chatPath in Directory.EnumerateDirectories(workspacePath))
+        {
+            // Read the `name` file:
+            var chatNamePath = Path.Join(chatPath, "name");
+            var chatName = await File.ReadAllTextAsync(chatNamePath, Encoding.UTF8);
+                                
+            workspaceChats.Add(new TreeItemData<ITreeItem>
+            {
+                Expandable = false,
+                Value = new TreeItemData
+                {
+                    Type = TreeItemType.CHAT,
+                    Depth = 2,
+                    Branch = WorkspaceBranch.WORKSPACES,
+                    Text = chatName,
+                    Icon = Icons.Material.Filled.Chat,
+                    Expandable = false,
+                    Path = chatPath,
+                },
+            });
+        }
+                            
+        workspaceChats.Add(new TreeItemData<ITreeItem>
+        {
+            Expandable = false,
+            Value = new TreeButton(WorkspaceBranch.WORKSPACES, 2, "Add chat",Icons.Material.Filled.AddComment, () => this.AddChat(workspacePath)),
+        });
+        
+        return workspaceChats;
+    }
+
+    public async Task StoreChat(ChatThread chat)
+    {
+        string chatDirectory;
+        if (chat.WorkspaceId == Guid.Empty)
+            chatDirectory = Path.Join(SettingsManager.DataDirectory, "tempChats", chat.ChatId.ToString());
+        else
+            chatDirectory = Path.Join(SettingsManager.DataDirectory, "workspaces", chat.WorkspaceId.ToString(), chat.ChatId.ToString());
+        
+        // Ensure the directory exists:
+        Directory.CreateDirectory(chatDirectory);
+        
+        // Save the chat name:
+        var chatNamePath = Path.Join(chatDirectory, "name");
+        await File.WriteAllTextAsync(chatNamePath, chat.Name);
+        
+        // Save the thread as thread.json:
+        var chatPath = Path.Join(chatDirectory, "thread.json");
+        await File.WriteAllTextAsync(chatPath, JsonSerializer.Serialize(chat, JSON_OPTIONS), Encoding.UTF8);
+        
+        // Reload the tree items:
+        await this.LoadTreeItems();
+        this.StateHasChanged();
+    }
+
+    private async Task<ChatThread?> LoadChat(string? chatPath, bool switchToChat)
+    {
+        if(string.IsNullOrWhiteSpace(chatPath))
+            return null;
+
+        if(!Directory.Exists(chatPath))
+            return null;
+        
+        // Check if the chat has unsaved changes:
+        if (switchToChat && await MessageBus.INSTANCE.SendMessageUseFirstResult<bool, bool>(this, Event.HAS_CHAT_UNSAVED_CHANGES))
+        {
+            var dialogParameters = new DialogParameters
+            {
+                { "Message", "Are you sure you want to load another chat? All unsaved changes will be lost." },
+            };
+        
+            var dialogReference = await this.DialogService.ShowAsync<ConfirmDialog>("Load Chat", dialogParameters, DialogOptions.FULLSCREEN);
+            var dialogResult = await dialogReference.Result;
+            if (dialogResult is null || dialogResult.Canceled)
+                return null;
+        }
+
+        try
+        {
+            var chatData = await File.ReadAllTextAsync(Path.Join(chatPath, "thread.json"), Encoding.UTF8);
+            var chat = JsonSerializer.Deserialize<ChatThread>(chatData, JSON_OPTIONS);
+            if (switchToChat)
+            {
+                this.CurrentChatThread = chat;
+                await this.CurrentChatThreadChanged.InvokeAsync(this.CurrentChatThread);
+                await this.LoadedChatWasChanged();
+            }
+            
+            return chat;
+        }
+        catch (Exception e)
+        {
+            Console.WriteLine(e);
+        }
+        
+        return null;
+    }
+
+    public async Task DeleteChat(string? chatPath, bool askForConfirmation = true, bool unloadChat = true)
+    {
+        var chat = await this.LoadChat(chatPath, false);
+        if (chat is null)
+            return;
+
+        if (askForConfirmation)
+        {
+            var workspaceName = await this.LoadWorkspaceName(chat.WorkspaceId);
+            var dialogParameters = new DialogParameters
+            {
+                {
+                    "Message", (chat.WorkspaceId == Guid.Empty) switch
+                    {
+                        true => $"Are you sure you want to delete the temporary chat '{chat.Name}'?",
+                        false => $"Are you sure you want to delete the chat '{chat.Name}' in the workspace '{workspaceName}'?",
+                    }
+                },
+            };
+
+            var dialogReference = await this.DialogService.ShowAsync<ConfirmDialog>("Delete Chat", dialogParameters, DialogOptions.FULLSCREEN);
+            var dialogResult = await dialogReference.Result;
+            if (dialogResult is null || dialogResult.Canceled)
+                return;
+        }
+
+        string chatDirectory;
+        if (chat.WorkspaceId == Guid.Empty)
+            chatDirectory = Path.Join(SettingsManager.DataDirectory, "tempChats", chat.ChatId.ToString());
+        else
+            chatDirectory = Path.Join(SettingsManager.DataDirectory, "workspaces", chat.WorkspaceId.ToString(), chat.ChatId.ToString());
+
+        Directory.Delete(chatDirectory, true);
+        await this.LoadTreeItems();
+        
+        if(unloadChat && this.CurrentChatThread?.ChatId == chat.ChatId)
+        {
+            this.CurrentChatThread = null;
+            await this.CurrentChatThreadChanged.InvokeAsync(this.CurrentChatThread);
+            await this.LoadedChatWasChanged();
+        }
+    }
+
+    private async Task RenameChat(string? chatPath)
+    {
+        var chat = await this.LoadChat(chatPath, false);
+        if (chat is null)
+            return;
+        
+        var dialogParameters = new DialogParameters
+        {
+            { "Message", $"Please enter a new or edit the name for your chat '{chat.Name}':" },
+            { "UserInput", chat.Name },
+            { "ConfirmText", "Rename" },
+            { "ConfirmColor", Color.Info },
+        };
+        
+        var dialogReference = await this.DialogService.ShowAsync<SingleInputDialog>("Rename Chat", dialogParameters, DialogOptions.FULLSCREEN);
+        var dialogResult = await dialogReference.Result;
+        if (dialogResult is null || dialogResult.Canceled)
+            return;
+
+        chat.Name = (dialogResult.Data as string)!;
+        await this.StoreChat(chat);
+        await this.LoadTreeItems();
+    }
+    
+    private async Task RenameWorkspace(string? workspacePath)
+    {
+        if(workspacePath is null)
+            return;
+        
+        var workspaceId = Guid.Parse(Path.GetFileName(workspacePath));
+        var workspaceName = await this.LoadWorkspaceName(workspaceId);
+        var dialogParameters = new DialogParameters
+        {
+            { "Message", $"Please enter a new or edit the name for your workspace '{workspaceName}':" },
+            { "UserInput", workspaceName },
+            { "ConfirmText", "Rename" },
+            { "ConfirmColor", Color.Info },
+        };
+        
+        var dialogReference = await this.DialogService.ShowAsync<SingleInputDialog>("Rename Workspace", dialogParameters, DialogOptions.FULLSCREEN);
+        var dialogResult = await dialogReference.Result;
+        if (dialogResult is null || dialogResult.Canceled)
+            return;
+        
+        var alteredWorkspaceName = (dialogResult.Data as string)!;
+        var workspaceNamePath = Path.Join(workspacePath, "name");
+        await File.WriteAllTextAsync(workspaceNamePath, alteredWorkspaceName, Encoding.UTF8);
+        await this.LoadTreeItems();
+    }
+
+    private async Task AddWorkspace()
+    {
+        var dialogParameters = new DialogParameters
+        {
+            { "Message", "Please name your workspace:" },
+            { "UserInput", string.Empty },
+            { "ConfirmText", "Add workspace" },
+            { "ConfirmColor", Color.Info },
+        };
+        
+        var dialogReference = await this.DialogService.ShowAsync<SingleInputDialog>("Add Workspace", dialogParameters, DialogOptions.FULLSCREEN);
+        var dialogResult = await dialogReference.Result;
+        if (dialogResult is null || dialogResult.Canceled)
+            return;
+        
+        var workspaceId = Guid.NewGuid();
+        var workspacePath = Path.Join(SettingsManager.DataDirectory, "workspaces", workspaceId.ToString());
+        Directory.CreateDirectory(workspacePath);
+        
+        var workspaceNamePath = Path.Join(workspacePath, "name");
+        await File.WriteAllTextAsync(workspaceNamePath, (dialogResult.Data as string)!, Encoding.UTF8);
+        
+        await this.LoadTreeItems();
+    }
+    
+    private async Task DeleteWorkspace(string? workspacePath)
+    {
+        if(workspacePath is null)
+            return;
+        
+        var workspaceId = Guid.Parse(Path.GetFileName(workspacePath));
+        var workspaceName = await this.LoadWorkspaceName(workspaceId);
+        
+        // Determine how many chats are in the workspace:
+        var chatCount = Directory.EnumerateDirectories(workspacePath).Count();
+        
+        var dialogParameters = new DialogParameters
+        {
+            { "Message", $"Are you sure you want to delete the workspace '{workspaceName}'? This will also delete {chatCount} chat(s) in this workspace." },
+        };
+        
+        var dialogReference = await this.DialogService.ShowAsync<ConfirmDialog>("Delete Workspace", dialogParameters, DialogOptions.FULLSCREEN);
+        var dialogResult = await dialogReference.Result;
+        if (dialogResult is null || dialogResult.Canceled)
+            return;
+        
+        Directory.Delete(workspacePath, true);
+        await this.LoadTreeItems();
+    }
+    
+    private async Task MoveChat(string? chatPath)
+    {
+        var chat = await this.LoadChat(chatPath, false);
+        if (chat is null)
+            return;
+        
+        var dialogParameters = new DialogParameters
+        {
+            { "Message", "Please select the workspace where you want to move the chat to." },
+            { "SelectedWorkspace", chat.WorkspaceId },
+            { "ConfirmText", "Move chat" },
+        };
+        
+        var dialogReference = await this.DialogService.ShowAsync<WorkspaceSelectionDialog>("Move Chat to Workspace", dialogParameters, DialogOptions.FULLSCREEN);
+        var dialogResult = await dialogReference.Result;
+        if (dialogResult is null || dialogResult.Canceled)
+            return;
+        
+        var workspaceId = dialogResult.Data is Guid id ? id : default;
+        if (workspaceId == Guid.Empty)
+            return;
+        
+        // Delete the chat from the current workspace or the temporary storage:
+        if (chat.WorkspaceId == Guid.Empty)
+        {
+            // Case: The chat is stored in the temporary storage:
+            await this.DeleteChat(Path.Join(SettingsManager.DataDirectory, "tempChats", chat.ChatId.ToString()), askForConfirmation: false, unloadChat: false);
+        }
+        else
+        {
+            // Case: The chat is stored in a workspace.
+            await this.DeleteChat(Path.Join(SettingsManager.DataDirectory, "workspaces", chat.WorkspaceId.ToString(), chat.ChatId.ToString()), askForConfirmation: false, unloadChat: false);
+        }
+        
+        // Update the chat's workspace:
+        chat.WorkspaceId = workspaceId;
+        
+        // Handle the case where the chat is the active chat:
+        if (this.CurrentChatThread?.ChatId == chat.ChatId)
+        {
+            this.CurrentChatThread = chat;
+            await this.CurrentChatThreadChanged.InvokeAsync(this.CurrentChatThread);
+            await this.LoadedChatWasChanged();
+        }
+        
+        await this.StoreChat(chat);
+    }
+    
+    private async Task AddChat(string workspacePath)
+    {
+        // Check if the chat has unsaved changes:
+        if (await MessageBus.INSTANCE.SendMessageUseFirstResult<bool, bool>(this, Event.HAS_CHAT_UNSAVED_CHANGES))
+        {
+            var dialogParameters = new DialogParameters
+            {
+                { "Message", "Are you sure you want to create a another chat? All unsaved changes will be lost." },
+            };
+        
+            var dialogReference = await this.DialogService.ShowAsync<ConfirmDialog>("Create Chat", dialogParameters, DialogOptions.FULLSCREEN);
+            var dialogResult = await dialogReference.Result;
+            if (dialogResult is null || dialogResult.Canceled)
+                return;
+        }
+        
+        var workspaceId = Guid.Parse(Path.GetFileName(workspacePath));
+        var chat = new ChatThread
+        {
+            WorkspaceId = workspaceId,
+            ChatId = Guid.NewGuid(),
+            Name = string.Empty,
+            Seed = this.RNG.Next(),
+            SystemPrompt = "You are a helpful assistant!",
+            Blocks = [],
+        };
+        
+        var chatPath = Path.Join(workspacePath, chat.ChatId.ToString());
+        
+        await this.StoreChat(chat);
+        await this.LoadChat(chatPath, switchToChat: true);
+        await this.LoadTreeItems();
+    }
+}

app/MindWork AI Studio/Components/CommonDialogs/SingleInputDialog.razor

@@ -0,0 +1,10 @@
+<MudDialog>
+    <DialogContent>
+        <MudText Typo="Typo.body1">@this.Message</MudText>
+        <MudTextField T="string" @bind-Text="@this.UserInput" Variant="Variant.Outlined" AutoGrow="@false" Lines="1" Label="Chat name" AutoFocus="@true"/>
+    </DialogContent>
+    <DialogActions>
+        <MudButton OnClick="@this.Cancel" Variant="Variant.Filled">Cancel</MudButton>
+        <MudButton OnClick="@this.Confirm" Variant="Variant.Filled" Color="@this.ConfirmColor">@this.ConfirmText</MudButton>
+    </DialogActions>
+</MudDialog>

app/MindWork AI Studio/Components/CommonDialogs/SingleInputDialog.razor.cs

@@ -0,0 +1,25 @@
+using Microsoft.AspNetCore.Components;
+
+namespace AIStudio.Components.CommonDialogs;
+
+public partial class SingleInputDialog : ComponentBase
+{
+    [CascadingParameter]
+    private MudDialogInstance MudDialog { get; set; } = null!;
+
+    [Parameter]
+    public string Message { get; set; } = string.Empty;
+    
+    [Parameter]
+    public string UserInput { get; set; } = string.Empty;
+    
+    [Parameter]
+    public string ConfirmText { get; set; } = "OK";
+
+    [Parameter]
+    public Color ConfirmColor { get; set; } = Color.Error;
+
+    private void Cancel() => this.MudDialog.Cancel();
+    
+    private void Confirm() => this.MudDialog.Close(DialogResult.Ok(this.UserInput));
+}

app/MindWork AI Studio/Components/CommonDialogs/WorkspaceSelectionDialog.razor

@@ -0,0 +1,15 @@
+<MudDialog>
+    <DialogContent>
+        <MudText Typo="Typo.body1">@this.Message</MudText>
+        <MudList Clickable="@true" @bind-SelectedValue="@this.selectedWorkspace">
+            @foreach (var (workspaceName, workspaceId) in this.workspaces)
+            {
+                <MudListItem Text="@workspaceName" Icon="@Icons.Material.Filled.Description" Value="@workspaceId" />
+            }
+        </MudList>
+    </DialogContent>
+    <DialogActions>
+        <MudButton OnClick="@this.Cancel" Variant="Variant.Filled">Cancel</MudButton>
+        <MudButton OnClick="@this.Confirm" Variant="Variant.Filled" Color="Color.Info">@this.ConfirmText</MudButton>
+    </DialogActions>
+</MudDialog>

app/MindWork AI Studio/Components/CommonDialogs/WorkspaceSelectionDialog.razor.cs

@@ -0,0 +1,60 @@
+using System.Text;
+
+using AIStudio.Settings;
+
+using Microsoft.AspNetCore.Components;
+
+namespace AIStudio.Components.CommonDialogs;
+
+public partial class WorkspaceSelectionDialog : ComponentBase
+{
+    [CascadingParameter]
+    private MudDialogInstance MudDialog { get; set; } = null!;
+
+    [Parameter]
+    public string Message { get; set; } = string.Empty;
+    
+    [Parameter]
+    public Guid SelectedWorkspace { get; set; } = Guid.Empty;
+    
+    [Parameter]
+    public string ConfirmText { get; set; } = "OK";
+    
+    private readonly Dictionary<string, Guid> workspaces = new();
+    private object? selectedWorkspace;
+
+    #region Overrides of ComponentBase
+
+    protected override async Task OnInitializedAsync()
+    {
+        this.selectedWorkspace = this.SelectedWorkspace;
+        
+        // Get the workspace root directory: 
+        var workspaceDirectories = Path.Join(SettingsManager.DataDirectory, "workspaces");
+        if(!Directory.Exists(workspaceDirectories))
+        {
+            await base.OnInitializedAsync();
+            return;
+        }
+
+        // Enumerate the workspace directories:
+        foreach (var workspaceDirPath in Directory.EnumerateDirectories(workspaceDirectories))
+        {
+            // Read the `name` file:
+            var workspaceNamePath = Path.Join(workspaceDirPath, "name");
+            var workspaceName = await File.ReadAllTextAsync(workspaceNamePath, Encoding.UTF8);
+            
+            // Add the workspace to the list:
+            this.workspaces.Add(workspaceName, Guid.Parse(Path.GetFileName(workspaceDirPath)));
+        }
+
+        this.StateHasChanged();
+        await base.OnInitializedAsync();
+    }
+
+    #endregion
+
+    private void Cancel() => this.MudDialog.Cancel();
+    
+    private void Confirm() => this.MudDialog.Close(DialogResult.Ok(this.selectedWorkspace is Guid workspaceId ? workspaceId : default));
+}

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

@@ -1,4 +1,5 @@
 using AIStudio.Settings;
+using AIStudio.Tools;
 
 using Microsoft.AspNetCore.Components;
 
@@ -23,7 +24,12 @@ public partial class ConfigurationBase : ComponentBase
     public string OptionHelp { get; set; } = string.Empty;
     
     [Inject]
-    public SettingsManager SettingsManager { get; init; } = null!;
+    protected SettingsManager SettingsManager { get; init; } = null!;
+    
+    [Inject]
+    protected MessageBus MessageBus { get; init; } = null!;
     
     protected const string MARGIN_CLASS = "mb-6";
+
+    protected async Task InformAboutChange() => await this.MessageBus.SendMessage<bool>(this, Event.CONFIGURATION_CHANGED);
 }

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

@@ -35,5 +35,6 @@ public partial class ConfigurationOption : ConfigurationBase
     {
         this.StateUpdate(updatedState);
         await this.SettingsManager.StoreSettings();
+        await this.InformAboutChange();
     }
 }

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

@@ -30,6 +30,7 @@ public partial class ConfigurationSelect<T> : ConfigurationBase
     {
         this.SelectionUpdate(updatedValue);
         await this.SettingsManager.StoreSettings();
+        await this.InformAboutChange();
     }
     
     private static string GetClass => $"{MARGIN_CLASS} rounded-lg";

app/MindWork AI Studio/Components/ConfigurationSelectData.cs

@@ -30,4 +30,29 @@ public static class ConfigurationSelectDataFactory
         yield return new("Check every day", UpdateBehavior.DAILY);
         yield return new ("Check every week", UpdateBehavior.WEEKLY);
     }
+    
+    public static IEnumerable<ConfigurationSelectData<WorkspaceStorageBehavior>> GetWorkspaceStorageBehaviorData()
+    {
+        yield return new("Disable workspaces", WorkspaceStorageBehavior.DISABLE_WORKSPACES);
+        yield return new("Store chats automatically", WorkspaceStorageBehavior.STORE_CHATS_AUTOMATICALLY);
+        yield return new("Store chats manually", WorkspaceStorageBehavior.STORE_CHATS_MANUALLY);
+    }
+    
+    public static IEnumerable<ConfigurationSelectData<WorkspaceStorageTemporaryMaintenancePolicy>> GetWorkspaceStorageTemporaryMaintenancePolicyData()
+    {
+        yield return new("No automatic maintenance for temporary chats", WorkspaceStorageTemporaryMaintenancePolicy.NO_AUTOMATIC_MAINTENANCE);
+        yield return new("Delete temporary chats older than 7 days", WorkspaceStorageTemporaryMaintenancePolicy.DELETE_OLDER_THAN_7_DAYS);
+        yield return new("Delete temporary chats older than 30 days", WorkspaceStorageTemporaryMaintenancePolicy.DELETE_OLDER_THAN_30_DAYS);
+        yield return new("Delete temporary chats older than 90 days", WorkspaceStorageTemporaryMaintenancePolicy.DELETE_OLDER_THAN_90_DAYS);
+        yield return new("Delete temporary chats older than 180 days", WorkspaceStorageTemporaryMaintenancePolicy.DELETE_OLDER_THAN_180_DAYS);
+        yield return new("Delete temporary chats older than 1 year", WorkspaceStorageTemporaryMaintenancePolicy.DELETE_OLDER_THAN_365_DAYS);
+    }
+    
+    public static IEnumerable<ConfigurationSelectData<NavBehavior>> GetNavBehaviorData()
+    {
+        yield return new("Navigation expands on mouse hover", NavBehavior.EXPAND_ON_HOVER);
+        yield return new("Navigation never expands, but there are tooltips", NavBehavior.NEVER_EXPAND_USE_TOOLTIPS);
+        yield return new("Navigation never expands, no tooltips", NavBehavior.NEVER_EXPAND_NO_TOOLTIPS);
+        yield return new("Always expand navigation", NavBehavior.ALWAYS_EXPAND);
+    }
 }

app/MindWork AI Studio/Components/Layout/MainLayout.razor

@@ -1,33 +1,32 @@
-@inherits LayoutComponentBase
+@using AIStudio.Settings
+@inherits LayoutComponentBase
 
 <MudPaper Height="calc(100vh);" Elevation="0">
     <MudLayout>
         @if (!this.performingUpdate)
         {
             <MudDrawerContainer Class="mud-height-full absolute">
-                <MudDrawer Elevation="0" Variant="@DrawerVariant.Mini" OpenMiniOnHover="@true" Color="Color.Default">
+                <MudDrawer @bind-Open="@this.navBarOpen" MiniWidth="@NAVBAR_COLLAPSED_WIDTH" Width="@NAVBAR_EXPANDED_WIDTH" Elevation="1" Fixed="@true" Variant="@DrawerVariant.Mini" OpenMiniOnHover="@(this.SettingsManager.ConfigurationData.NavigationBehavior is NavBehavior.EXPAND_ON_HOVER)" Color="Color.Default">
                     <MudNavMenu>
-                        <MudTooltip Text="Home" Placement="Placement.Right">
-                            <MudNavLink Href="/" Match="NavLinkMatch.All" Icon="@Icons.Material.Filled.Home">Home</MudNavLink>
-                        </MudTooltip>
-                        <MudTooltip Text="Chats" Placement="Placement.Right">
-                            <MudNavLink Href="/chat" Icon="@Icons.Material.Filled.Chat">Chats</MudNavLink>
-                        </MudTooltip>
-                        <MudTooltip Text="Supporters" Placement="Placement.Right">
-                            <MudNavLink Href="/supporters" Icon="@Icons.Material.Filled.Favorite" IconColor="Color.Error">Supporters</MudNavLink>
-                        </MudTooltip>
-                        <MudTooltip Text="About" Placement="Placement.Right">
-                            <MudNavLink Href="/about" Icon="@Icons.Material.Filled.Info">About</MudNavLink>
-                        </MudTooltip>
-                        <MudTooltip Text="Settings" Placement="Placement.Right">
-                            <MudNavLink Href="/settings" Icon="@Icons.Material.Filled.Settings">Settings</MudNavLink>
-                        </MudTooltip>
+                        @foreach (var navBarItem in NAV_ITEMS)
+                        {
+                            if (this.SettingsManager.ConfigurationData.NavigationBehavior is NavBehavior.NEVER_EXPAND_USE_TOOLTIPS)
+                            {
+                                <MudTooltip Text="@navBarItem.Name" Placement="Placement.Right">
+                                    <MudNavLink Href="@navBarItem.Path" Match="@(navBarItem.MatchAll ? NavLinkMatch.All : NavLinkMatch.Prefix)" Icon="@navBarItem.Icon" IconColor="@navBarItem.IconColor">@navBarItem.Name</MudNavLink>
+                                </MudTooltip>
+                            }
+                            else
+                            {
+                                <MudNavLink Href="@navBarItem.Path" Match="@(navBarItem.MatchAll ? NavLinkMatch.All : NavLinkMatch.Prefix)" Icon="@navBarItem.Icon" IconColor="@navBarItem.IconColor">@navBarItem.Name</MudNavLink>
+                            }
+                        }
                     </MudNavMenu>
                 </MudDrawer>
             </MudDrawerContainer>
         }
 
-        <MudMainContent Class="mud-height-full pt-1">
+        <MudMainContent Class="mud-height-full pt-1" Style="@this.PaddingLeft">
             <MudContainer Fixed="@true" Class="mud-height-full" Style="margin-left: 5em; width: calc(100% - 5em);">
                 @if (!this.performingUpdate && this.IsUpdateAlertVisible)
                 {

app/MindWork AI Studio/Components/Layout/MainLayout.razor.cs

@@ -3,6 +3,7 @@ using AIStudio.Settings;
 using AIStudio.Tools;
 
 using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Routing;
 
 using DialogOptions = AIStudio.Components.CommonDialogs.DialogOptions;
 
@@ -20,23 +21,49 @@ public partial class MainLayout : LayoutComponentBase, IMessageBusReceiver
     private MessageBus MessageBus { get; init; } = null!;
     
     [Inject]
-    public IDialogService DialogService { get; init; } = null!;
+    private IDialogService DialogService { get; init; } = null!;
     
     [Inject]
-    public Rust Rust { get; init; } = null!;
+    private Rust Rust { get; init; } = null!;
+    
+    [Inject]
+    private ISnackbar Snackbar { get; init; } = null!;
+    
+    [Inject]
+    private NavigationManager NavigationManager { get; init; } = null!;
 
     public string AdditionalHeight { get; private set; } = "0em";
     
+    private string PaddingLeft => this.navBarOpen ? $"padding-left: {NAVBAR_EXPANDED_WIDTH_INT - NAVBAR_COLLAPSED_WIDTH_INT}em;" : "padding-left: 0em;";
+    
+    private const int NAVBAR_COLLAPSED_WIDTH_INT = 4;
+    private const int NAVBAR_EXPANDED_WIDTH_INT = 10;
+    private static readonly string NAVBAR_COLLAPSED_WIDTH = $"{NAVBAR_COLLAPSED_WIDTH_INT}em";
+    private static readonly string NAVBAR_EXPANDED_WIDTH = $"{NAVBAR_EXPANDED_WIDTH_INT}em";
+    
+    private bool navBarOpen;
     private bool isUpdateAvailable;
     private bool performingUpdate;
     private bool userDismissedUpdate;
     private string updateToVersion = string.Empty;
     private UpdateResponse? currentUpdateResponse;
     
+    private static readonly IReadOnlyCollection<NavBarItem> NAV_ITEMS = new List<NavBarItem>
+    {
+        new("Home", Icons.Material.Filled.Home, Color.Default, "/", true),
+        new("Chat", Icons.Material.Filled.Chat, Color.Default, "/chat", false),
+        new("Assistants", Icons.Material.Filled.Apps, Color.Default ,"/assistants", false),
+        new("Supporters", Icons.Material.Filled.Favorite, Color.Error ,"/supporters", false),
+        new("About", Icons.Material.Filled.Info, Color.Default ,"/about", false),
+        new("Settings", Icons.Material.Filled.Settings, Color.Default ,"/settings", false),
+    };
+    
     #region Overrides of ComponentBase
 
     protected override async Task OnInitializedAsync()
     {
+        this.NavigationManager.RegisterLocationChangingHandler(this.OnLocationChanging);
+        
         //
         // We use the Tauri API (Rust) to get the data and config directories
         // for this app.
@@ -46,17 +73,23 @@ public partial class MainLayout : LayoutComponentBase, IMessageBusReceiver
         
         // Store the directories in the settings manager:
         SettingsManager.ConfigDirectory = configDir;
-        SettingsManager.DataDirectory = dataDir;
+        SettingsManager.DataDirectory = Path.Join(dataDir, "data");
+        Directory.CreateDirectory(SettingsManager.DataDirectory);
         
         // Ensure that all settings are loaded:
         await this.SettingsManager.LoadSettings();
         
         // Register this component with the message bus:
         this.MessageBus.RegisterComponent(this);
-        this.MessageBus.ApplyFilters(this, [], [ Event.UPDATE_AVAILABLE, Event.USER_SEARCH_FOR_UPDATE ]);
+        this.MessageBus.ApplyFilters(this, [], [ Event.UPDATE_AVAILABLE, Event.USER_SEARCH_FOR_UPDATE, Event.CONFIGURATION_CHANGED ]);
         
         // Set the js runtime for the update service:
-        UpdateService.SetJsRuntime(this.JsRuntime);
+        UpdateService.SetBlazorDependencies(this.JsRuntime, this.Snackbar);
+        TemporaryChatService.Initialize();
+        
+        // Should the navigation bar be open by default?
+        if(this.SettingsManager.ConfigurationData.NavigationBehavior is NavBehavior.ALWAYS_EXPAND)
+            this.navBarOpen = true;
         
         await base.OnInitializedAsync();
     }
@@ -85,11 +118,25 @@ public partial class MainLayout : LayoutComponentBase, IMessageBusReceiver
                 }
                 
                 break;
+            
+            case Event.CONFIGURATION_CHANGED:
+                if(this.SettingsManager.ConfigurationData.NavigationBehavior is NavBehavior.ALWAYS_EXPAND)
+                    this.navBarOpen = true;
+                else
+                    this.navBarOpen = false;
+                
+                this.StateHasChanged();
+                break;
         }
     }
 
-    #endregion
+    public Task<TResult?> ProcessMessageWithResult<TPayload, TResult>(ComponentBase? sendingComponent, Event triggeredEvent, TPayload? data)
+    {
+        return Task.FromResult<TResult?>(default);
+    }
 
+    #endregion
+    
     private async Task DismissUpdate()
     {
         this.userDismissedUpdate = true;
@@ -135,11 +182,33 @@ public partial class MainLayout : LayoutComponentBase, IMessageBusReceiver
 
         var dialogReference = await this.DialogService.ShowAsync<UpdateDialog>("Update", dialogParameters, DialogOptions.FULLSCREEN_NO_HEADER);
         var dialogResult = await dialogReference.Result;
-        if (dialogResult.Canceled)
+        if (dialogResult is null || dialogResult.Canceled)
             return;
         
         this.performingUpdate = true;
         this.StateHasChanged();
         await this.Rust.InstallUpdate(this.JsRuntime);
     }
+    
+    private async ValueTask OnLocationChanging(LocationChangingContext context)
+    {
+        if (await MessageBus.INSTANCE.SendMessageUseFirstResult<bool, bool>(this, Event.HAS_CHAT_UNSAVED_CHANGES))
+        {
+            var dialogParameters = new DialogParameters
+            {
+                { "Message", "Are you sure you want to leave the chat page? All unsaved changes will be lost." },
+            };
+        
+            var dialogReference = await this.DialogService.ShowAsync<ConfirmDialog>("Leave Chat Page", dialogParameters, DialogOptions.FULLSCREEN);
+            var dialogResult = await dialogReference.Result;
+            if (dialogResult is null || dialogResult.Canceled)
+            {
+                context.PreventNavigation();
+                return;
+            }
+
+            // User accepted to leave the chat page, reset the chat state:
+            await MessageBus.INSTANCE.SendMessage<bool>(this, Event.RESET_CHAT_STATE);
+        }
+    }
 }

app/MindWork AI Studio/Components/Layout/NavBarItem.cs

@@ -0,0 +1,3 @@
+namespace AIStudio.Components.Layout;
+
+public record NavBarItem(string Name, string Icon, Color IconColor, string Path, bool MatchAll);

app/MindWork AI Studio/Components/MSGComponentBase.cs

@@ -1,6 +1,8 @@
+using AIStudio.Tools;
+
 using Microsoft.AspNetCore.Components;
 
-namespace AIStudio.Tools;
+namespace AIStudio.Components;
 
 public abstract class MSGComponentBase : ComponentBase, IDisposable, IMessageBusReceiver
 {
@@ -20,6 +22,8 @@ public abstract class MSGComponentBase : ComponentBase, IDisposable, IMessageBus
     #region Implementation of IMessageBusReceiver
 
     public abstract Task ProcessMessage<T>(ComponentBase? sendingComponent, Event triggeredEvent, T? data);
+    
+    public abstract Task<TResult?> ProcessMessageWithResult<TPayload, TResult>(ComponentBase? sendingComponent, Event triggeredEvent, TPayload? data);
 
     #endregion
 
@@ -37,6 +41,11 @@ public abstract class MSGComponentBase : ComponentBase, IDisposable, IMessageBus
         await this.MessageBus.SendMessage(this, triggeredEvent, data);
     }
     
+    protected async Task<TResult?> SendMessageWithResult<TPayload, TResult>(Event triggeredEvent, TPayload? data)
+    {
+        return await this.MessageBus.SendMessageUseFirstResult<TPayload, TResult>(this, triggeredEvent, data);
+    }
+    
     protected void ApplyFilters(ComponentBase[] components, Event[] events)
     {
         this.MessageBus.ApplyFilters(this, components, events);

app/MindWork AI Studio/Components/Pages/About.razor

@@ -9,14 +9,14 @@
             <MudText>
                 The following list shows the versions of the MindWork AI Studio, the used compilers, build time, etc.:
             </MudText>
-            <MudList Clickable="@true">
-                <MudListItem Icon="@Icons.Material.Outlined.Chat" Text="@VersionApp"/>
-                <MudListItem Icon="@Icons.Material.Outlined.Timer" Text="@BuildTime"/>
-                <MudListItem Icon="@Icons.Material.Outlined.Build" Text="@VersionDotnetSdk"/>
-                <MudListItem Icon="@Icons.Material.Outlined.Memory" Text="@VersionDotnetRuntime"/>
-                <MudListItem Icon="@Icons.Material.Outlined.Build" Text="@VersionRust"/>
-                <MudListItem Icon="@Icons.Material.Outlined.Widgets" Text="@MudBlazorVersion"/>
-                <MudListItem Icon="@Icons.Material.Outlined.Memory" Text="@TauriVersion"/>
+            <MudList T="string">
+                <MudListItem T="string" Icon="@Icons.Material.Outlined.Chat" Text="@VersionApp"/>
+                <MudListItem T="string" Icon="@Icons.Material.Outlined.Timer" Text="@BuildTime"/>
+                <MudListItem T="string" Icon="@Icons.Material.Outlined.Build" Text="@VersionDotnetSdk"/>
+                <MudListItem T="string" Icon="@Icons.Material.Outlined.Memory" Text="@VersionDotnetRuntime"/>
+                <MudListItem T="string" Icon="@Icons.Material.Outlined.Build" Text="@VersionRust"/>
+                <MudListItem T="string" Icon="@Icons.Material.Outlined.Widgets" Text="@MudBlazorVersion"/>
+                <MudListItem T="string" Icon="@Icons.Material.Outlined.Memory" Text="@TauriVersion"/>
             </MudList>
             <MudButton Variant="Variant.Filled" Color="Color.Info" StartIcon="@Icons.Material.Filled.Update" OnClick="() => this.CheckForUpdate()">
                 Check for updates

app/MindWork AI Studio/Components/Pages/Assistants.razor

@@ -0,0 +1,12 @@
+@page "/assistants"
+
+<MudText Typo="Typo.h3" Class="mb-2 mr-3">
+    Assistants
+</MudText>
+
+<MudGrid>
+    <AssistantBlock Name="Icon Finder" Description="Using a LLM to find an icon for a given context." Icon="@Icons.Material.Filled.FindInPage" Link="/assistant/icons"/>
+    <AssistantBlock Name="Text Summarizer" Description="Using a LLM to summarize a given text." Icon="@Icons.Material.Filled.TextSnippet" Link="/assistant/summarizer"/>
+    <AssistantBlock Name="Translator" Description="Translate text into another language." Icon="@Icons.Material.Filled.Translate" Link="/assistant/translator"/>
+    <AssistantBlock Name="Coding" Description="Get coding and debugging support from a LLM." Icon="@Icons.Material.Filled.Code" Link="/assistant/coding"/>
+</MudGrid>

app/MindWork AI Studio/Components/Pages/Assistants.razor.cs

@@ -0,0 +1,5 @@
+using Microsoft.AspNetCore.Components;
+
+namespace AIStudio.Components.Pages;
+
+public partial class Assistants : ComponentBase;

app/MindWork AI Studio/Components/Pages/Chat.razor

@@ -2,8 +2,20 @@
 @using AIStudio.Chat
 @using AIStudio.Settings
 
-<MudText Typo="Typo.h3" Class="mb-2">Chats</MudText>
-<MudSelect T="Provider" @bind-Value="@this.selectedProvider" Adornment="Adornment.Start" AdornmentIcon="@Icons.Material.Filled.Apps" Margin="Margin.Dense" Label="Provider" Class="mb-2 rounded-lg" Variant="Variant.Outlined">
+@inherits MSGComponentBase
+
+<MudText Typo="Typo.h3" Class="mb-2 mr-3">
+    @if (this.chatThread is not null && this.chatThread.WorkspaceId != Guid.Empty)
+    {
+        @($"Chat in Workspace \"{this.currentWorkspaceName}\"")
+    }
+    else
+    {
+        @("Temporary Chat")
+    }
+</MudText>
+
+<MudSelect T="Provider" @bind-Value="@this.providerSettings" Adornment="Adornment.Start" AdornmentIcon="@Icons.Material.Filled.Apps" Margin="Margin.Dense" Label="Provider" Class="mb-2 rounded-lg" Variant="Variant.Outlined">
     @foreach (var provider in this.SettingsManager.ConfigurationData.Providers)
     {
         <MudSelectItem Value="@provider"/>
@@ -24,5 +36,64 @@
         <MudPaper Style="flex: 0 0 auto;">
             <MudTextField T="string" @ref="@this.inputField" @bind-Text="@this.userInput" Variant="Variant.Outlined" AutoGrow="@true" Lines="3" MaxLines="12" Label="@this.InputLabel" Placeholder="@this.ProviderPlaceholder" Adornment="Adornment.End" AdornmentIcon="@Icons.Material.Filled.Send" OnAdornmentClick="() => this.SendMessage()" ReadOnly="!this.IsProviderSelected || this.isStreaming" Immediate="@true" OnKeyUp="this.InputKeyEvent" UserAttributes="@USER_INPUT_ATTRIBUTES"/>
         </MudPaper>
+        <MudPaper Class="mt-1" Outlined="@true">
+            <MudToolBar WrapContent="true">
+                @if (this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior is not WorkspaceStorageBehavior.DISABLE_WORKSPACES)
+                {
+                    <MudTooltip Text="Your workspaces" Placement="@TOOLBAR_TOOLTIP_PLACEMENT">
+                        <MudIconButton Icon="@Icons.Material.Filled.SnippetFolder" OnClick="() => this.ToggleWorkspaces()"/>
+                    </MudTooltip>
+                }
+
+                @if (this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior is WorkspaceStorageBehavior.STORE_CHATS_MANUALLY)
+                {
+                    <MudTooltip Text="Save chat" Placement="@TOOLBAR_TOOLTIP_PLACEMENT">
+                        <MudIconButton Icon="@Icons.Material.Filled.Save" OnClick="() => this.SaveThread()" Disabled="@(!this.CanThreadBeSaved)"/>
+                    </MudTooltip>
+                }
+
+                <MudTooltip Text="Start temporary chat" Placement="@TOOLBAR_TOOLTIP_PLACEMENT">
+                    <MudIconButton Icon="@Icons.Material.Filled.AddComment" OnClick="() => this.StartNewChat(useSameWorkspace: false)"/>
+                </MudTooltip>
+
+                @if (!string.IsNullOrWhiteSpace(this.currentWorkspaceName))
+                {
+                    <MudTooltip Text="@this.TooltipAddChatToWorkspace" Placement="@TOOLBAR_TOOLTIP_PLACEMENT">
+                        <MudIconButton Icon="@Icons.Material.Filled.CommentBank" OnClick="() => this.StartNewChat(useSameWorkspace: true)"/>
+                    </MudTooltip>
+                }
+                
+                @if (this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior is WorkspaceStorageBehavior.STORE_CHATS_AUTOMATICALLY)
+                {
+                    <MudTooltip Text="Delete this chat & start a new one" Placement="@TOOLBAR_TOOLTIP_PLACEMENT">
+                        <MudIconButton Icon="@Icons.Material.Filled.Refresh" OnClick="() => this.StartNewChat(useSameWorkspace: true, deletePreviousChat: true)" Disabled="@(!this.CanThreadBeSaved)"/>
+                    </MudTooltip>
+                }
+
+                @if (this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior is not WorkspaceStorageBehavior.DISABLE_WORKSPACES)
+                {
+                    <MudTooltip Text="Move chat to (another) workspace" Placement="@TOOLBAR_TOOLTIP_PLACEMENT">
+                        <MudIconButton Icon="@Icons.Material.Filled.MoveToInbox" Disabled="@(!this.CanThreadBeSaved)" OnClick="() => this.MoveChatToWorkspace()"/>
+                    </MudTooltip>
+                }
+            </MudToolBar>
+        </MudPaper>
     </FooterContent>
-</InnerScrolling>
+</InnerScrolling>
+
+@if (this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior != WorkspaceStorageBehavior.DISABLE_WORKSPACES)
+{
+    <MudDrawer @bind-Open="@this.workspacesVisible" Width="40em" Height="100%" Anchor="Anchor.Start" Variant="DrawerVariant.Temporary" Elevation="1">
+        <MudDrawerHeader>
+            <MudStack Row="@true" AlignItems="AlignItems.Center">
+                <MudText Typo="Typo.h6" Class="mr-3">
+                    Your workspaces
+                </MudText>
+                <MudIconButton Icon="@Icons.Material.Filled.Close" Variant="Variant.Filled" Color="Color.Default" Size="Size.Small" OnClick="() => this.ToggleWorkspaces()"/>
+            </MudStack>
+        </MudDrawerHeader>
+        <MudDrawerContainer Class="ml-6">
+            <Workspaces @ref="this.workspaces" @bind-CurrentChatThread="@this.chatThread" LoadedChatWasChanged="this.LoadedChatChanged"/>
+        </MudDrawerContainer>
+    </MudDrawer>
+}

app/MindWork AI Studio/Components/Pages/Chat.razor.cs

@@ -1,16 +1,21 @@
 using AIStudio.Chat;
+using AIStudio.Components.Blocks;
+using AIStudio.Components.CommonDialogs;
 using AIStudio.Provider;
 using AIStudio.Settings;
+using AIStudio.Tools;
 
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 
+using DialogOptions = AIStudio.Components.CommonDialogs.DialogOptions;
+
 namespace AIStudio.Components.Pages;
 
 /// <summary>
 /// The chat page.
 /// </summary>
-public partial class Chat : ComponentBase
+public partial class Chat : MSGComponentBase, IAsyncDisposable
 {
     [Inject]
     private SettingsManager SettingsManager { get; set; } = null!;
@@ -20,13 +25,22 @@ public partial class Chat : ComponentBase
 
     [Inject]
     public Random RNG { get; set; } = null!;
+    
+    [Inject]
+    public IDialogService DialogService { get; set; } = null!;
 
+    private const Placement TOOLBAR_TOOLTIP_PLACEMENT = Placement.Bottom;
     private static readonly Dictionary<string, object?> USER_INPUT_ATTRIBUTES = new();
     
-    private AIStudio.Settings.Provider selectedProvider;
+    private AIStudio.Settings.Provider providerSettings;
     private ChatThread? chatThread;
+    private bool hasUnsavedChanges;
     private bool isStreaming;
     private string userInput = string.Empty;
+    private string currentWorkspaceName = string.Empty;
+    private Guid currentWorkspaceId = Guid.Empty;
+    private bool workspacesVisible;
+    private Workspaces? workspaces;
     
     // Unfortunately, we need the input field reference to clear it after sending a message.
     // This is necessary because we have to handle the key events ourselves. Otherwise,
@@ -37,44 +51,76 @@ public partial class Chat : ComponentBase
 
     protected override async Task OnInitializedAsync()
     {
+        this.ApplyFilters([], [ Event.HAS_CHAT_UNSAVED_CHANGES, Event.RESET_CHAT_STATE ]);
+        
         // Configure the spellchecking for the user input:
         this.SettingsManager.InjectSpellchecking(USER_INPUT_ATTRIBUTES);
         
-        // For now, we just create a new chat thread.
-        // Later we want the chats to be persisted
-        // across page loads and organize them in
-        // a chat history & workspaces.
-        this.chatThread = new("Thread 1", this.RNG.Next(), "You are a helpful assistant!", []);
         await base.OnInitializedAsync();
     }
 
     #endregion
 
-    private bool IsProviderSelected => this.selectedProvider.UsedProvider != Providers.NONE;
+    private bool IsProviderSelected => this.providerSettings.UsedProvider != Providers.NONE;
     
     private string ProviderPlaceholder => this.IsProviderSelected ? "Type your input here..." : "Select a provider first";
 
-    private string InputLabel => this.IsProviderSelected ? $"Your Prompt (use selected instance '{this.selectedProvider.InstanceName}', provider '{this.selectedProvider.UsedProvider.ToName()}')" : "Select a provider first";
+    private string InputLabel => this.IsProviderSelected ? $"Your Prompt (use selected instance '{this.providerSettings.InstanceName}', provider '{this.providerSettings.UsedProvider.ToName()}')" : "Select a provider first";
+    
+    private bool CanThreadBeSaved => this.chatThread is not null && this.chatThread.Blocks.Count > 0;
+
+    private string TooltipAddChatToWorkspace => $"Start new chat in workspace \"{this.currentWorkspaceName}\"";
     
     private async Task SendMessage()
     {
         if (!this.IsProviderSelected)
             return;
         
+        // Create a new chat thread if necessary:
+        var threadName = this.ExtractThreadName(this.userInput);
+
+        if (this.chatThread is null)
+        {
+            this.chatThread = new()
+            {
+                WorkspaceId = this.currentWorkspaceId,
+                ChatId = Guid.NewGuid(),
+                Name = threadName,
+                Seed = this.RNG.Next(),
+                SystemPrompt = "You are a helpful assistant!",
+                Blocks = [],
+            };
+        }
+        else
+        {
+            // Set the thread name if it is empty:
+            if (string.IsNullOrWhiteSpace(this.chatThread.Name))
+                this.chatThread.Name = threadName;
+        }
+        
         //
         // Add the user message to the thread:
         //
         var time = DateTimeOffset.Now;
-        this.chatThread?.Blocks.Add(new ContentBlock(time, ContentType.TEXT, new ContentText
+        this.chatThread?.Blocks.Add(new ContentBlock
         {
-            // Text content properties:
-            Text = this.userInput,
-        })
-        {
-            // Content block properties:
+            Time = time,
+            ContentType = ContentType.TEXT,
             Role = ChatRole.USER,
+            Content = new ContentText
+            {
+                Text = this.userInput,
+            },
         });
 
+        // Save the chat:
+        if (this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior is WorkspaceStorageBehavior.STORE_CHATS_AUTOMATICALLY)
+        {
+            await this.SaveThread();
+            this.hasUnsavedChanges = false;
+            this.StateHasChanged();
+        }
+
         //
         // Add the AI response to the thread:
         //
@@ -85,9 +131,12 @@ public partial class Chat : ComponentBase
             InitialRemoteWait = true,
         };
         
-        this.chatThread?.Blocks.Add(new ContentBlock(time, ContentType.TEXT, aiText)
+        this.chatThread?.Blocks.Add(new ContentBlock
         {
+            Time = time,
+            ContentType = ContentType.TEXT,
             Role = ChatRole.AI,
+            Content = aiText,
         });
         
         // Clear the input field:
@@ -96,13 +145,21 @@ public partial class Chat : ComponentBase
         
         // Enable the stream state for the chat component:
         this.isStreaming = true;
+        this.hasUnsavedChanges = true;
         this.StateHasChanged();
         
         // Use the selected provider to get the AI response.
         // By awaiting this line, we wait for the entire
         // content to be streamed.
-        await aiText.CreateFromProviderAsync(this.selectedProvider.UsedProvider.CreateProvider(this.selectedProvider.InstanceName), this.JsRuntime, this.SettingsManager, this.selectedProvider.Model, this.chatThread);
+        await aiText.CreateFromProviderAsync(this.providerSettings.CreateProvider(), this.JsRuntime, this.SettingsManager, this.providerSettings.Model, this.chatThread);
         
+        // Save the chat:
+        if (this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior is WorkspaceStorageBehavior.STORE_CHATS_AUTOMATICALLY)
+        {
+            await this.SaveThread();
+            this.hasUnsavedChanges = false;
+        }
+
         // Disable the stream state:
         this.isStreaming = false;
         this.StateHasChanged();
@@ -110,6 +167,7 @@ public partial class Chat : ComponentBase
 
     private async Task InputKeyEvent(KeyboardEventArgs keyEvent)
     {
+        this.hasUnsavedChanges = true;
         var key = keyEvent.Code.ToLowerInvariant();
         
         // Was the enter key (either enter or numpad enter) pressed?
@@ -132,4 +190,216 @@ public partial class Chat : ComponentBase
                 break;
         }
     }
+    
+    private void ToggleWorkspaces()
+    {
+        this.workspacesVisible = !this.workspacesVisible;
+    }
+    
+    private async Task SaveThread()
+    {
+        if(this.workspaces is null)
+            return;
+        
+        if(this.chatThread is null)
+            return;
+        
+        if (!this.CanThreadBeSaved)
+            return;
+        
+        await this.workspaces.StoreChat(this.chatThread);
+        this.hasUnsavedChanges = false;
+    }
+    
+    private string ExtractThreadName(string firstUserInput)
+    {
+        // We select the first 10 words of the user input:
+        var words = firstUserInput.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+        var threadName = string.Join(' ', words.Take(10));
+        
+        // If the thread name is empty, we use a default name:
+        if (string.IsNullOrWhiteSpace(threadName))
+            threadName = "Thread";
+        
+        return threadName;
+    }
+
+    private async Task StartNewChat(bool useSameWorkspace = false, bool deletePreviousChat = false)
+    {
+        if (this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior is WorkspaceStorageBehavior.STORE_CHATS_MANUALLY && this.hasUnsavedChanges)
+        {
+            var dialogParameters = new DialogParameters
+            {
+                { "Message", "Are you sure you want to start a new chat? All unsaved changes will be lost." },
+            };
+        
+            var dialogReference = await this.DialogService.ShowAsync<ConfirmDialog>("Delete Chat", dialogParameters, DialogOptions.FULLSCREEN);
+            var dialogResult = await dialogReference.Result;
+            if (dialogResult is null || dialogResult.Canceled)
+                return;
+        }
+
+        if (this.chatThread is not null && this.workspaces is not null && deletePreviousChat)
+        {
+            string chatPath;
+            if (this.chatThread.WorkspaceId == Guid.Empty)
+            {
+                chatPath = Path.Join(SettingsManager.DataDirectory, "tempChats", this.chatThread.ChatId.ToString());
+            }
+            else
+            {
+                chatPath = Path.Join(SettingsManager.DataDirectory, "workspaces", this.chatThread.WorkspaceId.ToString(), this.chatThread.ChatId.ToString());
+            }
+            
+            await this.workspaces.DeleteChat(chatPath, askForConfirmation: false, unloadChat: true);
+        }
+
+        this.isStreaming = false;
+        this.hasUnsavedChanges = false;
+        this.userInput = string.Empty;
+
+        if (!useSameWorkspace)
+        {
+            this.chatThread = null;
+            this.currentWorkspaceId = Guid.Empty;
+            this.currentWorkspaceName = string.Empty;
+        }
+        else
+        {
+            this.chatThread = new()
+            {
+                WorkspaceId = this.currentWorkspaceId,
+                ChatId = Guid.NewGuid(),
+                Name = string.Empty,
+                Seed = this.RNG.Next(),
+                SystemPrompt = "You are a helpful assistant!",
+                Blocks = [],
+            };
+        }
+
+        await this.inputField.Clear();
+    }
+
+    private async Task MoveChatToWorkspace()
+    {
+        if(this.chatThread is null)
+            return;
+        
+        if(this.workspaces is null)
+            return;
+        
+        if (this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior is WorkspaceStorageBehavior.STORE_CHATS_MANUALLY && this.hasUnsavedChanges)
+        {
+            var confirmationDialogParameters = new DialogParameters
+            {
+                { "Message", "Are you sure you want to move this chat? All unsaved changes will be lost." },
+            };
+        
+            var confirmationDialogReference = await this.DialogService.ShowAsync<ConfirmDialog>("Unsaved Changes", confirmationDialogParameters, DialogOptions.FULLSCREEN);
+            var confirmationDialogResult = await confirmationDialogReference.Result;
+            if (confirmationDialogResult is null || confirmationDialogResult.Canceled)
+                return;
+        }
+        
+        var dialogParameters = new DialogParameters
+        {
+            { "Message", "Please select the workspace where you want to move the chat to." },
+            { "SelectedWorkspace", this.chatThread?.WorkspaceId },
+            { "ConfirmText", "Move chat" },
+        };
+        
+        var dialogReference = await this.DialogService.ShowAsync<WorkspaceSelectionDialog>("Move Chat to Workspace", dialogParameters, DialogOptions.FULLSCREEN);
+        var dialogResult = await dialogReference.Result;
+        if (dialogResult is null || dialogResult.Canceled)
+            return;
+        
+        var workspaceId = dialogResult.Data is Guid id ? id : default;
+        if (workspaceId == Guid.Empty)
+            return;
+        
+        // Delete the chat from the current workspace or the temporary storage:
+        if (this.chatThread!.WorkspaceId == Guid.Empty)
+        {
+            // Case: The chat is stored in the temporary storage:
+            await this.workspaces.DeleteChat(Path.Join(SettingsManager.DataDirectory, "tempChats", this.chatThread.ChatId.ToString()), askForConfirmation: false, unloadChat: false);
+        }
+        else
+        {
+            // Case: The chat is stored in a workspace.
+            await this.workspaces.DeleteChat(Path.Join(SettingsManager.DataDirectory, "workspaces", this.chatThread.WorkspaceId.ToString(), this.chatThread.ChatId.ToString()), askForConfirmation: false, unloadChat: false);
+        }
+        
+        this.chatThread!.WorkspaceId = workspaceId;
+        await this.SaveThread();
+        
+        this.currentWorkspaceId = this.chatThread.WorkspaceId;
+        this.currentWorkspaceName = await this.workspaces.LoadWorkspaceName(this.chatThread.WorkspaceId);
+    }
+
+    private async Task LoadedChatChanged()
+    {
+        if(this.workspaces is null)
+            return;
+        
+        this.isStreaming = false;
+        this.hasUnsavedChanges = false;
+        this.userInput = string.Empty;
+        this.currentWorkspaceId = this.chatThread?.WorkspaceId ?? Guid.Empty;
+        this.currentWorkspaceName = this.chatThread is null ? string.Empty : await this.workspaces.LoadWorkspaceName(this.chatThread.WorkspaceId);
+        
+        await this.inputField.Clear();
+    }
+
+    private void ResetState()
+    {
+        this.isStreaming = false;
+        this.hasUnsavedChanges = false;
+        this.userInput = string.Empty;
+        this.currentWorkspaceId = Guid.Empty;
+        this.currentWorkspaceName = string.Empty;
+        this.chatThread = null;
+    }
+
+    #region Overrides of MSGComponentBase
+
+    public override Task ProcessMessage<T>(ComponentBase? sendingComponent, Event triggeredEvent, T? data) where T : default
+    {
+        switch (triggeredEvent)
+        {
+            case Event.RESET_CHAT_STATE:
+                this.ResetState();
+                break;
+        }
+        
+        return Task.CompletedTask;
+    }
+
+    public override Task<TResult?> ProcessMessageWithResult<TPayload, TResult>(ComponentBase? sendingComponent, Event triggeredEvent, TPayload? data) where TResult : default where TPayload : default
+    {
+        switch (triggeredEvent)
+        {
+            case Event.HAS_CHAT_UNSAVED_CHANGES:
+                if(this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior is WorkspaceStorageBehavior.STORE_CHATS_AUTOMATICALLY)
+                    return Task.FromResult((TResult?) (object) false);
+                
+                return Task.FromResult((TResult?)(object)this.hasUnsavedChanges);
+        }
+        
+        return Task.FromResult(default(TResult));
+    }
+
+    #endregion
+
+    #region Implementation of IAsyncDisposable
+
+    public async ValueTask DisposeAsync()
+    {
+        if(this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior is WorkspaceStorageBehavior.STORE_CHATS_AUTOMATICALLY)
+        {
+            await this.SaveThread();
+            this.hasUnsavedChanges = false;
+        }
+    }
+
+    #endregion
 }

app/MindWork AI Studio/Components/Pages/Coding/AssistantCoding.razor

@@ -0,0 +1,39 @@
+@page "/assistant/coding"
+@using AIStudio.Settings
+@inherits AssistantBaseCore
+
+<MudExpansionPanels Class="mb-3">
+    @for (var contextIndex = 0; contextIndex < this.codingContexts.Count; contextIndex++)
+    {
+        var codingContext = this.codingContexts[contextIndex];
+        <ExpansionPanel HeaderText="@codingContext.Id" HeaderIcon="@Icons.Material.Filled.Code">
+            <CodingContextItem @bind-CodingContext="@codingContext"/>
+        </ExpansionPanel>
+    }
+</MudExpansionPanels>
+<MudButton Variant="Variant.Filled" OnClick="() => this.AddCodingContext()" Class="mb-3">
+    Add context
+</MudButton>
+
+<MudStack Row="@false" Class="mb-3">
+    <MudSwitch T="bool" @bind-Value="@this.provideCompilerMessages">
+        @(this.provideCompilerMessages ? "Provide compiler messages" : "Provide no compiler messages")
+    </MudSwitch>
+    @if (this.provideCompilerMessages)
+    {
+        <MudTextField T="string" @bind-Text="@this.compilerMessages" Validation="@this.ValidatingCompilerMessages" AdornmentIcon="@Icons.Material.Filled.Error" Adornment="Adornment.Start" Label="Compiler messages" Variant="Variant.Outlined" Lines="6" AutoGrow="@true" MaxLines="12" Class="mb-3" UserAttributes="@USER_INPUT_ATTRIBUTES"/>
+    }
+</MudStack>
+
+<MudTextField T="string" @bind-Text="@this.questions" Validation="@this.ValidateQuestions" AdornmentIcon="@Icons.Material.Filled.QuestionMark" Adornment="Adornment.Start" Label="Your question(s)" Variant="Variant.Outlined" Lines="6" AutoGrow="@true" MaxLines="12" Class="mb-3" UserAttributes="@USER_INPUT_ATTRIBUTES"/>
+
+<MudSelect T="Provider" @bind-Value="@this.providerSettings" Validation="@this.ValidatingProvider" Adornment="Adornment.Start" AdornmentIcon="@Icons.Material.Filled.Apps" Margin="Margin.Dense" Label="Provider" Class="mb-3 rounded-lg" Variant="Variant.Outlined">
+    @foreach (var provider in this.SettingsManager.ConfigurationData.Providers)
+    {
+        <MudSelectItem Value="@provider"/>
+    }
+</MudSelect>
+
+<MudButton Variant="Variant.Filled" Color="Color.Info" OnClick="() => this.GetSupport()" Class="mb-3">
+    Get support
+</MudButton>

app/MindWork AI Studio/Components/Pages/Coding/AssistantCoding.razor.cs

@@ -0,0 +1,106 @@
+using System.Text;
+
+namespace AIStudio.Components.Pages.Coding;
+
+public partial class AssistantCoding : AssistantBaseCore
+{
+    protected override string Title => "Coding Assistant";
+    
+    protected override string Description =>
+        """
+        This coding assistant supports you in writing code. Provide some coding context by copying and pasting
+        your code into the input fields. You might assign an ID to your code snippet to easily reference it later.
+        When you have compiler messages, you can paste them into the input fields to get help with debugging as well.
+        """;
+    
+    protected override string SystemPrompt => 
+        """
+        You are a friendly, helpful senior software developer with extensive experience in various programming languages
+        and concepts. You are familiar with principles like DRY, KISS, YAGNI, and SOLID and can apply and explain them.
+        You know object-oriented programming, as well as functional programming and procedural programming. You are also
+        familiar with design patterns and can explain them. You are an expert of debugging and can help with compiler
+        messages. You can also help with code refactoring and optimization.
+        
+        When the user asks in a different language than English, you answer in the same language!
+        """;
+    
+    private readonly List<CodingContext> codingContexts = new();
+    private bool provideCompilerMessages;
+    private string compilerMessages = string.Empty;
+    private string questions = string.Empty;
+    
+    private string? ValidatingCompilerMessages(string checkCompilerMessages)
+    {
+        if(!this.provideCompilerMessages)
+            return null;
+        
+        if(string.IsNullOrWhiteSpace(checkCompilerMessages))
+            return "Please provide the compiler messages.";
+        
+        return null;
+    }
+    
+    private string? ValidateQuestions(string checkQuestions)
+    {
+        if(string.IsNullOrWhiteSpace(checkQuestions))
+            return "Please provide your questions.";
+        
+        return null;
+    }
+
+    private void AddCodingContext()
+    {
+        this.codingContexts.Add(new()
+        {
+            Id = $"Context {this.codingContexts.Count + 1}",
+        });
+    }
+
+    private async Task GetSupport()
+    {
+        await this.form!.Validate();
+        if (!this.inputIsValid)
+            return;
+
+        var sbContext = new StringBuilder();
+        if (this.codingContexts.Count > 0)
+        {
+            sbContext.AppendLine("I have the following coding context:");
+            sbContext.AppendLine();
+            foreach (var codingContext in this.codingContexts)
+            {
+                sbContext.AppendLine($"ID: {codingContext.Id}");
+                sbContext.AppendLine($"Language: {codingContext.Language.Name()}");
+                sbContext.AppendLine($"Other Language: {codingContext.OtherLanguage}");
+                sbContext.AppendLine($"Content:");
+                sbContext.AppendLine("```");
+                sbContext.AppendLine(codingContext.Code);
+                sbContext.AppendLine("```");
+                sbContext.AppendLine();
+            }
+        }
+
+        var sbCompilerMessages = new StringBuilder();
+        if (this.provideCompilerMessages)
+        {
+            sbCompilerMessages.AppendLine("I have the following compiler messages:");
+            sbCompilerMessages.AppendLine();
+            sbCompilerMessages.AppendLine("```");
+            sbCompilerMessages.AppendLine(this.compilerMessages);
+            sbCompilerMessages.AppendLine("```");
+            sbCompilerMessages.AppendLine();
+        }
+
+        this.CreateChatThread();
+        var time = this.AddUserRequest(
+            $"""
+                {sbContext}
+                {sbCompilerMessages}
+                
+                My questions are:
+                {this.questions}
+             """);
+
+        await this.AddAIResponseAsync(time);
+    }
+}

app/MindWork AI Studio/Components/Pages/Coding/CodingContext.cs

@@ -0,0 +1,16 @@
+namespace AIStudio.Components.Pages.Coding;
+
+public sealed class CodingContext(string id, CommonCodingLanguages language, string otherLanguage, string code)
+{
+    public CodingContext() : this(string.Empty, CommonCodingLanguages.NONE, string.Empty, string.Empty)
+    {
+    }
+    
+    public string Id { get; set; } = id;
+    
+    public CommonCodingLanguages Language { get; set; } = language;
+    
+    public string OtherLanguage { get; set; } = otherLanguage;
+    
+    public string Code { get; set; } = code;
+}

app/MindWork AI Studio/Components/Pages/Coding/CodingContextItem.razor

@@ -0,0 +1,14 @@
+<MudTextField T="string" @bind-Text="@this.CodingContext.Id" AdornmentIcon="@Icons.Material.Filled.Numbers" Adornment="Adornment.Start" Label="(Optional) Identifier" Variant="Variant.Outlined" Margin="Margin.Dense" UserAttributes="@USER_INPUT_ATTRIBUTES" Class="mb-3"/>
+<MudStack Row="@true" AlignItems="AlignItems.Center" Class="mb-3">
+    <MudSelect T="CommonCodingLanguages" @bind-Value="@this.CodingContext.Language" AdornmentIcon="@Icons.Material.Filled.Code" Adornment="Adornment.Start" Label="Language" Variant="Variant.Outlined" Margin="Margin.Dense">
+        @foreach (var language in Enum.GetValues<CommonCodingLanguages>())
+        {
+            <MudSelectItem Value="@language">@language.Name()</MudSelectItem>
+        }
+    </MudSelect>
+    @if (this.CodingContext.Language is CommonCodingLanguages.OTHER)
+    {
+        <MudTextField T="string" @bind-Text="@this.CodingContext.OtherLanguage" Validation="@this.ValidatingOtherLanguage" Label="Other language" Variant="Variant.Outlined" Margin="Margin.Dense" UserAttributes="@USER_INPUT_ATTRIBUTES"/>
+    }
+</MudStack>
+<MudTextField T="string" @bind-Text="@this.CodingContext.Code" Validation="@this.ValidatingCode" AdornmentIcon="@Icons.Material.Filled.DocumentScanner" Adornment="Adornment.Start" Label="Your code" Variant="Variant.Outlined" Lines="6" AutoGrow="@true" MaxLines="12" Class="mb-3" UserAttributes="@USER_INPUT_ATTRIBUTES" />

app/MindWork AI Studio/Components/Pages/Coding/CodingContextItem.razor.cs

@@ -0,0 +1,50 @@
+using AIStudio.Settings;
+
+using Microsoft.AspNetCore.Components;
+
+namespace AIStudio.Components.Pages.Coding;
+
+public partial class CodingContextItem : ComponentBase
+{
+    [Parameter]
+    public CodingContext CodingContext { get; set; } = new();
+
+    [Parameter]
+    public EventCallback<CodingContext> CodingContextChanged { get; set; }
+    
+    [Inject]
+    protected SettingsManager SettingsManager { get; set; } = null!;
+
+    private static readonly Dictionary<string, object?> USER_INPUT_ATTRIBUTES = new();
+    
+    #region Overrides of ComponentBase
+
+    protected override async Task OnParametersSetAsync()
+    {
+        // Configure the spellchecking for the user input:
+        this.SettingsManager.InjectSpellchecking(USER_INPUT_ATTRIBUTES);
+        
+        await base.OnParametersSetAsync();
+    }
+    
+    #endregion
+    
+    private string? ValidatingCode(string code)
+    {
+        if(string.IsNullOrWhiteSpace(code))
+            return $"{this.CodingContext.Id}: Please provide your input.";
+        
+        return null;
+    }
+    
+    private string? ValidatingOtherLanguage(string language)
+    {
+        if(this.CodingContext.Language != CommonCodingLanguages.OTHER)
+            return null;
+        
+        if(string.IsNullOrWhiteSpace(language))
+            return "Please specify the language.";
+        
+        return null;
+    }
+}

app/MindWork AI Studio/Components/Pages/Coding/CommonCodingLanguageExtensions.cs

@@ -0,0 +1,43 @@
+namespace AIStudio.Components.Pages.Coding;
+
+public static class CommonCodingLanguageExtensions
+{
+    public static string Name(this CommonCodingLanguages language) => language switch
+    { 
+        CommonCodingLanguages.NONE => "None",
+        
+        CommonCodingLanguages.BASH => "Bash",
+        CommonCodingLanguages.BLAZOR => ".NET Blazor",
+        CommonCodingLanguages.C => "C",
+        CommonCodingLanguages.CPP => "C++",
+        CommonCodingLanguages.CSHARP => "C#",
+        CommonCodingLanguages.CSS => "CSS",
+        CommonCodingLanguages.FORTRAN => "Fortran",
+        CommonCodingLanguages.GDSCRIPT => "GDScript",
+        CommonCodingLanguages.GO => "Go",
+        CommonCodingLanguages.HTML => "HTML",
+        CommonCodingLanguages.JAVA => "Java",
+        CommonCodingLanguages.JAVASCRIPT => "JavaScript",
+        CommonCodingLanguages.JSON => "JSON",
+        CommonCodingLanguages.JULIA => "Julia",
+        CommonCodingLanguages.KOTLIN => "Kotlin",
+        CommonCodingLanguages.LUA => "Lua",
+        CommonCodingLanguages.MARKDOWN => "Markdown",
+        CommonCodingLanguages.MATHEMATICA => "Mathematica",
+        CommonCodingLanguages.MATLAB => "MATLAB",
+        CommonCodingLanguages.PHP => "PHP",
+        CommonCodingLanguages.POWERSHELL => "PowerShell",
+        CommonCodingLanguages.PROLOG => "Prolog",
+        CommonCodingLanguages.PYTHON => "Python",
+        CommonCodingLanguages.R => "R",
+        CommonCodingLanguages.RUBY => "Ruby",
+        CommonCodingLanguages.RUST => "Rust",
+        CommonCodingLanguages.SQL => "SQL",
+        CommonCodingLanguages.SWIFT => "Swift",
+        CommonCodingLanguages.TYPESCRIPT => "TypeScript",
+        CommonCodingLanguages.XML => "XML",
+        
+        CommonCodingLanguages.OTHER => "Other",
+        _ => "Unknown"
+    };
+}

app/MindWork AI Studio/Components/Pages/Coding/CommonCodingLanguages.cs

@@ -0,0 +1,39 @@
+namespace AIStudio.Components.Pages.Coding;
+
+public enum CommonCodingLanguages
+{
+    NONE,
+    
+    BASH,
+    BLAZOR,
+    C,
+    CPP,
+    CSHARP,
+    CSS,
+    FORTRAN,
+    GDSCRIPT,
+    GO,
+    HTML,
+    JAVA,
+    JAVASCRIPT,
+    JSON,
+    JULIA,
+    KOTLIN,
+    LUA,
+    MARKDOWN,
+    MATHEMATICA,
+    MATLAB,
+    PHP,
+    POWERSHELL,
+    PROLOG,
+    PYTHON,
+    R,
+    RUBY,
+    RUST,
+    SQL,
+    SWIFT,
+    TYPESCRIPT,
+    XML,
+    
+    OTHER,
+}

app/MindWork AI Studio/Components/Pages/Home.razor.cs

@@ -31,7 +31,7 @@ public partial class Home : ComponentBase
     private static readonly TextItem[] ITEMS_ADVANTAGES =
     [
         new TextItem("Free of charge", "The app is free to use, both for personal and commercial purposes."),
-        new TextItem("Independence", "Users are not tied to any single provider. The initial version supports OpenAI models (like GPT-4o, GPT-4, GPT-4 Turbo, etc.). Future versions will support other providers such as Mistral or Google Gemini."),
+        new TextItem("Independence", "You are not tied to any single provider. Instead, you might choose the provider that best suits your needs. Right now, we support OpenAI (GPT4o etc.), Mistral, Anthropic (Claude), and self-hosted models using llama.cpp, ollama, LM Studio, or Fireworks. Support for Google Gemini and Replicate is planned."),
         new TextItem("Unrestricted usage", "Unlike services like ChatGPT, which impose limits after intensive use, MindWork AI Studio offers unlimited usage through the providers API."),
         new TextItem("Cost-effective", "You only pay for what you use, which can be cheaper than monthly subscription services like ChatGPT Plus, especially if used infrequently. But beware, here be dragons: For extremely intensive usage, the API costs can be significantly higher. Unfortunately, providers currently do not offer a way to display current costs in the app. Therefore, check your account with the respective provider to see how your costs are developing. When available, use prepaid and set a cost limit."),
         new TextItem("Privacy", "The data entered into the app is not used for training by the providers since we are using the provider's API."),

app/MindWork AI Studio/Components/Pages/IconFinder/AssistantIconFinder.razor

@@ -0,0 +1,29 @@
+@page "/assistant/icons"
+@using AIStudio.Settings
+@inherits AssistantBaseCore
+
+<MudTextField T="string" @bind-Text="@this.inputContext" Validation="@this.ValidatingContext" AdornmentIcon="@Icons.Material.Filled.Description" Adornment="Adornment.Start" Label="Your context" Variant="Variant.Outlined" Lines="3" AutoGrow="@true" MaxLines="12" Class="mb-3" UserAttributes="@USER_INPUT_ATTRIBUTES"/>
+
+<MudStack Row="@true" AlignItems="AlignItems.Center" Class="mb-3">
+    <MudSelect T="IconSources" @bind-Value="@this.selectedIconSource" AdornmentIcon="@Icons.Material.Filled.Source" Adornment="Adornment.Start" Label="Your icon source" Variant="Variant.Outlined" Margin="Margin.Dense">
+        @foreach (var source in Enum.GetValues<IconSources>())
+        {
+            <MudSelectItem Value="@source">@source.Name()</MudSelectItem>
+        }
+    </MudSelect>
+    @if (this.selectedIconSource is not IconSources.GENERIC)
+    {
+        <MudButton Href="@this.selectedIconSource.URL()" Target="_blank" Variant="Variant.Filled" Size="Size.Medium">Open website</MudButton>
+    }
+</MudStack>
+
+<MudSelect T="Provider" @bind-Value="@this.providerSettings" Validation="@this.ValidatingProvider" Adornment="Adornment.Start" AdornmentIcon="@Icons.Material.Filled.Apps" Margin="Margin.Dense" Label="Provider" Class="mb-3 rounded-lg" Variant="Variant.Outlined">
+    @foreach (var provider in this.SettingsManager.ConfigurationData.Providers)
+    {
+        <MudSelectItem Value="@provider"/>
+    }
+</MudSelect>
+
+<MudButton Variant="Variant.Filled" Class="mb-3" OnClick="() => this.FindIcon()">
+    Find icon
+</MudButton>

app/MindWork AI Studio/Components/Pages/IconFinder/AssistantIconFinder.razor.cs

@@ -0,0 +1,55 @@
+namespace AIStudio.Components.Pages.IconFinder;
+
+public partial class AssistantIconFinder : AssistantBaseCore
+{
+    private string inputContext = string.Empty;
+    private IconSources selectedIconSource;
+
+    protected override string Title => "Icon Finder";
+    
+    protected override string Description =>
+        """
+        Finding the right icon for a context, such as for a piece of text, is not easy. The first challenge:
+        You need to extract a concept from your context, such as from a text. Let's take an example where
+        your text contains statements about multiple departments. The sought-after concept could be "departments."
+        The next challenge is that we need to anticipate the bias of the icon designers: under the search term
+        "departments," there may be no relevant icons or only unsuitable ones. Depending on the icon source,
+        it might be more effective to search for "buildings," for instance. LLMs assist you with both steps.
+        """;
+    
+    protected override string SystemPrompt => 
+        """
+        I can search for icons using US English keywords. Please help me come up with the right search queries.
+        I don't want you to translate my requests word-for-word into US English. Instead, you should provide keywords
+        that are likely to yield suitable icons. For example, I might ask for an icon about departments, but icons
+        related to the keyword "buildings" might be the best match. Provide your keywords in a Markdown list without
+        quotation marks.
+        """;
+    
+    private string? ValidatingContext(string context)
+    {
+        if(string.IsNullOrWhiteSpace(context))
+            return "Please provide a context. This will help the AI to find the right icon. You might type just a keyword or copy a sentence from your text, e.g., from a slide where you want to use the icon.";
+        
+        return null;
+    }
+
+    private async Task FindIcon()
+    {
+        await this.form!.Validate();
+        if (!this.inputIsValid)
+            return;
+        
+        this.CreateChatThread();
+        var time = this.AddUserRequest(
+        $"""
+            {this.selectedIconSource.Prompt()} I search for an icon for the following context:
+            
+            ```
+            {this.inputContext}
+            ```
+         """);
+
+        await this.AddAIResponseAsync(time);
+    }
+}

app/MindWork AI Studio/Components/Pages/IconFinder/IconSourceExtensions.cs

@@ -0,0 +1,40 @@
+namespace AIStudio.Components.Pages.IconFinder;
+
+public static class IconSourceExtensions
+{
+    public static string Name(this IconSources iconSource) => iconSource switch
+    {
+        IconSources.FLAT_ICON => "Flaticon",
+        IconSources.FONT_AWESOME => "Font Awesome",
+        IconSources.MATERIAL_ICONS => "Material Icons",
+        IconSources.FEATHER_ICONS => "Feather Icons",
+        IconSources.BOOTSTRAP_ICONS => "Bootstrap Icons",
+        IconSources.ICONS8 => "Icons8",
+            
+        _ => "Generic",
+    };
+    
+    public static string Prompt(this IconSources iconSource) => iconSource switch
+    {
+        IconSources.FLAT_ICON => "My icon source is Flaticon.",
+        IconSources.FONT_AWESOME => "I look for an icon on Font Awesome. Please provide just valid icon names. Valid icon names are using the format `fa-icon-name`.",
+        IconSources.MATERIAL_ICONS => "I look for a Material icon. Please provide just valid icon names. Valid icon names are using the format `IconName`.",
+        IconSources.FEATHER_ICONS => "My icon source is Feather Icons. Please provide just valid icon names. Valid icon names usiing the format `icon-name`.",
+        IconSources.BOOTSTRAP_ICONS => "I look for an icon for Bootstrap. Please provide just valid icon names. Valid icon names are using the format `bi-icon-name`.",
+        IconSources.ICONS8 => "I look for an icon on Icons8.",
+            
+        _ => string.Empty,
+    };
+
+    public static string URL(this IconSources iconSource) => iconSource switch
+    {
+        IconSources.FLAT_ICON => "https://www.flaticon.com/",
+        IconSources.FONT_AWESOME => "https://fontawesome.com/",
+        IconSources.MATERIAL_ICONS => "https://material.io/resources/icons/",
+        IconSources.FEATHER_ICONS => "https://feathericons.com/",
+        IconSources.BOOTSTRAP_ICONS => "https://icons.getbootstrap.com/",
+        IconSources.ICONS8 => "https://icons8.com/",
+            
+        _ => string.Empty,
+    };
+}

app/MindWork AI Studio/Components/Pages/IconFinder/IconSources.cs

@@ -0,0 +1,13 @@
+namespace AIStudio.Components.Pages.IconFinder;
+
+public enum IconSources
+{
+    GENERIC,
+        
+    ICONS8,
+    FLAT_ICON,
+    FONT_AWESOME,
+    MATERIAL_ICONS,
+    FEATHER_ICONS,
+    BOOTSTRAP_ICONS,
+}

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

@@ -1,4 +1,6 @@
 @page "/settings"
+@using AIStudio.Provider
+@using Host = AIStudio.Provider.SelfHosted.Host
 
 <MudText Typo="Typo.h3" Class="mb-12">Settings</MudText>
 
@@ -11,7 +13,7 @@
                 <col style="width: 12em;"/>
                 <col style="width: 12em;"/>
                 <col/>
-                <col style="width: 20em;"/>
+                <col style="width: 34em;"/>
             </ColGroup>
             <HeaderContent>
                 <MudTh>#</MudTh>
@@ -24,12 +26,28 @@
                 <MudTd>@context.Num</MudTd>
                 <MudTd>@context.InstanceName</MudTd>
                 <MudTd>@context.UsedProvider</MudTd>
-                <MudTd>@context.Model</MudTd>
+                <MudTd>
+                    @if (context.UsedProvider is not Providers.SELF_HOSTED)
+                    {
+                        @this.GetProviderModelName(context)
+                    }
+                    else if (context.UsedProvider is Providers.SELF_HOSTED && context.Host is not Host.LLAMACPP)
+                    {
+                        @this.GetProviderModelName(context)
+                    }
+                    else
+                    {
+                        @("as selected by provider")
+                    }
+                </MudTd>
                 <MudTd Style="text-align: left;">
-                    <MudButton Variant="Variant.Filled" Color="Color.Info" StartIcon="@Icons.Material.Filled.Edit" Class="mr-2" OnClick="() => this.EditProvider(context)">
+                    <MudButton Variant="Variant.Filled" Color="Color.Info" StartIcon="@Icons.Material.Filled.OpenInBrowser" Class="ma-2" Href="@this.GetProviderDashboardURL(context.UsedProvider)" Target="_blank" Disabled="@(!this.HasDashboard(context.UsedProvider))">
+                        Open Dashboard
+                    </MudButton>
+                    <MudButton Variant="Variant.Filled" Color="Color.Info" StartIcon="@Icons.Material.Filled.Edit" Class="ma-2" OnClick="() => this.EditProvider(context)">
                         Edit
                     </MudButton>
-                    <MudButton Variant="Variant.Filled" Color="Color.Error" StartIcon="@Icons.Material.Filled.Delete" Class="mr-2" OnClick="() => this.DeleteProvider(context)">
+                    <MudButton Variant="Variant.Filled" Color="Color.Error" StartIcon="@Icons.Material.Filled.Delete" Class="ma-2" OnClick="() => this.DeleteProvider(context)">
                         Delete
                     </MudButton>
                 </MudTd>
@@ -53,5 +71,8 @@
         <ConfigurationOption OptionDescription="Enable spellchecking?" LabelOn="Spellchecking is enabled" LabelOff="Spellchecking is disabled" State="@(() => this.SettingsManager.ConfigurationData.EnableSpellchecking)" StateUpdate="@(updatedState => this.SettingsManager.ConfigurationData.EnableSpellchecking = updatedState)" OptionHelp="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." />
         <ConfigurationSelect OptionDescription="Shortcut to send input" SelectedValue="@(() => this.SettingsManager.ConfigurationData.ShortcutSendBehavior)" Data="@ConfigurationSelectDataFactory.GetSendBehaviorData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.ShortcutSendBehavior = selectedValue)" OptionHelp="Do you want to use any shortcut to send your input?"/>
         <ConfigurationSelect OptionDescription="Check for updates" SelectedValue="@(() => this.SettingsManager.ConfigurationData.UpdateBehavior)" Data="@ConfigurationSelectDataFactory.GetUpdateBehaviorData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.UpdateBehavior = selectedValue)" OptionHelp="How often should we check for app updates?"/>
+        <ConfigurationSelect OptionDescription="Workspace behavior" SelectedValue="@(() => this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior)" Data="@ConfigurationSelectDataFactory.GetWorkspaceStorageBehaviorData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.WorkspaceStorageBehavior = selectedValue)" OptionHelp="Should we store your chats?"/>
+        <ConfigurationSelect OptionDescription="Workspace maintenance" SelectedValue="@(() => this.SettingsManager.ConfigurationData.WorkspaceStorageTemporaryMaintenancePolicy)" Data="@ConfigurationSelectDataFactory.GetWorkspaceStorageTemporaryMaintenancePolicyData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.WorkspaceStorageTemporaryMaintenancePolicy = selectedValue)" OptionHelp="If and when should we delete your temporary chats?"/>
+        <ConfigurationSelect OptionDescription="Navigation bar behavior" SelectedValue="@(() => this.SettingsManager.ConfigurationData.NavigationBehavior)" Data="@ConfigurationSelectDataFactory.GetNavBehaviorData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.NavigationBehavior = selectedValue)" OptionHelp="Select the desired behavior for the navigation bar."/>
     </MudPaper>
 </InnerScrolling>

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

@@ -1,6 +1,8 @@
 using AIStudio.Components.CommonDialogs;
 using AIStudio.Provider;
 using AIStudio.Settings;
+using AIStudio.Tools;
+
 using Microsoft.AspNetCore.Components;
 
 using DialogOptions = AIStudio.Components.CommonDialogs.DialogOptions;
@@ -19,6 +21,9 @@ public partial class Settings : ComponentBase
     
     [Inject]
     public IJSRuntime JsRuntime { get; init; } = null!;
+    
+    [Inject]
+    protected MessageBus MessageBus { get; init; } = null!;
 
     #region Provider related
 
@@ -31,14 +36,15 @@ public partial class Settings : ComponentBase
         
         var dialogReference = await this.DialogService.ShowAsync<ProviderDialog>("Add Provider", dialogParameters, DialogOptions.FULLSCREEN);
         var dialogResult = await dialogReference.Result;
-        if (dialogResult.Canceled)
+        if (dialogResult is null || dialogResult.Canceled)
             return;
 
-        var addedProvider = (AIStudio.Settings.Provider)dialogResult.Data;
+        var addedProvider = (AIStudio.Settings.Provider)dialogResult.Data!;
         addedProvider = addedProvider with { Num = this.SettingsManager.ConfigurationData.NextProviderNum++ };
         
         this.SettingsManager.ConfigurationData.Providers.Add(addedProvider);
         await this.SettingsManager.StoreSettings();
+        await this.MessageBus.SendMessage<bool>(this, Event.CONFIGURATION_CHANGED);
     }
 
     private async Task EditProvider(AIStudio.Settings.Provider provider)
@@ -50,15 +56,18 @@ public partial class Settings : ComponentBase
             { x => x.DataInstanceName, provider.InstanceName },
             { x => x.DataProvider, provider.UsedProvider },
             { x => x.DataModel, provider.Model },
+            { x => x.DataHostname, provider.Hostname },
+            { x => x.IsSelfHosted, provider.IsSelfHosted },
             { x => x.IsEditing, true },
+            { x => x.DataHost, provider.Host },
         };
 
         var dialogReference = await this.DialogService.ShowAsync<ProviderDialog>("Edit Provider", dialogParameters, DialogOptions.FULLSCREEN);
         var dialogResult = await dialogReference.Result;
-        if (dialogResult.Canceled)
+        if (dialogResult is null || dialogResult.Canceled)
             return;
 
-        var editedProvider = (AIStudio.Settings.Provider)dialogResult.Data;
+        var editedProvider = (AIStudio.Settings.Provider)dialogResult.Data!;
         
         // Set the provider number if it's not set. This is important for providers
         // added before we started saving the provider number.
@@ -67,6 +76,7 @@ public partial class Settings : ComponentBase
         
         this.SettingsManager.ConfigurationData.Providers[this.SettingsManager.ConfigurationData.Providers.IndexOf(provider)] = editedProvider;
         await this.SettingsManager.StoreSettings();
+        await this.MessageBus.SendMessage<bool>(this, Event.CONFIGURATION_CHANGED);
     }
 
     private async Task DeleteProvider(AIStudio.Settings.Provider provider)
@@ -78,16 +88,45 @@ public partial class Settings : ComponentBase
         
         var dialogReference = await this.DialogService.ShowAsync<ConfirmDialog>("Delete Provider", dialogParameters, DialogOptions.FULLSCREEN);
         var dialogResult = await dialogReference.Result;
-        if (dialogResult.Canceled)
+        if (dialogResult is null || dialogResult.Canceled)
             return;
         
-        var providerInstance = provider.UsedProvider.CreateProvider(provider.InstanceName);
+        var providerInstance = provider.CreateProvider();
         var deleteSecretResponse = await this.SettingsManager.DeleteAPIKey(this.JsRuntime, providerInstance);
         if(deleteSecretResponse.Success)
         {
             this.SettingsManager.ConfigurationData.Providers.Remove(provider);
             await this.SettingsManager.StoreSettings();
         }
+        
+        await this.MessageBus.SendMessage<bool>(this, Event.CONFIGURATION_CHANGED);
+    }
+    
+    private bool HasDashboard(Providers provider) => provider switch
+    {
+        Providers.OPEN_AI => true,
+        Providers.MISTRAL => true,
+        Providers.ANTHROPIC => true,
+        Providers.FIREWORKS => true,
+        
+        _ => false,
+    };
+    
+    private string GetProviderDashboardURL(Providers provider) => provider switch
+    {
+        Providers.OPEN_AI => "https://platform.openai.com/usage",
+        Providers.MISTRAL => "https://console.mistral.ai/usage/",
+        Providers.ANTHROPIC => "https://console.anthropic.com/settings/plans",
+        Providers.FIREWORKS => "https://fireworks.ai/account/billing",
+        
+        _ => string.Empty,
+    };
+
+    private string GetProviderModelName(AIStudio.Settings.Provider provider)
+    {
+        const int MAX_LENGTH = 36;
+        var modelName = provider.Model.ToString();
+        return modelName.Length > MAX_LENGTH ? "[...] " + modelName[^Math.Min(MAX_LENGTH, modelName.Length)..] : modelName;
     }
 
     #endregion

app/MindWork AI Studio/Components/Pages/TextSummarizer/AssistantTextSummarizer.razor

@@ -0,0 +1,43 @@
+@page "/assistant/summarizer"
+@using AIStudio.Settings
+@using AIStudio.Tools
+@inherits AssistantBaseCore
+
+<MudTextField T="string" @bind-Text="@this.inputText" Validation="@this.ValidatingText" AdornmentIcon="@Icons.Material.Filled.DocumentScanner" Adornment="Adornment.Start" Label="Your input" Variant="Variant.Outlined" Lines="6" AutoGrow="@true" MaxLines="12" Class="mb-3" UserAttributes="@USER_INPUT_ATTRIBUTES"/>
+
+<MudStack Row="@true" AlignItems="AlignItems.Center" Class="mb-3">
+    <MudSelect T="CommonLanguages" @bind-Value="@this.selectedTargetLanguage" AdornmentIcon="@Icons.Material.Filled.Translate" Adornment="Adornment.Start" Label="Target language" Variant="Variant.Outlined" Margin="Margin.Dense">
+        @foreach (var targetLanguage in Enum.GetValues<CommonLanguages>())
+        {
+            <MudSelectItem Value="@targetLanguage">@targetLanguage.Name()</MudSelectItem>
+        }
+    </MudSelect>
+    @if (this.selectedTargetLanguage is CommonLanguages.OTHER)
+    {
+        <MudTextField T="string" @bind-Text="@this.customTargetLanguage" Validation="@this.ValidateCustomLanguage" Label="Custom target language" Variant="Variant.Outlined" Margin="Margin.Dense" UserAttributes="@USER_INPUT_ATTRIBUTES"/>
+    }
+</MudStack>
+
+<MudStack Row="@true" AlignItems="AlignItems.Center" Class="mb-3">
+    <MudSelect T="Complexity" @bind-Value="@this.selectedComplexity" AdornmentIcon="@Icons.Material.Filled.Layers" Adornment="Adornment.Start" Label="Target complexity" Variant="Variant.Outlined" Margin="Margin.Dense">
+        @foreach (var targetComplexity in Enum.GetValues<Complexity>())
+        {
+            <MudSelectItem Value="@targetComplexity">@targetComplexity.Name()</MudSelectItem>
+        }
+    </MudSelect>
+    @if (this.selectedComplexity is Complexity.SCIENTIFIC_LANGUAGE_OTHER_EXPERTS)
+    {
+        <MudTextField T="string" @bind-Text="@this.expertInField" Validation="@this.ValidateExpertInField" Label="Your expertise" Variant="Variant.Outlined" Margin="Margin.Dense" UserAttributes="@USER_INPUT_ATTRIBUTES"/>
+    }
+</MudStack>
+
+<MudSelect T="Provider" @bind-Value="@this.providerSettings" Validation="@this.ValidatingProvider" Adornment="Adornment.Start" AdornmentIcon="@Icons.Material.Filled.Apps" Margin="Margin.Dense" Label="Provider" Class="mb-3 rounded-lg" Variant="Variant.Outlined">
+    @foreach (var provider in this.SettingsManager.ConfigurationData.Providers)
+    {
+        <MudSelectItem Value="@provider"/>
+    }
+</MudSelect>
+
+<MudButton Variant="Variant.Filled" Class="mb-3" OnClick="() => this.SummarizeText()">
+    Summarize
+</MudButton>

app/MindWork AI Studio/Components/Pages/TextSummarizer/AssistantTextSummarizer.razor.cs

@@ -0,0 +1,77 @@
+using AIStudio.Tools;
+
+namespace AIStudio.Components.Pages.TextSummarizer;
+
+public partial class AssistantTextSummarizer : AssistantBaseCore
+{
+    protected override string Title => "Text Summarizer";
+    
+    protected override string Description =>
+        """
+        Summarize long text into a shorter version while retaining the main points.
+        You might want to change the language of the summary to make it more readable.
+        It is also possible to change the complexity of the summary to make it
+        easy to understand.
+        """;
+    
+    protected override string SystemPrompt => 
+        """
+        You get a long text as input. The user wants to get a summary of the text.
+        The user might want to change the language of the summary. In this case,
+        you should provide a summary in the requested language. Eventually, the user
+        want to change the complexity of the text. In this case, you should provide
+        a summary with the requested complexity. In any case, do not add any information.
+        """;
+    
+    private string inputText = string.Empty;
+    private CommonLanguages selectedTargetLanguage;
+    private string customTargetLanguage = string.Empty;
+    private Complexity selectedComplexity;
+    private string expertInField = string.Empty;
+
+    private string? ValidatingText(string text)
+    {
+        if(string.IsNullOrWhiteSpace(text))
+            return "Please provide a text as input. You might copy the desired text from a document or a website.";
+        
+        return null;
+    }
+    
+    private string? ValidateCustomLanguage(string language)
+    {
+        if(this.selectedTargetLanguage == CommonLanguages.OTHER && string.IsNullOrWhiteSpace(language))
+            return "Please provide a custom language.";
+        
+        return null;
+    }
+    
+    private string? ValidateExpertInField(string field)
+    {
+        if(this.selectedComplexity == Complexity.SCIENTIFIC_LANGUAGE_OTHER_EXPERTS && string.IsNullOrWhiteSpace(field))
+            return "Please provide your field of expertise.";
+        
+        return null;
+    }
+
+    private async Task SummarizeText()
+    {
+        await this.form!.Validate();
+        if (!this.inputIsValid)
+            return;
+        
+        this.CreateChatThread();
+        var time = this.AddUserRequest(
+            $"""
+                {this.selectedTargetLanguage.Prompt(this.customTargetLanguage)}
+                {this.selectedComplexity.Prompt(this.expertInField)}
+                
+                Please summarize the following text:
+                
+                ```
+                {this.inputText}
+                ```
+             """);
+
+        await this.AddAIResponseAsync(time);
+    }
+}

app/MindWork AI Studio/Components/Pages/TextSummarizer/CommonLanguagePrompts.cs

@@ -0,0 +1,14 @@
+using AIStudio.Tools;
+
+namespace AIStudio.Components.Pages.TextSummarizer;
+
+public static class CommonLanguagePrompts
+{
+    public static string Prompt(this CommonLanguages language, string customLanguage) => language switch
+    {
+        CommonLanguages.AS_IS => "Do not change the language of the text.",
+        CommonLanguages.OTHER => $"Output you summary in {customLanguage}.",
+
+        _ => $"Output your summary in {language.Name()} ({language}).",
+    };
+}

app/MindWork AI Studio/Components/Pages/TextSummarizer/Complexity.cs

@@ -0,0 +1,13 @@
+namespace AIStudio.Components.Pages.TextSummarizer;
+
+public enum Complexity
+{
+    NO_CHANGE,
+    
+    SIMPLE_LANGUAGE,
+    TEEN_LANGUAGE,
+    EVERYDAY_LANGUAGE,
+    POPULAR_SCIENCE_LANGUAGE,
+    SCIENTIFIC_LANGUAGE_FIELD_EXPERTS,
+    SCIENTIFIC_LANGUAGE_OTHER_EXPERTS,
+}

app/MindWork AI Studio/Components/Pages/TextSummarizer/ComplexityExtensions.cs

@@ -0,0 +1,32 @@
+namespace AIStudio.Components.Pages.TextSummarizer;
+
+public static class ComplexityExtensions
+{
+    public static string Name(this Complexity complexity) => complexity switch
+    {
+        Complexity.NO_CHANGE => "No change in complexity",
+        
+        Complexity.SIMPLE_LANGUAGE => "Simple language, e.g., for children",
+        Complexity.TEEN_LANGUAGE => "Teen language, e.g., for teenagers",
+        Complexity.EVERYDAY_LANGUAGE => "Everyday language, e.g., for adults",
+        Complexity.POPULAR_SCIENCE_LANGUAGE => "Popular science language, e.g., for people interested in science",
+        Complexity.SCIENTIFIC_LANGUAGE_FIELD_EXPERTS => "Scientific language for experts in this field",
+        Complexity.SCIENTIFIC_LANGUAGE_OTHER_EXPERTS => "Scientific language for experts from other fields (interdisciplinary)",
+        
+        _ => "No change in complexity",
+    };
+    
+    public static string Prompt(this Complexity complexity, string expertInField) => complexity switch
+    {
+        Complexity.NO_CHANGE => "Do not change the complexity of the text.",
+        
+        Complexity.SIMPLE_LANGUAGE => "Simplify the language, e.g., for 8 to 12-year-old children. Might use short sentences and simple words. You could use analogies to explain complex terms.",
+        Complexity.TEEN_LANGUAGE => "Use a language suitable for teenagers, e.g., 16 to 19 years old. Might use teenage slang and analogies to explain complex terms.",
+        Complexity.EVERYDAY_LANGUAGE => "Use everyday language suitable for adults. Avoid specific scientific terms. Use everday analogies to explain complex terms.",
+        Complexity.POPULAR_SCIENCE_LANGUAGE => "Use popular science language, e.g., for people interested in science. The text should be easy to understand, though. Use analogies to explain complex terms.",
+        Complexity.SCIENTIFIC_LANGUAGE_FIELD_EXPERTS => "Use scientific language for experts in the field of the texts subject. Use specific terms for this field.",
+        Complexity.SCIENTIFIC_LANGUAGE_OTHER_EXPERTS => $"The reader is an expert in {expertInField}. Change the language so that it is suitable. Explain specific terms, so that the reader within his field can understand the text. You might use analogies to explain complex terms.",
+        
+        _ => "Do not change the complexity of the text.",
+    };
+}

app/MindWork AI Studio/Components/Pages/Translator/AssistantTranslator.razor

@@ -0,0 +1,50 @@
+@page "/assistant/translator"
+@using AIStudio.Settings
+@using AIStudio.Tools
+@inherits AssistantBaseCore
+
+<MudField Label="Live translation" Variant="Variant.Outlined" Class="mb-3">
+    <MudSwitch T="bool" @bind-Value="@this.liveTranslation">
+        @(this.liveTranslation ? "Live translation" : "No live translation")
+    </MudSwitch>
+</MudField>
+
+@if (this.liveTranslation)
+{
+    <MudTextField T="string" @bind-Text="@this.inputText" Validation="@this.ValidatingText" AdornmentIcon="@Icons.Material.Filled.DocumentScanner" Adornment="Adornment.Start" Label="Your input" Variant="Variant.Outlined" Lines="6" AutoGrow="@true" MaxLines="12" Class="mb-3" Immediate="@true" DebounceInterval="1_000" OnDebounceIntervalElapsed="() => this.TranslateText(force: false)" UserAttributes="@USER_INPUT_ATTRIBUTES"/>
+}
+else
+{
+    <MudTextField T="string" @bind-Text="@this.inputText" Validation="@this.ValidatingText" AdornmentIcon="@Icons.Material.Filled.DocumentScanner" Adornment="Adornment.Start" Label="Your input" Variant="Variant.Outlined" Lines="6" AutoGrow="@true" MaxLines="12" Class="mb-3" UserAttributes="@USER_INPUT_ATTRIBUTES"/>
+}
+
+<MudStack Row="@true" AlignItems="AlignItems.Center" Class="mb-3">
+    <MudSelect T="CommonLanguages" @bind-Value="@this.selectedTargetLanguage" Validation="@this.ValidatingTargetLanguage" AdornmentIcon="@Icons.Material.Filled.Translate" Adornment="Adornment.Start" Label="Target language" Variant="Variant.Outlined" Margin="Margin.Dense">
+        @foreach (var targetLanguage in Enum.GetValues<CommonLanguages>())
+        {
+            if (targetLanguage is CommonLanguages.AS_IS)
+            {
+                <MudSelectItem Value="@targetLanguage">Please select the target language</MudSelectItem>
+            }
+            else
+            {
+                <MudSelectItem Value="@targetLanguage">@targetLanguage.Name()</MudSelectItem>
+            }
+        }
+    </MudSelect>
+    @if (this.selectedTargetLanguage is CommonLanguages.OTHER)
+    {
+        <MudTextField T="string" @bind-Text="@this.customTargetLanguage" Validation="@this.ValidateCustomLanguage" Label="Custom target language" Variant="Variant.Outlined" Margin="Margin.Dense" UserAttributes="@USER_INPUT_ATTRIBUTES"/>
+    }
+</MudStack>
+
+<MudSelect T="Provider" @bind-Value="@this.providerSettings" Validation="@this.ValidatingProvider" Adornment="Adornment.Start" AdornmentIcon="@Icons.Material.Filled.Apps" Margin="Margin.Dense" Label="Provider" Class="mb-3 rounded-lg" Variant="Variant.Outlined">
+    @foreach (var provider in this.SettingsManager.ConfigurationData.Providers)
+    {
+        <MudSelectItem Value="@provider"/>
+    }
+</MudSelect>
+
+<MudButton Variant="Variant.Filled" Class="mb-3" OnClick="() => this.TranslateText(force: true)">
+    Translate
+</MudButton>

app/MindWork AI Studio/Components/Pages/Translator/AssistantTranslator.razor.cs

@@ -0,0 +1,74 @@
+using AIStudio.Tools;
+
+namespace AIStudio.Components.Pages.Translator;
+
+public partial class AssistantTranslator : AssistantBaseCore
+{
+    protected override string Title => "Translator";
+    
+    protected override string Description =>
+        """
+        Translate text from one language to another.
+        """;
+    
+    protected override string SystemPrompt => 
+        """
+        You get text in a source language as input. The user wants to get the text translated into a target language.
+        Provide the translation in the requested language. Do not add any information. Correct any spelling or grammar mistakes.
+        Do not ask for additional information. Do not mirror the user's language. Do not mirror the task. When the target
+        language requires, e.g., shorter sentences, you should split the text into shorter sentences.
+        """;
+    
+    private bool liveTranslation;
+    private string inputText = string.Empty;
+    private string inputTextLastTranslation = string.Empty;
+    private CommonLanguages selectedTargetLanguage;
+    private string customTargetLanguage = string.Empty;
+    
+    private string? ValidatingText(string text)
+    {
+        if(string.IsNullOrWhiteSpace(text))
+            return "Please provide a text as input. You might copy the desired text from a document or a website.";
+        
+        return null;
+    }
+    
+    private string? ValidatingTargetLanguage(CommonLanguages language)
+    {
+        if(language == CommonLanguages.AS_IS)
+            return "Please select a target language.";
+        
+        return null;
+    }
+    
+    private string? ValidateCustomLanguage(string language)
+    {
+        if(this.selectedTargetLanguage == CommonLanguages.OTHER && string.IsNullOrWhiteSpace(language))
+            return "Please provide a custom language.";
+        
+        return null;
+    }
+    
+    private async Task TranslateText(bool force)
+    {
+        if (!this.inputIsValid)
+            return;
+        
+        if(!force && this.inputText == this.inputTextLastTranslation)
+            return;
+        
+        this.inputTextLastTranslation = this.inputText;
+        this.CreateChatThread();
+        var time = this.AddUserRequest(
+            $"""
+                {this.selectedTargetLanguage.Prompt(this.customTargetLanguage)}
+                
+                The given text is:
+                
+                ---
+                {this.inputText}
+             """);
+
+        await this.AddAIResponseAsync(time);
+    }
+}

app/MindWork AI Studio/Components/Pages/Translator/CommonLanguageExtension.cs

@@ -0,0 +1,13 @@
+using AIStudio.Tools;
+
+namespace AIStudio.Components.Pages.Translator;
+
+public static class CommonLanguageExtension
+{
+    public static string Prompt(this CommonLanguages language, string customLanguage) => language switch
+    {
+        CommonLanguages.OTHER => $"Translate the text in {customLanguage}.",
+
+        _ => $"Translate the given text in {language.Name()} ({language}).",
+    };
+}

app/MindWork AI Studio/Components/Routes.razor

@@ -7,4 +7,5 @@
 
 <MudThemeProvider />
 <MudDialogProvider />
+<MudPopoverProvider />
 <MudSnackbarProvider />

app/MindWork AI Studio/MindWork AI Studio.csproj

@@ -45,8 +45,8 @@
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="Microsoft.Extensions.FileProviders.Embedded" Version="8.0.6" />
-      <PackageReference Include="MudBlazor" Version="6.20.0" />
+      <PackageReference Include="Microsoft.Extensions.FileProviders.Embedded" Version="8.0.7" />
+      <PackageReference Include="MudBlazor" Version="7.4.0" />
       <PackageReference Include="MudBlazor.Markdown" Version="1.0.2" />
     </ItemGroup>
 

app/MindWork AI Studio/Program.cs

@@ -31,6 +31,7 @@ builder.Services.AddMudMarkdownClipboardService<MarkdownClipboardService>();
 builder.Services.AddSingleton<SettingsManager>();
 builder.Services.AddSingleton<Random>();
 builder.Services.AddHostedService<UpdateService>();
+builder.Services.AddHostedService<TemporaryChatService>();
 builder.Services.AddRazorComponents()
     .AddInteractiveServerComponents()
     .AddHubOptions(options =>

app/MindWork AI Studio/Provider/Anthropic/ChatRequest.cs

@@ -0,0 +1,19 @@
+using AIStudio.Provider.OpenAI;
+
+namespace AIStudio.Provider.Anthropic;
+
+/// <summary>
+/// The Anthropic chat request model.
+/// </summary>
+/// <param name="Model">Which model to use for chat completion.</param>
+/// <param name="Messages">The chat messages.</param>
+/// <param name="MaxTokens">The maximum number of tokens to generate.</param>
+/// <param name="Stream">Whether to stream the chat completion.</param>
+/// <param name="System">The system prompt for the chat completion.</param>
+public readonly record struct ChatRequest(
+    string Model,
+    IList<Message> Messages,
+    int MaxTokens,
+    bool Stream,
+    string System
+);

app/MindWork AI Studio/Provider/Anthropic/ProviderAnthropic.cs

@@ -0,0 +1,166 @@
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Text.Json;
+
+using AIStudio.Chat;
+using AIStudio.Provider.OpenAI;
+using AIStudio.Settings;
+
+namespace AIStudio.Provider.Anthropic;
+
+public sealed class ProviderAnthropic() : BaseProvider("https://api.anthropic.com/v1/"), IProvider
+{
+    private static readonly JsonSerializerOptions JSON_SERIALIZER_OPTIONS = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
+    };
+
+    #region Implementation of IProvider
+
+    public string Id => "Anthropic";
+
+    public string InstanceName { get; set; } = "Anthropic";
+
+    /// <inheritdoc />
+    public async IAsyncEnumerable<string> StreamChatCompletion(IJSRuntime jsRuntime, SettingsManager settings, Model chatModel, ChatThread chatThread, [EnumeratorCancellation] CancellationToken token = default)
+    {
+        // Get the API key:
+        var requestedSecret = await settings.GetAPIKey(jsRuntime, this);
+        if(!requestedSecret.Success)
+            yield break;
+
+        // Prepare the Anthropic HTTP chat request:
+        var chatRequest = JsonSerializer.Serialize(new ChatRequest
+        {
+            Model = chatModel.Id,
+            
+            // Build the messages:
+            Messages = [..chatThread.Blocks.Where(n => n.ContentType is ContentType.TEXT && !string.IsNullOrWhiteSpace((n.Content as ContentText)?.Text)).Select(n => new Message
+            {
+                Role = n.Role switch
+                {
+                    ChatRole.USER => "user",
+                    ChatRole.AI => "assistant",
+
+                    _ => "user",
+                },
+
+                Content = n.Content switch
+                {
+                    ContentText text => text.Text,
+                    _ => string.Empty,
+                }
+            }).ToList()],
+            
+            System = chatThread.SystemPrompt,
+            MaxTokens = 4_096,
+            
+            // Right now, we only support streaming completions:
+            Stream = true,
+        }, JSON_SERIALIZER_OPTIONS);
+        
+        // Build the HTTP post request:
+        var request = new HttpRequestMessage(HttpMethod.Post, "messages");
+        
+        // Set the authorization header:
+        request.Headers.Add("x-api-key", requestedSecret.Secret);
+        
+        // Set the Anthropic version:
+        request.Headers.Add("anthropic-version", "2023-06-01");
+        
+        // Set the content:
+        request.Content = new StringContent(chatRequest, Encoding.UTF8, "application/json");
+        
+        // Send the request with the ResponseHeadersRead option.
+        // This allows us to read the stream as soon as the headers are received.
+        // This is important because we want to stream the responses.
+        var response = await this.httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, token);
+        
+        // Open the response stream:
+        var stream = await response.Content.ReadAsStreamAsync(token);
+        
+        // Add a stream reader to read the stream, line by line:
+        var streamReader = new StreamReader(stream);
+        
+        // Read the stream, line by line:
+        while(!streamReader.EndOfStream)
+        {
+            // Check if the token is canceled:
+            if(token.IsCancellationRequested)
+                yield break;
+            
+            // Read the next line:
+            var line = await streamReader.ReadLineAsync(token);
+            
+            // Skip empty lines:
+            if(string.IsNullOrWhiteSpace(line))
+                continue;
+            
+            // Check for the end of the stream:
+            if(line.StartsWith("event: message_stop", StringComparison.InvariantCulture))
+                yield break;
+            
+            // Skip lines that do not start with "data: ". Regard
+            // to the specification, we only want to read the data lines:
+            if(!line.StartsWith("data: ", StringComparison.InvariantCulture))
+                continue;
+            
+            // Ignore any type except "content_block_delta":
+            if(!line.Contains("\"content_block_delta\"", StringComparison.InvariantCulture))
+                continue;
+
+            ResponseStreamLine anthropicResponse;
+            try
+            {
+                // We know that the line starts with "data: ". Hence, we can
+                // skip the first 6 characters to get the JSON data after that.
+                var jsonData = line[6..];
+                
+                // Deserialize the JSON data:
+                anthropicResponse = JsonSerializer.Deserialize<ResponseStreamLine>(jsonData, JSON_SERIALIZER_OPTIONS);
+            }
+            catch
+            {
+                // Skip invalid JSON data:
+                continue;
+            }    
+            
+            // Skip empty responses:
+            if(anthropicResponse == default || string.IsNullOrWhiteSpace(anthropicResponse.Delta.Text))
+                continue;
+            
+            // Yield the response:
+            yield return anthropicResponse.Delta.Text;
+        }
+    }
+
+    #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+    /// <inheritdoc />
+    public async IAsyncEnumerable<ImageURL> StreamImageCompletion(IJSRuntime jsRuntime, SettingsManager settings, Model imageModel, string promptPositive, string promptNegative = FilterOperator.String.Empty, ImageURL referenceImageURL = default, [EnumeratorCancellation] CancellationToken token = default)
+    {
+        yield break;
+    }
+    #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
+
+    /// <inheritdoc />
+    public Task<IEnumerable<Model>> GetTextModels(IJSRuntime jsRuntime, SettingsManager settings, string? apiKeyProvisional = null, CancellationToken token = default)
+    {
+        return Task.FromResult(new[]
+        {
+            new Model("claude-3-5-sonnet-20240620"),
+            new Model("claude-3-opus-20240229"),
+            new Model("claude-3-sonnet-20240229"),
+            new Model("claude-3-haiku-20240307"),
+        }.AsEnumerable());
+    }
+
+    #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+    /// <inheritdoc />
+    public Task<IEnumerable<Model>> GetImageModels(IJSRuntime jsRuntime, SettingsManager settings, string? apiKeyProvisional = null, CancellationToken token = default)
+    {
+        return Task.FromResult(Enumerable.Empty<Model>());
+    }
+    #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
+
+    #endregion
+}

app/MindWork AI Studio/Provider/Anthropic/ResponseStreamLine.cs

@@ -0,0 +1,17 @@
+// ReSharper disable NotAccessedPositionalProperty.Global
+namespace AIStudio.Provider.Anthropic;
+
+/// <summary>
+/// Represents a response stream line.
+/// </summary>
+/// <param name="Type">The type of the response line.</param>
+/// <param name="Index">The index of the response line.</param>
+/// <param name="Delta">The delta of the response line.</param>
+public readonly record struct ResponseStreamLine(string Type, int Index, Delta Delta);
+
+/// <summary>
+/// The delta object of a response line.
+/// </summary>
+/// <param name="Type">The type of the delta.</param>
+/// <param name="Text">The text of the delta.</param>
+public readonly record struct Delta(string Type, string Text);

app/MindWork AI Studio/Provider/Fireworks/ChatRequest.cs

@@ -0,0 +1,13 @@
+namespace AIStudio.Provider.Fireworks;
+
+/// <summary>
+/// The Fireworks chat request model.
+/// </summary>
+/// <param name="Model">Which model to use for chat completion.</param>
+/// <param name="Messages">The chat messages.</param>
+/// <param name="Stream">Whether to stream the chat completion.</param>
+public readonly record struct ChatRequest(
+    string Model,
+    IList<Message> Messages,
+    bool Stream
+);

app/MindWork AI Studio/Provider/Fireworks/Message.cs

@@ -0,0 +1,8 @@
+namespace AIStudio.Provider.Fireworks;
+
+/// <summary>
+/// Chat message model.
+/// </summary>
+/// <param name="Content">The text content of the message.</param>
+/// <param name="Role">The role of the message.</param>
+public readonly record struct Message(string Content, string Role);

app/MindWork AI Studio/Provider/Fireworks/ProviderFireworks.cs

@@ -0,0 +1,160 @@
+using System.Net.Http.Headers;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Text.Json;
+
+using AIStudio.Chat;
+using AIStudio.Settings;
+
+namespace AIStudio.Provider.Fireworks;
+
+public class ProviderFireworks() : BaseProvider("https://api.fireworks.ai/inference/v1/"), IProvider
+{
+    private static readonly JsonSerializerOptions JSON_SERIALIZER_OPTIONS = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
+    };
+    
+    #region Implementation of IProvider
+
+    /// <inheritdoc />
+    public string Id => "Fireworks.ai";
+
+    /// <inheritdoc />
+    public string InstanceName { get; set; } = "Fireworks.ai";
+
+    /// <inheritdoc />
+    public async IAsyncEnumerable<string> StreamChatCompletion(IJSRuntime jsRuntime, SettingsManager settings, Model chatModel, ChatThread chatThread, [EnumeratorCancellation] CancellationToken token = default)
+    {
+        // Get the API key:
+        var requestedSecret = await settings.GetAPIKey(jsRuntime, this);
+        if(!requestedSecret.Success)
+            yield break;
+
+        // Prepare the system prompt:
+        var systemPrompt = new Message
+        {
+            Role = "system",
+            Content = chatThread.SystemPrompt,
+        };
+        
+        // Prepare the Fireworks HTTP chat request:
+        var fireworksChatRequest = JsonSerializer.Serialize(new ChatRequest
+        {
+            Model = chatModel.Id,
+            
+            // Build the messages:
+            // - First of all the system prompt
+            // - Then none-empty user and AI messages
+            Messages = [systemPrompt, ..chatThread.Blocks.Where(n => n.ContentType is ContentType.TEXT && !string.IsNullOrWhiteSpace((n.Content as ContentText)?.Text)).Select(n => new Message
+            {
+                Role = n.Role switch
+                {
+                    ChatRole.USER => "user",
+                    ChatRole.AI => "assistant",
+                    ChatRole.SYSTEM => "system",
+
+                    _ => "user",
+                },
+
+                Content = n.Content switch
+                {
+                    ContentText text => text.Text,
+                    _ => string.Empty,
+                }
+            }).ToList()],
+            
+            // Right now, we only support streaming completions:
+            Stream = true,
+        }, JSON_SERIALIZER_OPTIONS);
+
+        // Build the HTTP post request:
+        var request = new HttpRequestMessage(HttpMethod.Post, "chat/completions");
+        
+        // Set the authorization header:
+        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", requestedSecret.Secret);
+        
+        // Set the content:
+        request.Content = new StringContent(fireworksChatRequest, Encoding.UTF8, "application/json");
+        
+        // Send the request with the ResponseHeadersRead option.
+        // This allows us to read the stream as soon as the headers are received.
+        // This is important because we want to stream the responses.
+        var response = await this.httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, token);
+        
+        // Open the response stream:
+        var fireworksStream = await response.Content.ReadAsStreamAsync(token);
+        
+        // Add a stream reader to read the stream, line by line:
+        var streamReader = new StreamReader(fireworksStream);
+        
+        // Read the stream, line by line:
+        while(!streamReader.EndOfStream)
+        {
+            // Check if the token is canceled:
+            if(token.IsCancellationRequested)
+                yield break;
+            
+            // Read the next line:
+            var line = await streamReader.ReadLineAsync(token);
+            
+            // Skip empty lines:
+            if(string.IsNullOrWhiteSpace(line))
+                continue;
+            
+            // Skip lines that do not start with "data: ". Regard
+            // to the specification, we only want to read the data lines:
+            if(!line.StartsWith("data: ", StringComparison.InvariantCulture))
+                continue;
+
+            // Check if the line is the end of the stream:
+            if (line.StartsWith("data: [DONE]", StringComparison.InvariantCulture))
+                yield break;
+
+            ResponseStreamLine fireworksResponse;
+            try
+            {
+                // We know that the line starts with "data: ". Hence, we can
+                // skip the first 6 characters to get the JSON data after that.
+                var jsonData = line[6..];
+                
+                // Deserialize the JSON data:
+                fireworksResponse = JsonSerializer.Deserialize<ResponseStreamLine>(jsonData, JSON_SERIALIZER_OPTIONS);
+            }
+            catch
+            {
+                // Skip invalid JSON data:
+                continue;
+            }    
+            
+            // Skip empty responses:
+            if(fireworksResponse == default || fireworksResponse.Choices.Count == 0)
+                continue;
+            
+            // Yield the response:
+            yield return fireworksResponse.Choices[0].Delta.Content;
+        }
+    }
+
+    #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+    /// <inheritdoc />
+    public async IAsyncEnumerable<ImageURL> StreamImageCompletion(IJSRuntime jsRuntime, SettingsManager settings, Model imageModel, string promptPositive, string promptNegative = FilterOperator.String.Empty, ImageURL referenceImageURL = default, [EnumeratorCancellation] CancellationToken token = default)
+    {
+        yield break;
+    }
+    #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
+
+    /// <inheritdoc />
+    public Task<IEnumerable<Model>> GetTextModels(IJSRuntime jsRuntime, SettingsManager settings, string? apiKeyProvisional = null, CancellationToken token = default)
+    {
+        return Task.FromResult(Enumerable.Empty<Model>());
+    }
+
+    /// <inheritdoc />
+    public Task<IEnumerable<Model>> GetImageModels(IJSRuntime jsRuntime, SettingsManager settings, string? apiKeyProvisional = null, CancellationToken token = default)
+    {
+        return Task.FromResult(Enumerable.Empty<Model>());
+    }
+
+    #endregion
+}

app/MindWork AI Studio/Provider/Fireworks/ResponseStreamLine.cs

@@ -0,0 +1,24 @@
+namespace AIStudio.Provider.Fireworks;
+
+/// <summary>
+/// Data model for a line in the response stream, for streaming completions.
+/// </summary>
+/// <param name="Id">The id of the response.</param>
+/// <param name="Object">The object describing the response.</param>
+/// <param name="Created">The timestamp of the response.</param>
+/// <param name="Model">The model used for the response.</param>
+/// <param name="Choices">The choices made by the AI.</param>
+public readonly record struct ResponseStreamLine(string Id, string Object, uint Created, string Model, IList<Choice> Choices);
+
+/// <summary>
+/// Data model for a choice made by the AI.
+/// </summary>
+/// <param name="Index">The index of the choice.</param>
+/// <param name="Delta">The delta text of the choice.</param>
+public readonly record struct Choice(int Index, Delta Delta);
+
+/// <summary>
+/// The delta text of a choice.
+/// </summary>
+/// <param name="Content">The content of the delta text.</param>
+public readonly record struct Delta(string Content);

app/MindWork AI Studio/Provider/Mistral/ChatRequest.cs

@@ -0,0 +1,17 @@
+namespace AIStudio.Provider.Mistral;
+
+/// <summary>
+/// The OpenAI chat request model.
+/// </summary>
+/// <param name="Model">Which model to use for chat completion.</param>
+/// <param name="Messages">The chat messages.</param>
+/// <param name="Stream">Whether to stream the chat completion.</param>
+/// <param name="RandomSeed">The seed for the chat completion.</param>
+/// <param name="SafePrompt">Whether to inject a safety prompt before all conversations.</param>
+public readonly record struct ChatRequest(
+    string Model,
+    IList<RegularMessage> Messages,
+    bool Stream,
+    int RandomSeed,
+    bool SafePrompt = false
+);

app/MindWork AI Studio/Provider/Mistral/ModelsResponse.cs

@@ -0,0 +1,5 @@
+namespace AIStudio.Provider.Mistral;
+
+public readonly record struct ModelsResponse(string Object, Model[] Data);
+
+public readonly record struct Model(string Id, string Object, int Created, string OwnedBy);

app/MindWork AI Studio/Provider/Mistral/ProviderMistral.cs

@@ -0,0 +1,188 @@
+using System.Net.Http.Headers;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Text.Json;
+
+using AIStudio.Chat;
+using AIStudio.Provider.OpenAI;
+using AIStudio.Settings;
+
+namespace AIStudio.Provider.Mistral;
+
+public sealed class ProviderMistral() : BaseProvider("https://api.mistral.ai/v1/"), IProvider
+{
+    private static readonly JsonSerializerOptions JSON_SERIALIZER_OPTIONS = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
+    };
+    
+    #region Implementation of IProvider
+
+    public string Id => "Mistral";
+    
+    public string InstanceName { get; set; } = "Mistral";
+
+    /// <inheritdoc />
+    public async IAsyncEnumerable<string> StreamChatCompletion(IJSRuntime jsRuntime, SettingsManager settings, Provider.Model chatModel, ChatThread chatThread, [EnumeratorCancellation] CancellationToken token = default)
+    {
+        // Get the API key:
+        var requestedSecret = await settings.GetAPIKey(jsRuntime, this);
+        if(!requestedSecret.Success)
+            yield break;
+
+        // Prepare the system prompt:
+        var systemPrompt = new RegularMessage
+        {
+            Role = "system",
+            Content = chatThread.SystemPrompt,
+        };
+        
+        // Prepare the Mistral HTTP chat request:
+        var mistralChatRequest = JsonSerializer.Serialize(new ChatRequest
+        {
+            Model = chatModel.Id,
+            
+            // Build the messages:
+            // - First of all the system prompt
+            // - Then none-empty user and AI messages
+            Messages = [systemPrompt, ..chatThread.Blocks.Where(n => n.ContentType is ContentType.TEXT && !string.IsNullOrWhiteSpace((n.Content as ContentText)?.Text)).Select(n => new RegularMessage
+            {
+                Role = n.Role switch
+                {
+                    ChatRole.USER => "user",
+                    ChatRole.AI => "assistant",
+                    ChatRole.SYSTEM => "system",
+
+                    _ => "user",
+                },
+
+                Content = n.Content switch
+                {
+                    ContentText text => text.Text,
+                    _ => string.Empty,
+                }
+            }).ToList()],
+
+            RandomSeed = chatThread.Seed,
+            
+            // Right now, we only support streaming completions:
+            Stream = true,
+            SafePrompt = false,
+        }, JSON_SERIALIZER_OPTIONS);
+
+        // Build the HTTP post request:
+        var request = new HttpRequestMessage(HttpMethod.Post, "chat/completions");
+        
+        // Set the authorization header:
+        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", requestedSecret.Secret);
+        
+        // Set the content:
+        request.Content = new StringContent(mistralChatRequest, Encoding.UTF8, "application/json");
+        
+        // Send the request with the ResponseHeadersRead option.
+        // This allows us to read the stream as soon as the headers are received.
+        // This is important because we want to stream the responses.
+        var response = await this.httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, token);
+        
+        // Open the response stream:
+        var mistralStream = await response.Content.ReadAsStreamAsync(token);
+        
+        // Add a stream reader to read the stream, line by line:
+        var streamReader = new StreamReader(mistralStream);
+        
+        // Read the stream, line by line:
+        while(!streamReader.EndOfStream)
+        {
+            // Check if the token is canceled:
+            if(token.IsCancellationRequested)
+                yield break;
+            
+            // Read the next line:
+            var line = await streamReader.ReadLineAsync(token);
+            
+            // Skip empty lines:
+            if(string.IsNullOrWhiteSpace(line))
+                continue;
+            
+            // Skip lines that do not start with "data: ". Regard
+            // to the specification, we only want to read the data lines:
+            if(!line.StartsWith("data: ", StringComparison.InvariantCulture))
+                continue;
+
+            // Check if the line is the end of the stream:
+            if (line.StartsWith("data: [DONE]", StringComparison.InvariantCulture))
+                yield break;
+
+            ResponseStreamLine mistralResponse;
+            try
+            {
+                // We know that the line starts with "data: ". Hence, we can
+                // skip the first 6 characters to get the JSON data after that.
+                var jsonData = line[6..];
+                
+                // Deserialize the JSON data:
+                mistralResponse = JsonSerializer.Deserialize<ResponseStreamLine>(jsonData, JSON_SERIALIZER_OPTIONS);
+            }
+            catch
+            {
+                // Skip invalid JSON data:
+                continue;
+            }    
+            
+            // Skip empty responses:
+            if(mistralResponse == default || mistralResponse.Choices.Count == 0)
+                continue;
+            
+            // Yield the response:
+            yield return mistralResponse.Choices[0].Delta.Content;
+        }
+    }
+
+    #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+    /// <inheritdoc />
+    public async IAsyncEnumerable<ImageURL> StreamImageCompletion(IJSRuntime jsRuntime, SettingsManager settings, Provider.Model imageModel, string promptPositive, string promptNegative = FilterOperator.String.Empty, ImageURL referenceImageURL = default, [EnumeratorCancellation] CancellationToken token = default)
+    {
+        yield break;
+    }
+    #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
+
+    /// <inheritdoc />
+    public async Task<IEnumerable<Provider.Model>> GetTextModels(IJSRuntime jsRuntime, SettingsManager settings, string? apiKeyProvisional = null, CancellationToken token = default)
+    {
+        var secretKey = apiKeyProvisional switch
+        {
+            not null => apiKeyProvisional,
+            _ => await settings.GetAPIKey(jsRuntime, this) switch
+            {
+                { Success: true } result => result.Secret,
+                _ => null,
+            }
+        };
+
+        if (secretKey is null)
+            return [];
+        
+        var request = new HttpRequestMessage(HttpMethod.Get, "models");
+        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", secretKey);
+
+        var response = await this.httpClient.SendAsync(request, token);
+        if(!response.IsSuccessStatusCode)
+            return [];
+
+        var modelResponse = await response.Content.ReadFromJsonAsync<ModelsResponse>(token);
+        return modelResponse.Data.Where(n => 
+            !n.Id.StartsWith("code", StringComparison.InvariantCulture) &&
+            !n.Id.Contains("embed", StringComparison.InvariantCulture))
+            .Select(n => new Provider.Model(n.Id));
+    }
+
+    #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+    /// <inheritdoc />
+    public Task<IEnumerable<Provider.Model>> GetImageModels(IJSRuntime jsRuntime, SettingsManager settings, string? apiKeyProvisional = null, CancellationToken token = default)
+    {
+        return Task.FromResult(Enumerable.Empty<Provider.Model>());
+    }
+    #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
+
+    #endregion
+}

app/MindWork AI Studio/Provider/Mistral/RegularMessage.cs

@@ -0,0 +1,8 @@
+namespace AIStudio.Provider.Mistral;
+
+/// <summary>
+/// Regulat chat message model.
+/// </summary>
+/// <param name="Content">The text content of the message.</param>
+/// <param name="Role">The role of the message.</param>
+public readonly record struct RegularMessage(string Content, string Role);

app/MindWork AI Studio/Provider/OpenAI/ProviderOpenAI.cs

@@ -97,7 +97,7 @@ public sealed class ProviderOpenAI() : BaseProvider("https://api.openai.com/v1/"
         // Read the stream, line by line:
         while(!streamReader.EndOfStream)
         {
-            // Check if the token is cancelled:
+            // Check if the token is canceled:
             if(token.IsCancellationRequested)
                 yield break;
             

app/MindWork AI Studio/Provider/Providers.cs

@@ -1,4 +1,8 @@
+using AIStudio.Provider.Anthropic;
+using AIStudio.Provider.Fireworks;
+using AIStudio.Provider.Mistral;
 using AIStudio.Provider.OpenAI;
+using AIStudio.Provider.SelfHosted;
 
 namespace AIStudio.Provider;
 
@@ -7,8 +11,15 @@ namespace AIStudio.Provider;
 /// </summary>
 public enum Providers
 {
-    NONE,
-    OPEN_AI,
+    NONE = 0,
+    
+    OPEN_AI = 1,
+    ANTHROPIC = 2,
+    MISTRAL = 3,
+    
+    FIREWORKS = 5,
+    
+    SELF_HOSTED = 4,
 }
 
 /// <summary>
@@ -23,22 +34,45 @@ public static class ExtensionsProvider
     /// <returns>The human-readable name of the provider.</returns>
     public static string ToName(this Providers provider) => provider switch
     {
-        Providers.OPEN_AI => "OpenAI",
-        
         Providers.NONE => "No provider selected",
+        
+        Providers.OPEN_AI => "OpenAI",
+        Providers.ANTHROPIC => "Anthropic",
+        Providers.MISTRAL => "Mistral",
+        
+        Providers.FIREWORKS => "Fireworks.ai",
+        
+        Providers.SELF_HOSTED => "Self-hosted",
+        
         _ => "Unknown",
     };
 
     /// <summary>
     /// Creates a new provider instance based on the provider value.
     /// </summary>
-    /// <param name="provider">The provider value.</param>
-    /// <param name="instanceName">The used instance name.</param>
+    /// <param name="providerSettings">The provider settings.</param>
     /// <returns>The provider instance.</returns>
-    public static IProvider CreateProvider(this Providers provider, string instanceName) => provider switch
+    public static IProvider CreateProvider(this Settings.Provider providerSettings)
     {
-        Providers.OPEN_AI => new ProviderOpenAI { InstanceName = instanceName },
-        
-        _ => new NoProvider(),
-    };
+        try
+        {
+            return providerSettings.UsedProvider switch
+            {
+                Providers.OPEN_AI => new ProviderOpenAI { InstanceName = providerSettings.InstanceName },
+                Providers.ANTHROPIC => new ProviderAnthropic { InstanceName = providerSettings.InstanceName },
+                Providers.MISTRAL => new ProviderMistral { InstanceName = providerSettings.InstanceName },
+                
+                Providers.FIREWORKS => new ProviderFireworks { InstanceName = providerSettings.InstanceName },
+                
+                Providers.SELF_HOSTED => new ProviderSelfHosted(providerSettings) { InstanceName = providerSettings.InstanceName },
+                
+                _ => new NoProvider(),
+            };
+        }
+        catch (Exception e)
+        {
+            Console.WriteLine($"Failed to create provider: {e.Message}");
+            return new NoProvider();
+        }
+    }
 }

app/MindWork AI Studio/Provider/SelfHosted/ChatRequest.cs

@@ -0,0 +1,16 @@
+namespace AIStudio.Provider.SelfHosted;
+
+/// <summary>
+/// The chat request model.
+/// </summary>
+/// <param name="Model">Which model to use for chat completion.</param>
+/// <param name="Messages">The chat messages.</param>
+/// <param name="Stream">Whether to stream the chat completion.</param>
+/// <param name="MaxTokens">The maximum number of tokens to generate.</param>
+public readonly record struct ChatRequest(
+    string Model,
+    IList<Message> Messages,
+    bool Stream,
+    
+    int MaxTokens
+);

app/MindWork AI Studio/Provider/SelfHosted/Host.cs

@@ -0,0 +1,42 @@
+namespace AIStudio.Provider.SelfHosted;
+
+public enum Host
+{
+    NONE,
+
+    LM_STUDIO,
+    LLAMACPP,
+    OLLAMA,
+}
+
+public static class HostExtensions
+{
+    public static string Name(this Host host) => host switch
+    {
+        Host.NONE => "None",
+
+        Host.LM_STUDIO => "LM Studio",
+        Host.LLAMACPP => "llama.cpp",
+        Host.OLLAMA => "ollama",
+
+        _ => "Unknown",
+    };
+
+    public static string BaseURL(this Host host) => host switch
+    {
+        Host.LM_STUDIO => "/v1/",
+        Host.LLAMACPP => "/v1/",
+        Host.OLLAMA => "/v1/",
+
+        _ => "/v1/",
+    };
+
+    public static string ChatURL(this Host host) => host switch
+    {
+        Host.LM_STUDIO => "chat/completions",
+        Host.LLAMACPP => "chat/completions",
+        Host.OLLAMA => "chat/completions",
+
+        _ => "chat/completions",
+    };
+}

app/MindWork AI Studio/Provider/SelfHosted/Message.cs

@@ -0,0 +1,8 @@
+namespace AIStudio.Provider.SelfHosted;
+
+/// <summary>
+/// Chat message model.
+/// </summary>
+/// <param name="Content">The text content of the message.</param>
+/// <param name="Role">The role of the message.</param>
+public readonly record struct Message(string Content, string Role);

app/MindWork AI Studio/Provider/SelfHosted/ModelsResponse.cs

@@ -0,0 +1,5 @@
+namespace AIStudio.Provider.SelfHosted;
+
+public readonly record struct ModelsResponse(string Object, Model[] Data);
+
+public readonly record struct Model(string Id, string Object, string OwnedBy);

app/MindWork AI Studio/Provider/SelfHosted/ProviderSelfHosted.cs

@@ -0,0 +1,178 @@
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Text.Json;
+
+using AIStudio.Chat;
+using AIStudio.Provider.OpenAI;
+using AIStudio.Settings;
+
+namespace AIStudio.Provider.SelfHosted;
+
+public sealed class ProviderSelfHosted(Settings.Provider provider) : BaseProvider($"{provider.Hostname}{provider.Host.BaseURL()}"), IProvider
+{
+    private static readonly JsonSerializerOptions JSON_SERIALIZER_OPTIONS = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
+    };
+
+    #region Implementation of IProvider
+
+    public string Id => "Self-hosted";
+    
+    public string InstanceName { get; set; } = "Self-hosted";
+    
+    public async IAsyncEnumerable<string> StreamChatCompletion(IJSRuntime jsRuntime, SettingsManager settings, Provider.Model chatModel, ChatThread chatThread, [EnumeratorCancellation] CancellationToken token = default)
+    {
+        // Prepare the system prompt:
+        var systemPrompt = new Message
+        {
+            Role = "system",
+            Content = chatThread.SystemPrompt,
+        };
+        
+        // Prepare the OpenAI HTTP chat request:
+        var providerChatRequest = JsonSerializer.Serialize(new ChatRequest
+        {
+            Model = chatModel.Id,
+            
+            // Build the messages:
+            // - First of all the system prompt
+            // - Then none-empty user and AI messages
+            Messages = [systemPrompt, ..chatThread.Blocks.Where(n => n.ContentType is ContentType.TEXT && !string.IsNullOrWhiteSpace((n.Content as ContentText)?.Text)).Select(n => new Message
+            {
+                Role = n.Role switch
+                {
+                    ChatRole.USER => "user",
+                    ChatRole.AI => "assistant",
+                    ChatRole.SYSTEM => "system",
+
+                    _ => "user",
+                },
+
+                Content = n.Content switch
+                {
+                    ContentText text => text.Text,
+                    _ => string.Empty,
+                }
+            }).ToList()],
+            
+            // Right now, we only support streaming completions:
+            Stream = true,
+            MaxTokens = -1,
+        }, JSON_SERIALIZER_OPTIONS);
+
+        // Build the HTTP post request:
+        var request = new HttpRequestMessage(HttpMethod.Post, provider.Host.ChatURL());
+        
+        // Set the content:
+        request.Content = new StringContent(providerChatRequest, Encoding.UTF8, "application/json");
+        
+        // Send the request with the ResponseHeadersRead option.
+        // This allows us to read the stream as soon as the headers are received.
+        // This is important because we want to stream the responses.
+        var response = await this.httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, token);
+        
+        // Open the response stream:
+        var providerStream = await response.Content.ReadAsStreamAsync(token);
+        
+        // Add a stream reader to read the stream, line by line:
+        var streamReader = new StreamReader(providerStream);
+        
+        // Read the stream, line by line:
+        while(!streamReader.EndOfStream)
+        {
+            // Check if the token is canceled:
+            if(token.IsCancellationRequested)
+                yield break;
+            
+            // Read the next line:
+            var line = await streamReader.ReadLineAsync(token);
+            
+            // Skip empty lines:
+            if(string.IsNullOrWhiteSpace(line))
+                continue;
+            
+            // Skip lines that do not start with "data: ". Regard
+            // to the specification, we only want to read the data lines:
+            if(!line.StartsWith("data: ", StringComparison.InvariantCulture))
+                continue;
+
+            // Check if the line is the end of the stream:
+            if (line.StartsWith("data: [DONE]", StringComparison.InvariantCulture))
+                yield break;
+
+            ResponseStreamLine providerResponse;
+            try
+            {
+                // We know that the line starts with "data: ". Hence, we can
+                // skip the first 6 characters to get the JSON data after that.
+                var jsonData = line[6..];
+                
+                // Deserialize the JSON data:
+                providerResponse = JsonSerializer.Deserialize<ResponseStreamLine>(jsonData, JSON_SERIALIZER_OPTIONS);
+            }
+            catch
+            {
+                // Skip invalid JSON data:
+                continue;
+            }    
+            
+            // Skip empty responses:
+            if(providerResponse == default || providerResponse.Choices.Count == 0)
+                continue;
+            
+            // Yield the response:
+            yield return providerResponse.Choices[0].Delta.Content;
+        }
+    }
+
+    #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+    /// <inheritdoc />
+    public async IAsyncEnumerable<ImageURL> StreamImageCompletion(IJSRuntime jsRuntime, SettingsManager settings, Provider.Model imageModel, string promptPositive, string promptNegative = FilterOperator.String.Empty, ImageURL referenceImageURL = default, [EnumeratorCancellation] CancellationToken token = default)
+    {
+        yield break;
+    }
+    #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
+
+
+    public async Task<IEnumerable<Provider.Model>> GetTextModels(IJSRuntime jsRuntime, SettingsManager settings, string? apiKeyProvisional = null, CancellationToken token = default)
+    {
+        try
+        {
+            switch (provider.Host)
+            {
+                case Host.LLAMACPP:
+                    // Right now, llama.cpp only supports one model.
+                    // There is no API to list the model(s).
+                    return [ new Provider.Model("as configured by llama.cpp") ];
+            
+                case Host.LM_STUDIO:
+                case Host.OLLAMA:
+                    var lmStudioRequest = new HttpRequestMessage(HttpMethod.Get, "models");
+                    var lmStudioResponse = await this.httpClient.SendAsync(lmStudioRequest, token);
+                    if(!lmStudioResponse.IsSuccessStatusCode)
+                        return [];
+
+                    var lmStudioModelResponse = await lmStudioResponse.Content.ReadFromJsonAsync<ModelsResponse>(token);
+                    return lmStudioModelResponse.Data.Select(n => new Provider.Model(n.Id));
+            }
+
+            return [];
+        }
+        catch(Exception e)
+        {
+            Console.WriteLine($"Failed to load text models from self-hosted provider: {e.Message}");
+            return [];
+        }
+    }
+
+    #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+    /// <inheritdoc />
+    public Task<IEnumerable<Provider.Model>> GetImageModels(IJSRuntime jsRuntime, SettingsManager settings, string? apiKeyProvisional = null, CancellationToken token = default)
+    {
+        return Task.FromResult(Enumerable.Empty<Provider.Model>());
+    }
+    #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
+
+    #endregion
+}

app/MindWork AI Studio/Settings/Data.cs

@@ -9,7 +9,7 @@ public sealed class Data
     /// The version of the settings file. Allows us to upgrade the settings
     /// when a new version is available.
     /// </summary>
-    public Version Version { get; init; } = Version.V1;
+    public Version Version { get; init; } = Version.V3;
 
     /// <summary>
     /// List of configured providers.
@@ -41,4 +41,19 @@ public sealed class Data
     /// If and when we should look for updates.
     /// </summary>
     public UpdateBehavior UpdateBehavior { get; set; } = UpdateBehavior.ONCE_STARTUP;
+    
+    /// <summary>
+    /// The chat storage behavior.
+    /// </summary>
+    public WorkspaceStorageBehavior WorkspaceStorageBehavior { get; set; } = WorkspaceStorageBehavior.STORE_CHATS_AUTOMATICALLY;
+    
+    /// <summary>
+    /// The chat storage maintenance behavior.
+    /// </summary>
+    public WorkspaceStorageTemporaryMaintenancePolicy WorkspaceStorageTemporaryMaintenancePolicy { get; set; } = WorkspaceStorageTemporaryMaintenancePolicy.DELETE_OLDER_THAN_90_DAYS;
+    
+    /// <summary>
+    /// The navigation behavior.
+    /// </summary>
+    public NavBehavior NavigationBehavior { get; set; } = NavBehavior.EXPAND_ON_HOVER;
 }

app/MindWork AI Studio/Settings/NavBehavior.cs

@@ -0,0 +1,9 @@
+namespace AIStudio.Settings;
+
+public enum NavBehavior
+{
+    EXPAND_ON_HOVER,
+    NEVER_EXPAND_USE_TOOLTIPS,
+    NEVER_EXPAND_NO_TOOLTIPS,
+    ALWAYS_EXPAND,
+}

app/MindWork AI Studio/Settings/Provider.cs

@@ -1,5 +1,7 @@
 using AIStudio.Provider;
 
+using Host = AIStudio.Provider.SelfHosted.Host;
+
 namespace AIStudio.Settings;
 
 /// <summary>
@@ -9,8 +11,18 @@ namespace AIStudio.Settings;
 /// <param name="Id">The provider's ID.</param>
 /// <param name="InstanceName">The provider's instance name. Useful for multiple instances of the same provider, e.g., to distinguish between different OpenAI API keys.</param>
 /// <param name="UsedProvider">The provider used.</param>
+/// <param name="IsSelfHosted">Whether the provider is self-hosted.</param>
+/// <param name="Hostname">The hostname of the provider. Useful for self-hosted providers.</param>
 /// <param name="Model">The LLM model to use for chat.</param>
-public readonly record struct Provider(uint Num, string Id, string InstanceName, Providers UsedProvider, Model Model)
+public readonly record struct Provider(
+    uint Num,
+    string Id,
+    string InstanceName,
+    Providers UsedProvider,
+    Model Model,
+    bool IsSelfHosted = false,
+    string Hostname = "http://localhost:1234",
+    Host Host = Host.NONE)
 {
     #region Overrides of ValueType
 
@@ -21,6 +33,9 @@ public readonly record struct Provider(uint Num, string Id, string InstanceName,
     /// <returns>A string that represents the current provider in a human-readable format.</returns>
     public override string ToString()
     {
+        if(this.IsSelfHosted)
+            return $"{this.InstanceName} ({this.UsedProvider.ToName()}, {this.Host}, {this.Hostname}, {this.Model})";
+
         return $"{this.InstanceName} ({this.UsedProvider.ToName()}, {this.Model})";
     }
 

app/MindWork AI Studio/Settings/ProviderDialog.razor

@@ -1,9 +1,83 @@
 @using AIStudio.Provider
+@using AIStudio.Provider.SelfHosted
 @using MudBlazor
 
 <MudDialog>
     <DialogContent>
         <MudForm @ref="@this.form" @bind-IsValid="@this.dataIsValid" @bind-Errors="@this.dataIssues">
+            <MudStack Row="@true" AlignItems="AlignItems.Center">
+                @* ReSharper disable once CSharpWarnings::CS8974 *@
+                <MudSelect @bind-Value="@this.DataProvider" Label="Provider" Class="mb-3" OpenIcon="@Icons.Material.Filled.AccountBalance" AdornmentColor="Color.Info" Adornment="Adornment.Start" Validation="@this.ValidatingProvider">
+                    @foreach (Providers provider in Enum.GetValues(typeof(Providers)))
+                    {
+                        <MudSelectItem Value="@provider">@provider</MudSelectItem>
+                    }
+                </MudSelect>
+                <MudButton Disabled="@(!this.ShowRegisterButton)" Variant="Variant.Filled" Size="Size.Small" StartIcon="@Icons.Material.Filled.OpenInBrowser" Href="@this.GetProviderCreationURL()" Target="_blank">Create account</MudButton>
+            </MudStack>
+            
+            @* ReSharper disable once CSharpWarnings::CS8974 *@
+            <MudTextField
+                T="string"
+                @bind-Text="@this.dataAPIKey"
+                Label="API Key"
+                Disabled="@(!this.NeedAPIKey)"
+                Class="mb-3"
+                Adornment="Adornment.Start"
+                AdornmentIcon="@Icons.Material.Filled.VpnKey"
+                AdornmentColor="Color.Info"
+                InputType="InputType.Password"
+                Validation="@this.ValidatingAPIKey"
+            />
+            
+            <MudTextField
+                T="string"
+                @bind-Text="@this.DataHostname"
+                Label="Hostname"
+                Disabled="@(!this.NeedHostname)"
+                Class="mb-3"
+                Adornment="Adornment.Start"
+                AdornmentIcon="@Icons.Material.Filled.Dns"
+                AdornmentColor="Color.Info"
+                Validation="@this.ValidatingHostname"
+                UserAttributes="@SPELLCHECK_ATTRIBUTES"
+            />
+
+            <MudSelect Disabled="@(!this.NeedHost)" @bind-Value="@this.DataHost" Label="Host" Class="mb-3" OpenIcon="@Icons.Material.Filled.ExpandMore" AdornmentColor="Color.Info" Adornment="Adornment.Start" Validation="@this.ValidatingHost">
+                @foreach (Host host in Enum.GetValues(typeof(Host)))
+                {
+                    <MudSelectItem Value="@host">@host.Name()</MudSelectItem>
+                }
+            </MudSelect>
+
+            <MudStack Row="@true" AlignItems="AlignItems.Center">
+                @if (this.ProvideModelManually)
+                {
+                    <MudButton Variant="Variant.Filled" Size="Size.Small" StartIcon="@Icons.Material.Filled.OpenInBrowser" Href="@this.GetModelOverviewURL()" Target="_blank">Show available models</MudButton>
+                    <MudTextField
+                        T="string"
+                        @bind-Text="@this.dataManuallyModel"
+                        Label="Model"
+                        Class="mb-3"
+                        Adornment="Adornment.Start"
+                        AdornmentIcon="@Icons.Material.Filled.Dns"
+                        AdornmentColor="Color.Info"
+                        Validation="@this.ValidateManuallyModel"
+                        UserAttributes="@SPELLCHECK_ATTRIBUTES"
+                    />
+                }
+                else
+                {
+                    <MudButton Disabled="@(!this.CanLoadModels())" Variant="Variant.Filled" Size="Size.Small" StartIcon="@Icons.Material.Filled.Refresh" OnClick="this.ReloadModels">Load</MudButton>
+                    <MudSelect Disabled="@this.IsNoneProvider" @bind-Value="@this.DataModel" Label="Model" Class="mb-3" OpenIcon="@Icons.Material.Filled.FaceRetouchingNatural" AdornmentColor="Color.Info" Adornment="Adornment.Start" Validation="@this.ValidatingModel">
+                        @foreach (var model in this.availableModels)
+                        {
+                            <MudSelectItem Value="@model">@model</MudSelectItem>
+                        }
+                    </MudSelect>
+                }
+            </MudStack>
+
             @* ReSharper disable once CSharpWarnings::CS8974 *@
             <MudTextField
                 T="string"
@@ -14,50 +88,19 @@
                 AdornmentIcon="@Icons.Material.Filled.Lightbulb"
                 AdornmentColor="Color.Info"
                 Validation="@this.ValidatingInstanceName"
-                UserAttributes="@INSTANCE_NAME_ATTRIBUTES"
+                UserAttributes="@SPELLCHECK_ATTRIBUTES"
             />
             
-            @* ReSharper disable once CSharpWarnings::CS8974 *@
-            <MudSelect @bind-Value="@this.DataProvider" Label="Provider" Class="mb-3" OpenIcon="@Icons.Material.Filled.AccountBalance" AdornmentColor="Color.Info" Adornment="Adornment.Start" Validation="@this.ValidatingProvider">
-                @foreach (Providers provider in Enum.GetValues(typeof(Providers)))
-                {
-                    <MudSelectItem Value="@provider">@provider</MudSelectItem>
-                }
-            </MudSelect>
-            
-            @* ReSharper disable once CSharpWarnings::CS8974 *@
-            <MudTextField
-                T="string"
-                @bind-Text="@this.dataAPIKey"
-                Label="API Key"
-                Class="mb-3"
-                Adornment="Adornment.Start"
-                AdornmentIcon="@Icons.Material.Filled.VpnKey"
-                AdornmentColor="Color.Info"
-                InputType="InputType.Password"
-                Validation="@this.ValidatingAPIKey"
-            />
-
-            <MudStack Row="@true" AlignItems="AlignItems.Center">
-                <MudButton Disabled="@(!this.CanLoadModels)" Variant="Variant.Filled" Size="Size.Small" StartIcon="@Icons.Material.Filled.Refresh" OnClick="this.ReloadModels">Reload</MudButton>
-                <MudSelect @bind-Value="@this.DataModel" Label="Model" Class="mb-3" OpenIcon="@Icons.Material.Filled.FaceRetouchingNatural" AdornmentColor="Color.Info" Adornment="Adornment.Start" Validation="@this.ValidatingModel">
-                    @foreach (var model in this.availableModels)
-                    {
-                        <MudSelectItem Value="@model">@model</MudSelectItem>
-                    }
-                </MudSelect>
-            </MudStack>
-            
         </MudForm>
 
         @if (this.dataIssues.Any())
         {
             <MudPaper Class="pa-2 mt-3">
                 <MudText Typo="Typo.h6">Issues</MudText>
-                <MudList Clickable="@true">
+                <MudList T="string">
                     @foreach (var issue in this.dataIssues)
                     {
-                        <MudListItem Icon="@Icons.Material.Filled.Error" IconColor="Color.Error">
+                        <MudListItem T="string" Icon="@Icons.Material.Filled.Error" IconColor="Color.Error">
                             @issue
                         </MudListItem> 
                     }

app/MindWork AI Studio/Settings/ProviderDialog.razor.cs

@@ -4,6 +4,8 @@ using AIStudio.Provider;
 
 using Microsoft.AspNetCore.Components;
 
+using Host = AIStudio.Provider.SelfHosted.Host;
+
 namespace AIStudio.Settings;
 
 /// <summary>
@@ -32,6 +34,24 @@ public partial class ProviderDialog : ComponentBase
     [Parameter]
     public string DataInstanceName { get; set; } = string.Empty;
     
+    /// <summary>
+    /// The chosen hostname for self-hosted providers.
+    /// </summary>
+    [Parameter]
+    public string DataHostname { get; set; } = string.Empty;
+    
+    /// <summary>
+    /// The local host to use, e.g., llama.cpp.
+    /// </summary>
+    [Parameter]
+    public Host DataHost { get; set; } = Host.NONE;
+    
+    /// <summary>
+    /// Is this provider self-hosted?
+    /// </summary>
+    [Parameter]
+    public bool IsSelfHosted { get; set; }
+    
     /// <summary>
     /// The provider to use.
     /// </summary>
@@ -56,7 +76,7 @@ public partial class ProviderDialog : ComponentBase
     [Inject]
     private IJSRuntime JsRuntime { get; set; } = null!;
 
-    private static readonly Dictionary<string, object?> INSTANCE_NAME_ATTRIBUTES = new();
+    private static readonly Dictionary<string, object?> SPELLCHECK_ATTRIBUTES = new();
     
     /// <summary>
     /// The list of used instance names. We need this to check for uniqueness.
@@ -66,6 +86,7 @@ public partial class ProviderDialog : ComponentBase
     private bool dataIsValid;
     private string[] dataIssues = [];
     private string dataAPIKey = string.Empty;
+    private string dataManuallyModel = string.Empty;
     private string dataAPIKeyStorageIssue = string.Empty;
     private string dataEditingPreviousInstanceName = string.Empty;
     
@@ -73,13 +94,25 @@ public partial class ProviderDialog : ComponentBase
     private MudForm form = null!;
     
     private readonly List<Model> availableModels = new();
+    
+    private Provider CreateProviderSettings() => new()
+    {
+        Num = this.DataNum,
+        Id = this.DataId,
+        InstanceName = this.DataInstanceName,
+        UsedProvider = this.DataProvider,
+        Model = this.DataProvider is Providers.FIREWORKS ? new Model(this.dataManuallyModel) : this.DataModel,
+        IsSelfHosted = this.DataProvider is Providers.SELF_HOSTED,
+        Hostname = this.DataHostname.EndsWith('/') ? this.DataHostname[..^1] : this.DataHostname,
+        Host = this.DataHost,
+    };
 
     #region Overrides of ComponentBase
 
     protected override async Task OnInitializedAsync()
     {
         // Configure the spellchecking for the instance name input:
-        this.SettingsManager.InjectSpellchecking(INSTANCE_NAME_ATTRIBUTES);
+        this.SettingsManager.InjectSpellchecking(SPELLCHECK_ATTRIBUTES);
         
         // Load the used instance names:
         this.UsedInstanceNames = this.SettingsManager.ConfigurationData.Providers.Select(x => x.InstanceName.ToLowerInvariant()).ToList();
@@ -88,9 +121,24 @@ public partial class ProviderDialog : ComponentBase
         if(this.IsEditing)
         {
             this.dataEditingPreviousInstanceName = this.DataInstanceName.ToLowerInvariant();
-            var provider = this.DataProvider.CreateProvider(this.DataInstanceName);
-            if(provider is NoProvider)
+            
+            //
+            // We cannot load the API key for self-hosted providers:
+            //
+            if (this.DataProvider is Providers.SELF_HOSTED)
+            {
+                await this.ReloadModels();
+                await base.OnInitializedAsync();
                 return;
+            }
+            
+            var loadedProviderSettings = this.CreateProviderSettings();
+            var provider = loadedProviderSettings.CreateProvider();
+            if(provider is NoProvider)
+            {
+                await base.OnInitializedAsync();
+                return;
+            }
             
             // Load the API key:
             var requestedSecret = await this.SettingsManager.GetAPIKey(this.JsRuntime, provider);
@@ -135,28 +183,23 @@ public partial class ProviderDialog : ComponentBase
         
         // Use the data model to store the provider.
         // We just return this data to the parent component:
-        var addedProvider = new Provider
+        var addedProviderSettings = this.CreateProviderSettings();
+        if (addedProviderSettings.UsedProvider != Providers.SELF_HOSTED)
         {
-            Num = this.DataNum,
-            Id = this.DataId,
-            InstanceName = this.DataInstanceName,
-            UsedProvider = this.DataProvider,
-            Model = this.DataModel,
-        };
-        
-        // We need to instantiate the provider to store the API key:
-        var provider = this.DataProvider.CreateProvider(this.DataInstanceName);
+            // We need to instantiate the provider to store the API key:
+            var provider = addedProviderSettings.CreateProvider();
             
-        // Store the API key in the OS secure storage:
-        var storeResponse = await this.SettingsManager.SetAPIKey(this.JsRuntime, provider, this.dataAPIKey);
-        if (!storeResponse.Success)
-        {
-            this.dataAPIKeyStorageIssue = $"Failed to store the API key in the operating system. The message was: {storeResponse.Issue}. Please try again.";
-            await this.form.Validate();
-            return;
+            // Store the API key in the OS secure storage:
+            var storeResponse = await this.SettingsManager.SetAPIKey(this.JsRuntime, provider, this.dataAPIKey);
+            if (!storeResponse.Success)
+            {
+                this.dataAPIKeyStorageIssue = $"Failed to store the API key in the operating system. The message was: {storeResponse.Issue}. Please try again.";
+                await this.form.Validate();
+                return;
+            }
         }
-        
-        this.MudDialog.Close(DialogResult.Ok(addedProvider));
+
+        this.MudDialog.Close(DialogResult.Ok(addedProviderSettings));
     }
     
     private string? ValidatingProvider(Providers provider)
@@ -167,35 +210,70 @@ public partial class ProviderDialog : ComponentBase
         return null;
     }
     
+    private string? ValidatingHost(Host host)
+    {
+        if(this.DataProvider is not Providers.SELF_HOSTED)
+            return null;
+
+        if (host == Host.NONE)
+            return "Please select a host.";
+
+        return null;
+    }
+    
+    private string? ValidateManuallyModel(string manuallyModel)
+    {
+        if (this.DataProvider is Providers.FIREWORKS && string.IsNullOrWhiteSpace(manuallyModel))
+            return "Please enter a model name.";
+        
+        return null;
+    }
+    
     private string? ValidatingModel(Model model)
     {
+        if(this.DataProvider is Providers.SELF_HOSTED && this.DataHost == Host.LLAMACPP)
+            return null;
+        
         if (model == default)
             return "Please select a model.";
         
         return null;
     }
     
-    [GeneratedRegex("^[a-zA-Z0-9 ]+$")]
+    [GeneratedRegex(@"^[a-zA-Z0-9\-_. ]+$")]
     private static partial Regex InstanceNameRegex();
     
+    private static readonly string[] RESERVED_NAMES = ["CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9"];
+    
     private string? ValidatingInstanceName(string instanceName)
     {
-        if(string.IsNullOrWhiteSpace(instanceName))
+        if (string.IsNullOrWhiteSpace(instanceName))
             return "Please enter an instance name.";
         
-        if(instanceName.StartsWith(' '))
-            return "The instance name must not start with a space.";
+        if (instanceName.StartsWith(' ') || instanceName.StartsWith('.'))
+            return "The instance name must not start with a space or a dot.";
         
-        if(instanceName.EndsWith(' '))
-            return "The instance name must not end with a space.";
+        if (instanceName.EndsWith(' ') || instanceName.EndsWith('.'))
+            return "The instance name must not end with a space or a dot.";
+        
+        if (instanceName.StartsWith('-') || instanceName.StartsWith('_'))
+            return "The instance name must not start with a hyphen or an underscore.";
+        
+        if (instanceName.Length > 255)
+            return "The instance name must not exceed 255 characters.";
         
-        // The instance name must only contain letters, numbers, and spaces:
         if (!InstanceNameRegex().IsMatch(instanceName))
-            return "The instance name must only contain letters, numbers, and spaces.";
+            return "The instance name must only contain letters, numbers, spaces, hyphens, underscores, and dots.";
         
-        if(instanceName.Contains("  "))
+        if (instanceName.Contains("  "))
             return "The instance name must not contain consecutive spaces.";
         
+        if (RESERVED_NAMES.Contains(instanceName.ToUpperInvariant()))
+            return "This name is reserved and cannot be used.";
+        
+        if (instanceName.Any(c => Path.GetInvalidFileNameChars().Contains(c)))
+            return "The instance name contains invalid characters.";
+        
         // The instance name must be unique:
         var lowerInstanceName = instanceName.ToLowerInvariant();
         if (lowerInstanceName != this.dataEditingPreviousInstanceName && this.UsedInstanceNames.Contains(lowerInstanceName))
@@ -206,6 +284,9 @@ public partial class ProviderDialog : ComponentBase
     
     private string? ValidatingAPIKey(string apiKey)
     {
+        if(this.DataProvider is Providers.SELF_HOSTED)
+            return null;
+        
         if(!string.IsNullOrWhiteSpace(this.dataAPIKeyStorageIssue))
             return this.dataAPIKeyStorageIssue;
 
@@ -215,16 +296,32 @@ public partial class ProviderDialog : ComponentBase
         return null;
     }
 
-    private void Cancel() => this.MudDialog.Cancel();
+    private string? ValidatingHostname(string hostname)
+    {
+        if(this.DataProvider != Providers.SELF_HOSTED)
+            return null;
+        
+        if(string.IsNullOrWhiteSpace(hostname))
+            return "Please enter a hostname, e.g., http://localhost:1234";
+        
+        if(!hostname.StartsWith("http://", StringComparison.InvariantCultureIgnoreCase) && !hostname.StartsWith("https://", StringComparison.InvariantCultureIgnoreCase))
+            return "The hostname must start with either http:// or https://";
 
-    private bool CanLoadModels => !string.IsNullOrWhiteSpace(this.dataAPIKey) && this.DataProvider != Providers.NONE && !string.IsNullOrWhiteSpace(this.DataInstanceName);
+        if(!Uri.TryCreate(hostname, UriKind.Absolute, out _))
+            return "The hostname is not a valid HTTP(S) URL.";
+        
+        return null;
+    }
+
+    private void Cancel() => this.MudDialog.Cancel();
     
     private async Task ReloadModels()
     {
-        var provider = this.DataProvider.CreateProvider(this.DataInstanceName);
+        var currentProviderSettings = this.CreateProviderSettings();
+        var provider = currentProviderSettings.CreateProvider();
         if(provider is NoProvider)
             return;
-
+        
         var models = await provider.GetTextModels(this.JsRuntime, this.SettingsManager, this.dataAPIKey);
         
         // Order descending by ID means that the newest models probably come first:
@@ -233,4 +330,96 @@ public partial class ProviderDialog : ComponentBase
         this.availableModels.Clear();
         this.availableModels.AddRange(orderedModels);
     }
+    
+    private bool CanLoadModels()
+    {
+        if (this.DataProvider is Providers.SELF_HOSTED)
+        {
+            switch (this.DataHost)
+            {
+                case Host.NONE:
+                    return false;
+
+                case Host.LLAMACPP:
+                    return false;
+
+                case Host.LM_STUDIO:
+                    return true;
+
+                case Host.OLLAMA:
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        if(this.DataProvider is Providers.NONE)
+            return false;
+        
+        if(string.IsNullOrWhiteSpace(this.dataAPIKey))
+            return false;
+        
+        return true;
+    }
+
+    private bool ShowRegisterButton => this.DataProvider switch
+    {
+        Providers.OPEN_AI => true,
+        Providers.MISTRAL => true,
+        Providers.ANTHROPIC => true,
+        
+        Providers.FIREWORKS => true,
+        
+        _ => false,
+    };
+
+    private bool NeedAPIKey => this.DataProvider switch
+    {
+        Providers.OPEN_AI => true,
+        Providers.MISTRAL => true,
+        Providers.ANTHROPIC => true,
+        
+        Providers.FIREWORKS => true,
+        
+        _ => false,
+    };
+
+    private bool NeedHostname => this.DataProvider switch
+    {
+        Providers.SELF_HOSTED => true,
+        _ => false,
+    };
+    
+    private bool NeedHost => this.DataProvider switch
+    {
+        Providers.SELF_HOSTED => true,
+        _ => false,
+    };
+    
+    private bool ProvideModelManually => this.DataProvider switch
+    {
+        Providers.FIREWORKS => true,
+        _ => false,
+    };
+    
+    private string GetModelOverviewURL() => this.DataProvider switch
+    {
+        Providers.FIREWORKS => "https://fireworks.ai/models?show=Serverless",
+        
+        _ => string.Empty,
+    };
+
+    private string GetProviderCreationURL() => this.DataProvider switch
+    {
+        Providers.OPEN_AI => "https://platform.openai.com/signup",
+        Providers.MISTRAL => "https://console.mistral.ai/",
+        Providers.ANTHROPIC => "https://console.anthropic.com/dashboard",
+        
+        Providers.FIREWORKS => "https://fireworks.ai/login",
+        
+        _ => string.Empty,
+    };
+    
+    private bool IsNoneProvider => this.DataProvider is Providers.NONE;
 }

app/MindWork AI Studio/Settings/SendBehavior.cs

@@ -13,7 +13,7 @@ public enum SendBehavior
     
     /// <summary>
     /// The user can send the input to the AI by pressing any modifier key
-    /// together with the enter key. Alternatively, the user can click the send
+    /// together with the enter key. Alternatively, the user can click the sent
     /// button. The enter key alone adds a new line.
     /// </summary>
     MODIFER_ENTER_IS_SENDING,

app/MindWork AI Studio/Settings/SettingsManager.cs

@@ -103,7 +103,7 @@ public sealed class SettingsManager
         if(loadedConfiguration is null)
             return;
         
-        this.ConfigurationData = loadedConfiguration;
+        this.ConfigurationData = SettingsMigrations.Migrate(loadedConfiguration);
     }
 
     /// <summary>

app/MindWork AI Studio/Settings/SettingsMigrations.cs

@@ -0,0 +1,74 @@
+using Host = AIStudio.Provider.SelfHosted.Host;
+
+namespace AIStudio.Settings;
+
+public static class SettingsMigrations
+{
+    public static Data Migrate(Data previousData)
+    {
+        switch (previousData.Version)
+        {
+            case Version.V1:
+                previousData = MigrateV1ToV2(previousData);
+                return MigrateV2ToV3(previousData);
+
+            case Version.V2:
+                return MigrateV2ToV3(previousData);
+            
+            default:
+                Console.WriteLine("No migration needed.");
+                return previousData;
+        }
+    }
+
+    private static Data MigrateV1ToV2(Data previousData)
+    {
+        //
+        // Summary:
+        // In v1 we had no self-hosted providers. Thus, we had no hostnames.
+        //
+
+        Console.WriteLine("Migrating from v1 to v2...");
+        return new()
+        {
+            Version = Version.V2,
+            
+            Providers = previousData.Providers.Select(provider => provider with { IsSelfHosted = false, Hostname = "" }).ToList(),
+            
+            EnableSpellchecking = previousData.EnableSpellchecking,
+            IsSavingEnergy = previousData.IsSavingEnergy,
+            NextProviderNum = previousData.NextProviderNum,
+            ShortcutSendBehavior = previousData.ShortcutSendBehavior,
+            UpdateBehavior = previousData.UpdateBehavior,
+        };
+    }
+    
+    private static Data MigrateV2ToV3(Data previousData)
+    {
+        //
+        // Summary:
+        // In v2, self-hosted providers had no host (LM Studio, llama.cpp, ollama, etc.)
+        //
+
+        Console.WriteLine("Migrating from v2 to v3...");
+        return new()
+        {
+            Version = Version.V3,
+            Providers = previousData.Providers.Select(provider =>
+            {
+                if(provider.IsSelfHosted)
+                    return provider with { Host = Host.LM_STUDIO };
+                
+                return provider with { Host = Host.NONE };
+            }).ToList(),
+
+            EnableSpellchecking = previousData.EnableSpellchecking,
+            IsSavingEnergy = previousData.IsSavingEnergy,
+            NextProviderNum = previousData.NextProviderNum,
+            ShortcutSendBehavior = previousData.ShortcutSendBehavior,
+            UpdateBehavior = previousData.UpdateBehavior,
+            WorkspaceStorageBehavior = previousData.WorkspaceStorageBehavior,
+            WorkspaceStorageTemporaryMaintenancePolicy = previousData.WorkspaceStorageTemporaryMaintenancePolicy,
+        };
+    }
+}

app/MindWork AI Studio/Settings/Version.cs

@@ -7,5 +7,8 @@ namespace AIStudio.Settings;
 public enum Version
 {
     UNKNOWN,
+    
     V1,
+    V2,
+    V3,
 }

app/MindWork AI Studio/Settings/WorkspaceStorageBehavior.cs

@@ -0,0 +1,9 @@
+namespace AIStudio.Settings;
+
+public enum WorkspaceStorageBehavior
+{
+    DISABLE_WORKSPACES,
+    
+    STORE_CHATS_AUTOMATICALLY,
+    STORE_CHATS_MANUALLY,
+}

app/MindWork AI Studio/Settings/WorkspaceStorageTemporaryMaintenancePolicy.cs

@@ -0,0 +1,12 @@
+namespace AIStudio.Settings;
+
+public enum WorkspaceStorageTemporaryMaintenancePolicy
+{
+    NO_AUTOMATIC_MAINTENANCE,
+    
+    DELETE_OLDER_THAN_7_DAYS,
+    DELETE_OLDER_THAN_30_DAYS,
+    DELETE_OLDER_THAN_90_DAYS,
+    DELETE_OLDER_THAN_180_DAYS,
+    DELETE_OLDER_THAN_365_DAYS,
+}

app/MindWork AI Studio/Tools/CommonLanguageExtensions.cs

@@ -0,0 +1,22 @@
+namespace AIStudio.Tools;
+
+public static class CommonLanguageExtensions
+{
+    public static string Name(this CommonLanguages language) => language switch
+    {
+        CommonLanguages.AS_IS => "Do not change the language",
+        
+        CommonLanguages.EN_US => "English (US)",
+        CommonLanguages.EN_GB => "English (UK)",
+        CommonLanguages.ZH_CN => "Chinese (Simplified)",
+        CommonLanguages.HI_IN => "Hindi (India)",
+        CommonLanguages.ES_ES => "Spanish (Spain)",
+        CommonLanguages.FR_FR => "French (France)",
+        CommonLanguages.DE_DE => "German (Germany)",
+        CommonLanguages.DE_AT => "German (Austria)",
+        CommonLanguages.DE_CH => "German (Switzerland)",
+        CommonLanguages.JA_JP => "Japanese (Japan)",
+            
+        _ => "Other",
+    };
+}