MindWorkAI/AI-Studio
1
0 Fork 0
mirror of https://github.com/MindWorkAI/AI-Studio.git synced 2026-11-15 10:48:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Moved the chats of the BeyondFacts Lab to the embedded chat of assistants (#1203)

Browse Source
This commit is contained in:
Thorsten Sommer authored and GitHub committed 2026-11-15 10:32:46 +01:00
1 parent dc97db256e
commit cb54ad297d
27 files changed
+1019 -739
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

app/MindWork AI Studio/Assistants/BeyondFactsLab/BflChat.razor
+17 -77
View File
@@ -1,79 +1,19 @@
@using AIStudio.Chat
@inherits MSGComponentBase
@if (this.ShowHeading)
{
<MudText Typo="Typo.h6" Class="mt-6 mb-2">@T("Conversation")</MudText>
}
@if (this.conversation is null)
{
<MudProgressLinear Color="Color.Primary" Indeterminate="true" Class="mb-3"/>
}
else if (this.conversation.Thread is not { } thread)
{
<MudAlert Severity="Severity.Error" Variant="Variant.Outlined" Class="mb-3">
@TA("AI Studio cannot open this conversation. Its file may be damaged, or a newer version of AI Studio stored it. You can start the conversation over, which deletes it.")
</MudAlert>
<MudButton StartIcon="@AppIcons.RESET" Color="Color.Error" OnClick="@this.ResetAsync">@T("Start over")</MudButton>
}
else
{
@if (!this.conversation.HasVisibleMessages && !this.IsRunning)
{
<MudText Typo="Typo.body2" Class="mb-3">@this.Introduction</MudText>
<div class="mb-4">
<MudButton Variant="Variant.Filled" Color="Color.Primary" StartIcon="@AppIcons.CHAT" OnClick="@this.StartAsync" Disabled="@(!this.CanSend)">
@T("Start the conversation")
</MudButton>
</div>
}
else
{
@foreach (var block in thread.Blocks)
{
@if (block is { HideFromUser: false, Content: not null })
{
<ContentBlockComponent Role="@block.Role" Type="@block.ContentType" Time="@block.Time" Content="@block.Content" ExportTitle="@T("Export message")" ExportFileName="@this.ExportFileName"/>
}
}
}
@if (this.ProviderIssue is { } issue)
{
<MudText Typo="Typo.body2" Color="Color.Warning" Class="mb-2">@issue</MudText>
}
@* Laid out like the input of the chat page: sending through the icon in the field, and the tokens as its helper text. *@
<MudTextField T="string"
@bind-Value="@this.userInput"
Immediate="true"
Lines="3"
Sizing="InputSizing.Auto"
MaxLines="12"
Variant="Variant.Outlined"
Label="@TA("Your message")"
Adornment="Adornment.End"
AdornmentIcon="@AppIcons.SEND"
AdornmentColor="@(this.CanSendMessage ? Color.Primary : Color.Default)"
AdornmentAriaLabel="@T("Send")"
OnAdornmentClick="@this.SendAsync"
OnKeyUp="@this.InputKeyEventAsync"
UserAttributes="@this.inputAttributes"
HelperText="@this.TokenBudgetText"
Class="@this.InputClass"
Disabled="@(!this.conversation.IsAvailable || this.IsRunning)"/>
@if (this.IsRunning || this.conversation.HasVisibleMessages)
{
<MudStack Row="true" Spacing="1" Class="mt-2">
@if (this.IsRunning)
{
<MudButton Variant="Variant.Filled" Color="Color.Error" StartIcon="@AppIcons.STOP" OnClick="@this.CancelAsync">@T("Stop")</MudButton>
}
@if (this.conversation.HasVisibleMessages)
{
<MudButton StartIcon="@AppIcons.RESET" OnClick="@this.ResetAsync" Disabled="@this.IsRunning">@T("Start over")</MudButton>
}
</MudStack>
}
}
<EmbeddedChat Store="@this.ConversationService.StoreOf(this.Location)"
Component="@Components.BEYOND_FACTS_LAB_ASSISTANT"
ChatId="@this.Location.ChatId"
CreateThread="@this.CreateThread"
Provider="@this.Provider"
PrepareAsync="@this.prepareAsync"
ProviderIssue="@this.ProviderIssue"
Heading="@(this.ShowHeading ? T("Conversation") : null)"
StartRequest="@BflConversationService.OpeningRequestFor(this.Location)"
Introduction="@this.Introduction"
ExportFileName="@this.ExportFileName"
AllowsReset="true"
ResetQuestion="@this.ResetQuestion"
AllowsAttachments="false"
ShowsContextWindow="true"
SystemPromptForCountAsync="@this.systemPromptForCountAsync"
ContextVersion="@this.materialsVersion"/>
app/MindWork AI Studio/Assistants/BeyondFactsLab/BflChat.razor.cs
+32 -216
View File
@@ -1,13 +1,8 @@
using AIStudio.Chat;
using AIStudio.Chat.Embedded;
using AIStudio.Components;
using AIStudio.Dialogs;
using AIStudio.Settings.DataModel;
using AIStudio.Tools.Services;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web;
using DialogOptions = AIStudio.Dialogs.DialogOptions;
namespace AIStudio.Assistants.BeyondFactsLab;
@@ -15,9 +10,11 @@ namespace AIStudio.Assistants.BeyondFactsLab;
/// A chat of the BeyondFacts Lab, such as the one of a step below its form "Your details".
/// </summary>
/// <remarks>
/// The chat itself lives in BflConversationService, so an answer goes on while the person looks elsewhere; this
/// component shows it and renders whenever the service says it changed. It offers no "send to": the lab neither
/// receives content from other assistants nor hands its answers on.
/// The embedded chat of assistants with what the lab decides for each of its places: the opening request, the
/// introduction, the question before starting over, and, for every request, the system prompt with the guide, the
/// details, and the material, see BflConversationService.PrepareAsync. The count of tokens shows how full the context
/// of the model is, since every request carries the guide. It offers no "send to": the lab neither receives content
/// from other assistants nor hands its answers on.
/// </remarks>
public partial class BflChat : MSGComponentBase
{
@@ -51,67 +48,24 @@ public partial class BflChat : MSGComponentBase
[Inject]
private BflMaterialService MaterialService { get; init; } = null!;
[Inject]
private IDialogService DialogService { get; init; } = null!;
[Inject]
private ILogger<BflChat> Logger { get; init; } = null!;
[Inject]
private ConversationTokenCounter TokenCounter { get; init; } = null!;
/// <summary>
/// Readies a request of the chat shown, with the provider chosen; made anew whenever either changes.
/// </summary>
private Func<ChatThread, Task<EmbeddedChatPreparation>> prepareAsync = _ => Task.FromResult(EmbeddedChatPreparation.REFUSED);
/// <summary>
/// Ends a count when the component goes away.
/// Gets the system prompt of the next request of the chat shown, for the count of tokens; made anew whenever the
/// chat or the provider changes.
/// </summary>
private readonly CancellationTokenSource countCancellation = new();
private Func<Task<string?>> systemPromptForCountAsync = () => Task.FromResult<string?>(null);
/// <summary>
/// The token of countCancellation, taken while the source still lives.
/// Changes whenever the material of the preparation changes, since every request of a step carries it.
/// </summary>
/// <remarks>
/// A count goes on after an await, when the component may have gone away meanwhile, e.g., because the person moved
/// on to another step. The source is disposed by then and refuses to hand out its token; the token taken before
/// still tells that the count was cancelled.
/// </remarks>
private CancellationToken countToken;
/// <summary>
/// What the next request carries, as far as it was counted.
/// </summary>
private ConversationTokens tokens = ConversationTokens.UNAVAILABLE;
/// <summary>
/// The provider the tokens were counted for, to count again when the parent chooses another one.
/// </summary>
private string countedProviderId = string.Empty;
/// <summary>
/// The chat shown, or null while it loads.
/// </summary>
private BflConversation? conversation;
/// <summary>
/// Where the chat shown belongs, to notice when the parent shows another one.
/// </summary>
private BflThreadLocation? shownLocation;
/// <summary>
/// The message the person writes.
/// </summary>
private string userInput = string.Empty;
/// <summary>
/// The attributes of the message field, such as the spell checking the person chose.
/// </summary>
private readonly Dictionary<string, object?> inputAttributes = new();
private bool IsRunning => this.conversation?.IsRunning ?? false;
private BflTokenBudgetState Budget => BflTokenBudget.Of(this.tokens);
private bool CanSend => this.conversation is { IsAvailable: true, IsRunning: false } && this.ProviderIssue is null && this.Budget is not BflTokenBudgetState.FULL;
private bool CanSendMessage => this.CanSend && !string.IsNullOrWhiteSpace(this.userInput);
private int materialsVersion;
/// <summary>
/// Gets what the chat says before its conversation begins.
@@ -143,10 +97,7 @@ public partial class BflChat : MSGComponentBase
/// <inheritdoc />
protected override async Task OnInitializedAsync()
{
this.countToken = this.countCancellation.Token;
this.ConversationService.ConversationChanged += this.OnConversationChangedAsync;
this.MaterialService.MaterialsChanged += this.OnMaterialsChangedAsync;
this.SettingsManager.InjectSpellchecking(this.inputAttributes);
await base.OnInitializedAsync();
}
@@ -154,48 +105,28 @@ public partial class BflChat : MSGComponentBase
protected override async Task OnParametersSetAsync()
{
await base.OnParametersSetAsync();
if (this.shownLocation != this.Location)
{
this.shownLocation = this.Location;
this.conversation = null;
this.userInput = string.Empty;
this.conversation = await this.ConversationService.GetAsync(this.Location);
await this.RecountAsync();
}
else if (this.countedProviderId != this.Provider.Id)
await this.RecountAsync();
// Bound to the chat and the provider shown now, so that a request never takes those of the next render:
var location = this.Location;
var provider = this.Provider;
this.prepareAsync = thread => this.ConversationService.PrepareAsync(location, provider, thread);
this.systemPromptForCountAsync = () => this.SystemPromptForCountAsync(location, provider);
}
/// <inheritdoc />
protected override void DisposeResources()
{
this.ConversationService.ConversationChanged -= this.OnConversationChangedAsync;
this.MaterialService.MaterialsChanged -= this.OnMaterialsChangedAsync;
this.countCancellation.Cancel();
this.countCancellation.Dispose();
base.DisposeResources();
}
/// <summary>
/// Renders the chat again when the service changed it, and counts again once an answer is complete.
/// Creates the chat of the place shown, for a place which has no stored chat yet.
/// </summary>
/// <param name="location">Where the chat which changed belongs.</param>
private Task OnConversationChangedAsync(BflThreadLocation location)
{
if (location != this.Location)
return Task.CompletedTask;
return this.InvokeAsync(async () =>
{
if (!this.IsRunning)
await this.RecountAsync();
this.StateHasChanged();
});
}
private ChatThread CreateThread() => BflThreadFactory.Create(this.Location);
/// <summary>
/// Counts again when the material of the preparation changed, since every request of a step carries it.
/// Lets the chat count again when the material of the preparation changed.
/// </summary>
/// <param name="projectId">The ID of the preparation whose material changed.</param>
private Task OnMaterialsChangedAsync(Guid projectId)
@@ -203,145 +134,30 @@ public partial class BflChat : MSGComponentBase
if (this.Location is not BflStepThreadLocation stepLocation || stepLocation.ProjectId != projectId)
return Task.CompletedTask;
return this.InvokeAsync(async () =>
return this.InvokeAsync(() =>
{
if (!this.IsRunning)
await this.RecountAsync();
this.materialsVersion++;
this.StateHasChanged();
});
}
/// <summary>
/// Counts what the next request of the chat carries: the system prompt, e.g., with the guide, and the conversation.
/// Puts together the system prompt of the next request of a chat, for the count of tokens.
/// </summary>
/// <remarks>
/// Only while no answer runs: the request appends to the conversation which the count reads. The message being
/// written is left out; the reserve of the budget keeps room for it.
/// </remarks>
private async Task RecountAsync()
/// <param name="location">Where the chat belongs.</param>
/// <param name="provider">The provider which answers.</param>
/// <returns>The system prompt, or null when it cannot be put together now.</returns>
private async Task<string?> SystemPromptForCountAsync(BflThreadLocation location, AIStudio.Settings.Provider provider)
{
this.countedProviderId = this.Provider.Id;
if (this.conversation is not { Thread: { } thread, IsRunning: false } || this.ProviderIssue is not null)
{
this.tokens = ConversationTokens.UNAVAILABLE;
return;
}
try
{
var systemPrompt = await this.ConversationService.ComposeSystemPromptAsync(this.Location, this.Provider);
var parts = ConversationParts.Of(thread, systemPrompt, string.Empty, null, false, null);
this.tokens = await this.TokenCounter.CountAsync(this.Provider, parts, thread.ReportedHistoryFor(this.Provider.Model), this.countToken);
}
catch (OperationCanceledException)
{
// The component went away.
return await this.ConversationService.ComposeSystemPromptAsync(location, provider);
}
catch (Exception exception) when (exception is IOException or UnauthorizedAccessException or FormatException)
{
// Sending reports the same problem; the count only stays unknown:
this.Logger.LogDebug(exception, "Could not count the tokens of a chat in the BeyondFacts Lab.");
this.tokens = ConversationTokens.UNAVAILABLE;
}
}
/// <summary>
/// Gets how full the context of the model is, or null when nothing could be counted.
/// </summary>
private string? TokenBudgetText
{
get
{
if (!this.tokens.IsKnown)
return null;
var culture = Tools.PluginSystem.I18N.I.Culture;
var counted = TokenAmount.Format(this.tokens.Tokens, culture);
if (!this.tokens.Window.IsKnown)
return string.Format(T("approx. {0} tokens; the context window of this model is unknown"), counted);
var window = TokenAmount.Format(this.tokens.Window.DefaultTokens, culture);
var budget = string.Format(this.tokens.IsEstimate && !this.tokens.HistoryIsReported ? T("approx. {0} of {1} tokens") : T("{0} of {1} tokens"), counted, window);
return this.Budget switch
{
BflTokenBudgetState.FULL => $"{budget}. {TA("This conversation fills the context window of the model. Start it over, or choose a provider whose model reads more at once.")}",
BflTokenBudgetState.WARNING => $"{budget}. {TA("This conversation fills most of the context window of the model. Soon, you will have to start it over.")}",
_ => budget
};
}
}
/// <summary>
/// Gets the classes of the message field; like on the chat page, they colour its helper text with the tokens.
/// </summary>
private string InputClass => this.Budget switch
{
BflTokenBudgetState.FULL => "mt-2 token-budget-exceeded",
BflTokenBudgetState.WARNING => "mt-2 token-budget-nearly-full",
_ => "mt-2"
};
/// <summary>
/// Lets the model open the conversation.
/// </summary>
private async Task StartAsync()
{
if (this.CanSend)
await this.ConversationService.StartAsync(this.Location, this.Provider);
}
/// <summary>
/// Sends the message of the person.
/// </summary>
private async Task SendAsync()
{
if (!this.CanSendMessage)
return;
var text = this.userInput.Trim();
this.userInput = string.Empty;
await this.ConversationService.SendAsync(this.Location, this.Provider, text);
}
/// <summary>
/// Sends the message when the person releases the shortcut they chose for the chat.
/// </summary>
/// <param name="keyEvent">The key released.</param>
private async Task InputKeyEventAsync(KeyboardEventArgs keyEvent)
{
if (this.SettingsManager.ConfigurationData.Chat.ShortcutSendBehavior.IsSendShortcut(keyEvent))
await this.SendAsync();
}
/// <summary>
/// Stops the answer the model writes.
/// </summary>
private Task CancelAsync() => this.ConversationService.CancelAsync(this.Location);
/// <summary>
/// Deletes the conversation after asking, so that it starts over.
/// </summary>
private async Task ResetAsync()
{
var parameters = new DialogParameters<ConfirmDialog>
{
{ dialog => dialog.Message, this.ResetQuestion }
};
var reference = await this.DialogService.ShowAsync<ConfirmDialog>(T("Start over"), parameters, DialogOptions.FULLSCREEN);
var result = await reference.Result;
if (result is null || result.Canceled)
return;
try
{
await this.ConversationService.ResetAsync(this.Location);
}
catch (Exception exception) when (exception is IOException or UnauthorizedAccessException)
{
this.Logger.LogError(exception, "Could not delete the chat '{Location}' of the BeyondFacts Lab.", this.Location.Key);
await this.MessageBus.SendError(new(AppIcons.DELETE, TA("AI Studio could not delete this conversation. Please try again.")));
}
}
}
app/MindWork AI Studio/Assistants/BeyondFactsLab/BflChatStore.cs
+38
View File
@@ -0,0 +1,38 @@
using AIStudio.Chat;
using AIStudio.Chat.Embedded;
namespace AIStudio.Assistants.BeyondFactsLab;
/// <summary>
/// Lets the embedded chat of a place of the BeyondFacts Lab live where the lab keeps it, e.g., in the folder of a step
/// of a preparation.
/// </summary>
/// <remarks>
/// The ID of a chat of the lab follows from its place, see BflThreadId, so the store serves the one chat of its place
/// and refuses any other. Files, paths, and locks stay those of BeyondFactsLabStore, so chats stored before keep
/// working, and the cleanup of the provenance store still finds every chat, see
/// BeyondFactsLabStore.ReadAllThreadLocations.
/// </remarks>
/// <param name="store">The store of the lab.</param>
/// <param name="location">The place of the chat.</param>
public sealed class BflChatStore(BeyondFactsLabStore store, BflThreadLocation location) : IEmbeddedChatStore
{
/// <inheritdoc />
public Task<ChatThread?> LoadThreadAsync(Guid chatId, CancellationToken token = default) => store.LoadThreadAsync(this.LocationOf(chatId), token);
/// <inheritdoc />
public Task SaveThreadAsync(ChatThread thread, CancellationToken token = default) => store.SaveThreadAsync(this.LocationOf(thread.ChatId), thread, token);
/// <inheritdoc />
public Task DeleteThreadAsync(Guid chatId, CancellationToken token = default) => store.DeleteThreadAsync(this.LocationOf(chatId), token);
/// <summary>
/// Gets the place of a chat, which must be the place of this store.
/// </summary>
/// <param name="chatId">The ID of the chat.</param>
/// <returns>The place of the store.</returns>
/// <exception cref="ArgumentException">The chat belongs to another place.</exception>
private BflThreadLocation LocationOf(Guid chatId) => chatId == location.ChatId
? location
: throw new ArgumentException("The chat belongs to another place of the lab.", nameof(chatId));
}
app/MindWork AI Studio/Assistants/BeyondFactsLab/BflConversation.cs
-38
View File
@@ -1,38 +0,0 @@
using AIStudio.Chat;
namespace AIStudio.Assistants.BeyondFactsLab;
/// <summary>
/// A chat of the BeyondFacts Lab, as BflConversationService keeps it while the app runs.
/// </summary>
/// <remarks>
/// The service keeps it beyond the page, so that an answer goes on while the person looks at another page, and the
/// page shows it again when it comes back.
/// </remarks>
public sealed class BflConversation
{
/// <summary>
/// Gets where the chat belongs, e.g., to a step of a preparation.
/// </summary>
public required BflThreadLocation Location { get; init; }
/// <summary>
/// Gets or sets the chat, or null when this version cannot open the stored one.
/// </summary>
public ChatThread? Thread { get; set; }
/// <summary>
/// Gets or sets whether the model answers right now.
/// </summary>
public bool IsRunning { get; set; }
/// <summary>
/// Gets whether the chat can be shown and continued.
/// </summary>
public bool IsAvailable => this.Thread is not null;
/// <summary>
/// Gets whether the chat has a message the person sees.
/// </summary>
public bool HasVisibleMessages => this.Thread?.Blocks.Any(block => !block.HideFromUser) ?? false;
}
app/MindWork AI Studio/Assistants/BeyondFactsLab/BflConversationService.cs
+55 -279
View File
@@ -1,28 +1,30 @@
using System.Collections.Concurrent;
using AIStudio.Chat;
using AIStudio.Chat.Embedded;
using AIStudio.Provider;
using AIStudio.Settings;
using AIStudio.Tools.AssistantSessions;
using AIStudio.Tools.ToolCallingSystem;
namespace AIStudio.Assistants.BeyondFactsLab;
/// <summary>
/// Runs the chats of the BeyondFacts Lab, such as those of the steps of a preparation.
/// Opens the chats of the BeyondFacts Lab, such as those of the steps of a preparation, and puts together what each of
/// their requests carries.
/// </summary>
/// <remarks>
/// A singleton, so that an answer goes on while the person looks at another page: the page asks for the chat again
/// when it comes back and listens to ConversationChanged. Each request registers in AssistantSessionService, which
/// shows the work in the navigation. The service does nothing until the page of the lab asks for a chat.
/// The chats themselves run in EmbeddedChatService, like the chats of other assistants: it keeps them while the app
/// runs, so that an answer goes on while the person looks at another page, and registers each request in
/// AssistantSessionService. A chat lives where the lab keeps it, see BflChatStore. What the lab decides for every
/// request comes from here, see PrepareAsync: the system prompt with the guide, the details, and the material, the
/// images of the material, the tools, and where the chat may send data. The service does nothing until the page of the
/// lab asks for a chat.
/// </remarks>
/// <param name="store">The store of the lab.</param>
/// <param name="chatService">The service which runs the embedded chats.</param>
/// <param name="settingsManager">The settings.</param>
/// <param name="sessionService">The registry of running assistant sessions.</param>
/// <param name="messageBus">The message bus, for errors.</param>
/// <param name="toolRegistry">The registry of the tools, which tells the chats what they can do on the web.</param>
/// <param name="logger">The logger.</param>
public sealed class BflConversationService(BeyondFactsLabStore store, SettingsManager settingsManager, AssistantSessionService sessionService, MessageBus messageBus, ToolRegistry toolRegistry, ILogger<BflConversationService> logger)
public sealed class BflConversationService(BeyondFactsLabStore store, EmbeddedChatService chatService, SettingsManager settingsManager, MessageBus messageBus, ToolRegistry toolRegistry, ILogger<BflConversationService> logger)
{
/// <summary>
/// The request which lets the model open the conversation of a step. The person does not see it.
@@ -38,41 +40,13 @@ public sealed class BflConversationService(BeyondFactsLabStore store, SettingsMa
/// </summary>
public const string ONBOARDING_OPENING_REQUEST = "Beginne das Gespräch mit deiner ersten Nachricht, wie es der Abschnitt „Gesprächsführung“ beschreibt.";
/// <summary>
/// How often a streamed answer renders at most.
/// </summary>
private static readonly TimeSpan STREAMING_RENDER_MIN_TIME = TimeSpan.FromMilliseconds(100);
private static string TA(string fallbackEN) => Tools.PluginSystem.I18N.I.TA(fallbackEN, typeof(BflConversationService).Namespace, nameof(BflConversationService));
/// <summary>
/// The chats loaded so far, by their places.
/// </summary>
private readonly ConcurrentDictionary<BflThreadLocation, BflConversation> conversations = new();
/// <summary>
/// Serializes loading a chat, so that two pages never load the same chat twice.
/// </summary>
private readonly SemaphoreSlim loadLock = new(1, 1);
/// <summary>
/// Guards whether a chat answers right now, so that two requests never run in the same chat.
/// </summary>
private readonly Lock runningLock = new();
/// <summary>
/// Gets the folder whose files replace the prompts of the lab, or null while the person does not allow it. The
/// setting counts anew for every request, so that switching it on or off shows in the next answer.
/// </summary>
internal string? PromptOverridesDirectory =>BflPromptOverrides.ActiveDirectory(settingsManager.ConfigurationData.BeyondFactsLab, store.PromptOverridesDirectory);
/// <summary>
/// Happens whenever a chat changed: a message, a chunk of an answer, or the end of a request.
/// </summary>
/// <remarks>
/// Called on the thread of the request. A page renders through InvokeAsync.
/// </remarks>
public event Func<BflThreadLocation, Task>? ConversationChanged;
internal string? PromptOverridesDirectory => BflPromptOverrides.ActiveDirectory(settingsManager.ConfigurationData.BeyondFactsLab, store.PromptOverridesDirectory);
/// <summary>
/// Gets a chat, loading it on the first call.
@@ -80,72 +54,52 @@ public sealed class BflConversationService(BeyondFactsLabStore store, SettingsMa
/// <param name="location">Where the chat belongs.</param>
/// <param name="token">The cancellation token.</param>
/// <returns>The chat; it is not available when this version cannot open the stored one.</returns>
public async Task<BflConversation> GetAsync(BflThreadLocation location, CancellationToken token = default)
{
if (this.conversations.TryGetValue(location, out var conversation))
return conversation;
await this.loadLock.WaitAsync(token);
try
{
if (this.conversations.TryGetValue(location, out conversation))
return conversation;
ChatThread? thread;
try
{
thread = await store.LoadThreadAsync(location, token) ?? BflThreadFactory.Create(location);
}
catch (InvalidDataException exception)
{
// The file stays as it is, see BeyondFactsLabStore.SaveThreadAsync:
logger.LogWarning(exception, "Could not open the chat '{Location}' of the BeyondFacts Lab.", location.Key);
thread = null;
}
conversation = new BflConversation { Location = location, Thread = thread };
this.conversations[location] = conversation;
return conversation;
}
finally
{
this.loadLock.Release();
}
}
public Task<EmbeddedConversation> GetAsync(BflThreadLocation location, CancellationToken token = default) => chatService.GetAsync(this.StoreOf(location), Tools.Components.BEYOND_FACTS_LAB_ASSISTANT, location.ChatId, () => BflThreadFactory.Create(location), token);
/// <summary>
/// Lets the model open a conversation, as its prompt describes.
/// Gets where a chat of the lab lives.
/// </summary>
/// <param name="location">Where the chat belongs.</param>
/// <param name="provider">The provider which answers.</param>
public Task StartAsync(BflThreadLocation location, AIStudio.Settings.Provider provider) => this.SendAsync(location, provider, OpeningRequestFor(location), isHidden: true);
/// <returns>The store, which serves this chat only.</returns>
public IEmbeddedChatStore StoreOf(BflThreadLocation location) => new BflChatStore(store, location);
/// <summary>
/// Gets the request which lets the model open a conversation.
/// Gets the request which lets the model open a conversation, see EmbeddedChat.StartRequest. The person does not see
/// it.
/// </summary>
/// <param name="location">Where the chat belongs.</param>
/// <returns>The request, which names the section of the prompt that describes the first message.</returns>
public static string OpeningRequestFor(BflThreadLocation location) => location is BflOnboardingThreadLocation ? ONBOARDING_OPENING_REQUEST : OPENING_REQUEST;
/// <summary>
/// Sends a message of the person and lets the model answer it.
/// Stops every answer of a preparation and forgets its chats, e.g., because the person deleted it.
/// </summary>
/// <param name="projectId">The ID of the preparation.</param>
/// <returns>The IDs of the chats the preparation could have had.</returns>
public async Task<IReadOnlyList<Guid>> ForgetProjectAsync(Guid projectId)
{
List<Guid> chatIds = [.. BflStep.All.Select(step => new BflStepThreadLocation(projectId, step).ChatId)];
foreach (var chatId in chatIds)
await chatService.ForgetAsync(chatId);
return chatIds;
}
/// <summary>
/// Readies a chat of the lab for a request, see EmbeddedChatRequest.PrepareAsync: checks the provider and puts
/// together what the request carries.
/// </summary>
/// <remarks>
/// The message is stored before the model answers, so that a crash loses at most the answer. What goes wrong is
/// reported through the message bus; the method itself does not fail.
/// What goes wrong is reported through the message bus; the request then does not go out.
/// </remarks>
/// <param name="location">Where the chat belongs.</param>
/// <param name="provider">The provider which answers.</param>
/// <param name="text">The message.</param>
/// <param name="isHidden">Whether the person does not see the message, e.g., the request which opens a conversation.</param>
public async Task SendAsync(BflThreadLocation location, AIStudio.Settings.Provider provider, string text, bool isHidden = false)
/// <param name="thread">The chat.</param>
/// <returns>What the request carries, or EmbeddedChatPreparation.REFUSED.</returns>
public async Task<EmbeddedChatPreparation> PrepareAsync(BflThreadLocation location, AIStudio.Settings.Provider provider, ChatThread thread)
{
if (string.IsNullOrWhiteSpace(text))
return;
var conversation = await this.GetAsync(location);
if (conversation.Thread is not { } thread || !await this.CheckProviderAsync(location, thread, provider))
return;
if (!await this.CheckProviderAsync(location, thread, provider))
return EmbeddedChatPreparation.REFUSED;
BflRequestMaterial requestMaterial;
try
@@ -155,139 +109,35 @@ public sealed class BflConversationService(BeyondFactsLabStore store, SettingsMa
catch (BflPromptOverrideException exception)
{
logger.LogWarning(exception, "A prompt override of the BeyondFacts Lab has a placeholder which the lab does not fill.");
await messageBus.SendError(new(AppIcons.ERROR, string.Format(TA("The file '{0}' in the test folder of the BeyondFacts Lab contains the placeholder '{1}', which the lab does not fill in this file. Please correct the file and try again."),exception.FileName, exception.Placeholder)));
return;
await messageBus.SendError(new(AppIcons.ERROR, string.Format(TA("The file '{0}' in the test folder of the BeyondFacts Lab contains the placeholder '{1}', which the lab does not fill in this file. Please correct the file and try again."), exception.FileName, exception.Placeholder)));
return EmbeddedChatPreparation.REFUSED;
}
catch (Exception exception) when (exception is IOException or UnauthorizedAccessException or FormatException)
{
logger.LogError(exception, "The BeyondFacts Lab could not put together the system prompt of the chat '{Location}'.", location.Key);
await messageBus.SendError(new(AppIcons.ERROR, TA("The BeyondFacts Lab could not put together its instructions for the model. Please report this as a bug.")));
return;
return EmbeddedChatPreparation.REFUSED;
}
lock (this.runningLock)
{
if (conversation.IsRunning)
return;
conversation.IsRunning = true;
return Prepare(location, provider, thread, requestMaterial);
}
ContentBlock? answerBlock = null;
var sessionKey = SessionKey(location);
var sessionId = Guid.Empty;
var status = AssistantSessionStatus.FAILED;
try
/// <summary>
/// Readies a chat of the lab for a request with what the lab put together for it.
/// </summary>
/// <param name="location">Where the chat belongs.</param>
/// <param name="provider">The provider which answers.</param>
/// <param name="thread">The chat, which gets its prompt, its tools, and its restriction.</param>
/// <param name="requestMaterial">The system prompt and the images of the material.</param>
/// <returns>The preparation, whose request carries the images, see WithImages.</returns>
internal static EmbeddedChatPreparation Prepare(BflThreadLocation location, AIStudio.Settings.Provider provider, ChatThread thread, BflRequestMaterial requestMaterial)
{
// A chat stored before the lab offered tools gets its restriction now, before it may read a page:
BflChatTools.Restrict(thread, location);
BflThreadFactory.PrepareForRequest(thread, provider, requestMaterial.SystemPrompt, BflChatTools.For(location));
var request = new ContentText { Text = text };
thread.Blocks.Add(new ContentBlock
{
Time = DateTimeOffset.Now,
ContentType = ContentType.TEXT,
Role = ChatRole.USER,
Content = request,
HideFromUser = isHidden
});
await store.SaveThreadAsync(location, thread);
var answer = new ContentText { InitialRemoteWait = true };
answerBlock = new ContentBlock
{
Time = DateTimeOffset.Now,
ContentType = ContentType.TEXT,
Role = ChatRole.AI,
Content = answer
};
var lastRendering = DateTimeOffset.MinValue;
answer.StreamingEvent = async () =>
{
var now = DateTimeOffset.Now;
if (now - lastRendering < STREAMING_RENDER_MIN_TIME)
return;
lastRendering = now;
await this.NotifyAsync(location);
};
answer.StreamingDone = () => this.NotifyAsync(location);
thread.Blocks.Add(answerBlock);
var cancellation = new CancellationTokenSource();
sessionId = (await sessionService.TryBeginAsync(sessionKey, Tools.Components.BEYOND_FACTS_LAB_ASSISTANT.Name, cancellation, thread, new(StringComparer.Ordinal))).SessionId;
await this.NotifyAsync(location);
await answer.CreateFromProviderAsync(provider.CreateProvider(), provider.Model, request, WithImages(thread, requestMaterial.Images), cancellation.Token);
status = cancellation.IsCancellationRequested ? AssistantSessionStatus.CANCELED : AssistantSessionStatus.COMPLETED;
}
catch (OperationCanceledException)
{
status = AssistantSessionStatus.CANCELED;
}
catch (ProviderRequestException exception)
{
logger.LogError(exception, "The provider request of the BeyondFacts Lab failed. Status={StatusCode}, Reason='{ReasonPhrase}'.", exception.StatusCode, exception.ReasonPhrase);
await messageBus.SendError(new(AppIcons.PROVIDER_ERROR, exception.UserMessage));
}
catch (Exception exception) when (exception is IOException or UnauthorizedAccessException or InvalidDataException)
{
logger.LogError(exception, "The BeyondFacts Lab could not store the chat '{Location}'.", location.Key);
await messageBus.SendError(new(AppIcons.SAVE_FAILED, TA("AI Studio could not save this conversation. Please try again.")));
}
finally
{
await this.FinishAsync(conversation, thread, answerBlock, sessionKey, sessionId, status);
}
}
/// <summary>
/// Stops the answer the model writes in a chat.
/// </summary>
/// <param name="location">Where the chat belongs.</param>
public Task CancelAsync(BflThreadLocation location) => sessionService.CancelAsync(SessionKey(location));
/// <summary>
/// Deletes a conversation, so that it starts over.
/// </summary>
/// <param name="location">Where the chat belongs.</param>
/// <returns>False while the model answers in the chat.</returns>
public async Task<bool> ResetAsync(BflThreadLocation location)
{
var conversation = await this.GetAsync(location);
lock (this.runningLock)
{
if (conversation.IsRunning)
return false;
}
await store.DeleteThreadAsync(location);
conversation.Thread = BflThreadFactory.Create(location);
// The new conversation keeps the ID of the chat, so what the old one received would otherwise wait for the next start:
await ChatProvenance.ForgetChatsAsync([location.ChatId]);
await this.NotifyAsync(location);
return true;
}
/// <summary>
/// Stops every answer of a preparation and forgets its chats, e.g., because the person deleted it.
/// </summary>
/// <param name="projectId">The ID of the preparation.</param>
/// <returns>The IDs of the chats the preparation could have had.</returns>
public async Task<IReadOnlyList<Guid>> ForgetProjectAsync(Guid projectId)
{
var locations = BflStep.All.Select(step => new BflStepThreadLocation(projectId, step)).ToList();
foreach (var location in locations)
{
await sessionService.CancelAsync(SessionKey(location));
this.conversations.TryRemove(location, out _);
}
return [.. locations.Select(location => location.ChatId)];
var images = requestMaterial.Images;
return EmbeddedChatPreparation.READY with { ThreadForRequest = request => WithImages(request, images) };
}
/// <summary>
@@ -535,78 +385,4 @@ public sealed class BflConversationService(BeyondFactsLabStore store, SettingsMa
await messageBus.SendError(new(AppIcons.PROVIDER_ERROR, reason));
return false;
}
/// <summary>
/// Ends a request: removes an empty answer, stores the chat, and closes the session.
/// </summary>
/// <param name="conversation">The chat.</param>
/// <param name="thread">The thread of the chat.</param>
/// <param name="answerBlock">The block of the answer, or null when the request did not get that far.</param>
/// <param name="sessionKey">The key of the session.</param>
/// <param name="sessionId">The ID of the session, or Guid.Empty when none began.</param>
/// <param name="status">How the request ended.</param>
private async Task FinishAsync(BflConversation conversation, ChatThread thread, ContentBlock? answerBlock, AssistantSessionKey sessionKey, Guid sessionId, AssistantSessionStatus status)
{
if (answerBlock is { Content: ContentText answer } && string.IsNullOrWhiteSpace(answer.Text))
thread.Blocks.Remove(answerBlock);
if (answerBlock is not null)
{
try
{
await store.SaveThreadAsync(conversation.Location, thread);
}
catch (FileNotFoundException)
{
// The person deleted the preparation while the model answered; nothing is left to store.
}
catch (Exception exception) when (exception is IOException or UnauthorizedAccessException or InvalidDataException)
{
logger.LogError(exception, "The BeyondFacts Lab could not store the chat '{Location}'.", conversation.Location.Key);
await messageBus.SendError(new(AppIcons.SAVE_FAILED, TA("AI Studio could not save this conversation. Please try again.")));
}
}
lock (this.runningLock)
conversation.IsRunning = false;
if (sessionId != Guid.Empty)
{
await sessionService.CompleteAsync(sessionKey, sessionId, status, string.Empty, thread, new(StringComparer.Ordinal));
// The lab keeps the chat itself; the registry only shows that the lab is at work:
await sessionService.ClearAsync(sessionKey);
}
await this.NotifyAsync(conversation.Location);
}
/// <summary>
/// Tells every page which listens that a chat changed.
/// </summary>
/// <param name="location">Where the chat belongs.</param>
private async Task NotifyAsync(BflThreadLocation location)
{
if (this.ConversationChanged is not { } handlers)
return;
foreach (var handler in handlers.GetInvocationList().Cast<Func<BflThreadLocation, Task>>())
{
try
{
await handler(location);
}
catch (Exception exception)
{
// A page which went away meanwhile must not stop the answer:
logger.LogDebug(exception, "A page of the BeyondFacts Lab could not show a change of a chat.");
}
}
}
/// <summary>
/// Gets the key under which a request of a chat registers in AssistantSessionService.
/// </summary>
/// <param name="location">Where the chat belongs.</param>
private static AssistantSessionKey SessionKey(BflThreadLocation location) => new(Tools.Components.BEYOND_FACTS_LAB_ASSISTANT, location.Key);
}
app/MindWork AI Studio/Assistants/BeyondFactsLab/BflMaterialBudget.cs
+2 -1
View File
@@ -1,3 +1,4 @@
using AIStudio.Chat.Embedded;
using AIStudio.Models;
namespace AIStudio.Assistants.BeyondFactsLab;
@@ -83,7 +84,7 @@ public static class BflMaterialBudget
if (!contextWindow.IsKnown)
return CHARACTERS_WITHOUT_A_KNOWN_CONTEXT_WINDOW;
var freeTokens = (long)contextWindow.DefaultTokens - BflTokenBudget.RESERVE_TOKENS - (long)Math.Max(0, sentImages) * TOKENS_PER_IMAGE;
var freeTokens = (long)contextWindow.DefaultTokens - EmbeddedChatTokenBudget.RESERVE_TOKENS - (long)Math.Max(0, sentImages) * TOKENS_PER_IMAGE;
var freeCharacters = freeTokens * CHARACTERS_PER_TOKEN - promptCharacters;
return (int)Math.Clamp((long)(freeCharacters * SHARE_OF_THE_FREE_CONTEXT), 0, MAX_CHARACTERS);
}
app/MindWork AI Studio/Assistants/BeyondFactsLab/BflTokenBudget.cs
-40
View File
@@ -1,40 +0,0 @@
using AIStudio.Chat;
namespace AIStudio.Assistants.BeyondFactsLab;
/// <summary>
/// Decides how much room a chat of the BeyondFacts Lab has left in the context of its model.
/// </summary>
/// <remarks>
/// Every request carries the guide of the lab, so a conversation fills the context faster than an ordinary chat.
/// A model which loses the beginning of its context loses its instructions first; therefore, the lab stops before.
/// </remarks>
public static class BflTokenBudget
{
/// <summary>
/// From which share of the context on the lab warns.
/// </summary>
public const double WARNING_SHARE = 0.8;
/// <summary>
/// How many tokens the lab keeps free for the next message and its answer.
/// </summary>
public const int RESERVE_TOKENS = 4_096;
/// <summary>
/// Decides how much room a chat has left.
/// </summary>
/// <param name="tokens">What the conversation costs, with the system prompt, and the context of the model.</param>
/// <returns>The state of the budget.</returns>
public static BflTokenBudgetState Of(ConversationTokens tokens)
{
if (!tokens.IsKnown || !tokens.Window.IsKnown)
return BflTokenBudgetState.UNKNOWN;
var window = tokens.Window.DefaultTokens;
if (tokens.Tokens > window - RESERVE_TOKENS)
return BflTokenBudgetState.FULL;
return tokens.Tokens >= window * WARNING_SHARE ? BflTokenBudgetState.WARNING : BflTokenBudgetState.OK;
}
}
app/MindWork AI Studio/Assistants/ModelComparison/ModelComparisonSeriesChatStore.cs
+3
View File
@@ -15,4 +15,7 @@ public sealed class ModelComparisonSeriesChatStore(ModelComparisonStore store, G
/// <inheritdoc />
public Task SaveThreadAsync(ChatThread thread, CancellationToken token = default) => store.SaveSeriesChatAsync(seriesId, thread, token);
/// <inheritdoc />
public Task DeleteThreadAsync(Guid chatId, CancellationToken token = default) => store.DeleteSeriesChatAsync(seriesId, chatId, token);
}
app/MindWork AI Studio/Assistants/ModelComparison/ModelComparisonSeriesView.razor.cs
+4 -4
View File
@@ -104,7 +104,7 @@ public partial class ModelComparisonSeriesView : MSGComponentBase
/// <summary>
/// Readies a request of the chat the user works in right now, with the provider of that chat.
/// </summary>
private Func<ChatThread, Task<bool>> prepareChat = _ => Task.FromResult(true);
private Func<ChatThread, Task<EmbeddedChatPreparation>> prepareChat = _ => Task.FromResult(EmbeddedChatPreparation.READY);
/// <summary>
/// The copy of the first message of the first chat, with which the second chat starts, or null in the first chat.
@@ -230,12 +230,12 @@ public partial class ModelComparisonSeriesView : MSGComponentBase
/// </summary>
/// <param name="thread">The chat.</param>
/// <param name="provider">The provider which answers in the chat.</param>
/// <returns>Always true: whether the provider may answer, the embedded chat checks itself.</returns>
private Task<bool> PrepareAsync(ChatThread thread, AIStudio.Settings.Provider provider)
/// <returns>Always ready: whether the provider may answer, the embedded chat checks itself.</returns>
private Task<EmbeddedChatPreparation> PrepareAsync(ChatThread thread, AIStudio.Settings.Provider provider)
{
var toolIds = this.ToolRegistry.FilterToolIdsForProvider(provider, this.Series.ToolIds, thread.RequiredOutboundDataRestriction.Restriction);
ModelComparisonSeriesThreads.PrepareForRequest(thread, this.Series, provider, toolIds);
return Task.FromResult(true);
return Task.FromResult(EmbeddedChatPreparation.READY);
}
/// <summary>
app/MindWork AI Studio/Chat/Embedded/EmbeddedChatOpening.cs
+15 -1
View File
@@ -1,7 +1,8 @@
namespace AIStudio.Chat.Embedded;
/// <summary>
/// Decides when an embedded chat sends the message it opens with, see EmbeddedChat.OpeningMessage.
/// Decides how an embedded chat opens: when it sends the message it opens with, see EmbeddedChat.OpeningMessage, and
/// when it offers to let the model begin, see EmbeddedChat.StartRequest.
/// </summary>
public static class EmbeddedChatOpening
{
@@ -19,4 +20,17 @@ public static class EmbeddedChatOpening
/// <returns>True when the chat sends the message now.</returns>
public static bool SendsNow(ContentText? openingMessage, EmbeddedConversation? conversation, bool wasSent) =>
openingMessage is not null && !wasSent && conversation is { IsAvailable: true, IsRunning: false, UserMessageCount: 0 };
/// <summary>
/// Tells whether an embedded chat offers to let the model open its conversation.
/// </summary>
/// <remarks>
/// Only before anything the user sees: once the model or the user wrote, the conversation has begun. The user may
/// always write first instead.
/// </remarks>
/// <param name="startRequest">The request which lets the model begin, or null without one.</param>
/// <param name="conversation">The chat shown, or null while it loads.</param>
/// <returns>True when the chat offers to begin.</returns>
public static bool OffersStart(string? startRequest, EmbeddedConversation? conversation) =>
!string.IsNullOrWhiteSpace(startRequest) && conversation is { IsAvailable: true, IsRunning: false, HasVisibleMessages: false };
}
app/MindWork AI Studio/Chat/Embedded/EmbeddedChatPreparation.cs
+38
View File
@@ -0,0 +1,38 @@
namespace AIStudio.Chat.Embedded;
/// <summary>
/// What an assistant decided while it readied a request of an embedded chat: whether the request goes out, and what it
/// carries beside the stored chat.
/// </summary>
/// <remarks>
/// Both are decided together, since what a request carries may only be known once it was readied, e.g., which images
/// of the assistant fit beside the system prompt. A ready preparation which carries more starts from READY:
/// <c>EmbeddedChatPreparation.READY with { ThreadForRequest = … }</c>.
/// </remarks>
public sealed record EmbeddedChatPreparation
{
/// <summary>
/// The request goes out with the chat as it is.
/// </summary>
public static readonly EmbeddedChatPreparation READY = new() { IsReady = true };
/// <summary>
/// The request does not go out; whoever readied it told the user why.
/// </summary>
public static readonly EmbeddedChatPreparation REFUSED = new() { IsReady = false };
/// <summary>
/// Gets whether the request goes out.
/// </summary>
public bool IsReady { get; private init; }
/// <summary>
/// Gets the chat which the request sends, e.g., with images which the stored chat never holds. The chat itself by
/// default.
/// </summary>
/// <remarks>
/// Called once the message and the block of the answer are in the chat, so that the request carries both. Change a
/// copy only: the chat is stored as it is.
/// </remarks>
public Func<ChatThread, ChatThread> ThreadForRequest { get; init; } = thread => thread;
}
app/MindWork AI Studio/Chat/Embedded/EmbeddedChatRequest.cs
+3 -8
View File
@@ -27,13 +27,8 @@ public sealed record EmbeddedChatRequest
/// <summary>
/// Readies the chat for the request before the message goes in: its system prompt, profile, tools, and data
/// sources, which a chat partly does not store. Returns false to send nothing; it tells the user why itself.
/// sources, which a chat partly does not store. Returns what the request carries beside the stored chat, or
/// EmbeddedChatPreparation.REFUSED to send nothing; it tells the user why itself.
/// </summary>
public Func<ChatThread, Task<bool>> PrepareAsync { get; init; } = _ => Task.FromResult(true);
/// <summary>
/// Gets the chat which the request sends, e.g., with images which the stored chat never holds. The chat itself
/// by default.
/// </summary>
public Func<ChatThread, ChatThread> ThreadForRequest { get; init; } = thread => thread;
public Func<ChatThread, Task<EmbeddedChatPreparation>> PrepareAsync { get; init; } = _ => Task.FromResult(EmbeddedChatPreparation.READY);
}
app/MindWork AI Studio/Chat/Embedded/EmbeddedChatService.cs
+37 -2
View File
@@ -134,7 +134,8 @@ public sealed class EmbeddedChatService(SettingsManager settingsManager, Assista
var status = AssistantSessionStatus.FAILED;
try
{
if (!await request.PrepareAsync(thread) || !await this.CheckProviderAsync(conversation, thread, request.Provider))
var preparation = await request.PrepareAsync(thread);
if (!preparation.IsReady || !await this.CheckProviderAsync(conversation, thread, request.Provider))
return false;
thread.RuntimeComponent = conversation.Component;
@@ -177,7 +178,7 @@ public sealed class EmbeddedChatService(SettingsManager settingsManager, Assista
sessionId = (await sessionService.TryBeginAsync(sessionKey, conversation.Component.Name, cancellation, thread, new(StringComparer.Ordinal))).SessionId;
await this.NotifyAsync(chatId);
await this.answerAsync(request, answer, request.ThreadForRequest(thread), cancellation.Token);
await this.answerAsync(request, answer, preparation.ThreadForRequest(thread), cancellation.Token);
status = cancellation.IsCancellationRequested ? AssistantSessionStatus.CANCELED : AssistantSessionStatus.COMPLETED;
}
catch (OperationCanceledException)
@@ -214,6 +215,40 @@ public sealed class EmbeddedChatService(SettingsManager settingsManager, Assista
? sessionService.CancelAsync(SessionKey(conversation))
: Task.CompletedTask;
/// <summary>
/// Deletes the conversation of a chat, so that it starts over, e.g., because the user asked for it.
/// </summary>
/// <remarks>
/// Works for a chat which this version cannot open as well; it becomes available again. The new conversation keeps
/// the ID of the chat, so what the old one received goes now; otherwise, it would wait for the cleanup at the next
/// start.
/// </remarks>
/// <param name="chatId">The ID of a chat which GetAsync loaded before.</param>
/// <param name="createThread">Creates the thread of the new conversation; it gets the ID of the chat.</param>
/// <returns>False while the model answers in the chat, or when it was not loaded.</returns>
/// <exception cref="IOException">The stored chat could not be deleted; the conversation stays as it is.</exception>
/// <exception cref="UnauthorizedAccessException">The stored chat could not be deleted; the conversation stays as it is.</exception>
public async Task<bool> ResetAsync(Guid chatId, Func<ChatThread> createThread)
{
if (!this.conversations.TryGetValue(chatId, out var conversation))
return false;
lock (this.runningLock)
{
if (conversation.IsRunning)
return false;
}
await conversation.Store.DeleteThreadAsync(chatId);
var thread = createThread();
thread.ChatId = chatId;
conversation.Thread = thread;
await ChatProvenance.ForgetChatsAsync([chatId]);
await this.NotifyAsync(chatId);
return true;
}
/// <summary>
/// Stops the answer of a chat and forgets the chat, e.g., because the user deleted what it belonged to.
/// </summary>
app/MindWork AI Studio/Chat/Embedded/EmbeddedChatTokenBudget.cs
+39
View File
@@ -0,0 +1,39 @@
namespace AIStudio.Chat.Embedded;
/// <summary>
/// Decides how much room an embedded chat has left in the context of its model, see EmbeddedChat.ShowsContextWindow.
/// </summary>
/// <remarks>
/// Meant for assistants whose requests carry long instructions, such as the guide of the BeyondFacts Lab: their
/// conversations fill the context faster than an ordinary chat, and a model which loses the beginning of its context
/// loses its instructions first. Therefore, the chat stops before.
/// </remarks>
public static class EmbeddedChatTokenBudget
{
/// <summary>
/// From which share of the context on the chat warns.
/// </summary>
public const double WARNING_SHARE = 0.8;
/// <summary>
/// How many tokens the chat keeps free for the next message and its answer.
/// </summary>
public const int RESERVE_TOKENS = 4_096;
/// <summary>
/// Decides how much room a chat has left.
/// </summary>
/// <param name="tokens">What the conversation costs, with the system prompt, and the context of the model.</param>
/// <returns>The state of the budget.</returns>
public static EmbeddedChatTokenBudgetState Of(ConversationTokens tokens)
{
if (!tokens.IsKnown || !tokens.Window.IsKnown)
return EmbeddedChatTokenBudgetState.UNKNOWN;
var window = tokens.Window.DefaultTokens;
if (tokens.Tokens > window - RESERVE_TOKENS)
return EmbeddedChatTokenBudgetState.FULL;
return tokens.Tokens >= window * WARNING_SHARE ? EmbeddedChatTokenBudgetState.WARNING : EmbeddedChatTokenBudgetState.OK;
}
}
app/MindWork AI Studio/Assistants/BeyondFactsLab/BflTokenBudgetState.cs → app/MindWork AI Studio/Chat/Embedded/EmbeddedChatTokenBudgetState.cs
+5 -5
View File
@@ -1,9 +1,9 @@
namespace AIStudio.Assistants.BeyondFactsLab;
namespace AIStudio.Chat.Embedded;
/// <summary>
/// How much room a chat of the BeyondFacts Lab has left in the context of its model.
/// How much room an embedded chat has left in the context of its model.
/// </summary>
public enum BflTokenBudgetState
public enum EmbeddedChatTokenBudgetState
{
/// <summary>
/// Nobody knows: the count failed, or the model has no statement about its context.
@@ -16,12 +16,12 @@ public enum BflTokenBudgetState
OK,
/// <summary>
/// Most of the context is used; the person should think about starting over.
/// Most of the context is used; the user should think about starting over.
/// </summary>
WARNING,
/// <summary>
/// The next message and its answer would not fit anymore, so the lab sends no more.
/// The next message and its answer would not fit anymore, so the chat sends no more.
/// </summary>
FULL,
}
app/MindWork AI Studio/Chat/Embedded/IEmbeddedChatStore.cs
+7
View File
@@ -25,4 +25,11 @@ public interface IEmbeddedChatStore
/// <param name="token">The cancellation token.</param>
/// <exception cref="FileNotFoundException">What the chat belonged to was deleted meanwhile; nothing is left to store.</exception>
public Task SaveThreadAsync(ChatThread thread, CancellationToken token = default);
/// <summary>
/// Deletes a chat, so that its conversation starts over, also one which this version cannot open.
/// </summary>
/// <param name="chatId">The ID of the chat.</param>
/// <param name="token">The cancellation token.</param>
public Task DeleteThreadAsync(Guid chatId, CancellationToken token = default);
}
app/MindWork AI Studio/Components/EmbeddedChat.razor
+29 -1
View File
@@ -1,15 +1,30 @@
@using AIStudio.Chat
@using AIStudio.Chat.Embedded
@inherits MSGComponentBase
@if (!string.IsNullOrWhiteSpace(this.Heading))
{
<MudText Typo="Typo.h6" Class="mt-6 mb-2">@this.Heading</MudText>
}
@if (this.conversation is null)
{
<MudProgressLinear Color="Color.Primary" Indeterminate="true" Class="mb-3"/>
}
else if (this.conversation.Thread is not { } thread)
{
@if (this.CanReset)
{
<MudAlert Severity="Severity.Error" Variant="Variant.Outlined" Class="mb-3">
@TA("AI Studio cannot open this conversation. Its file may be damaged, or a newer version of AI Studio stored it. You can start the conversation over, which deletes it.")
</MudAlert>
<MudButton StartIcon="@AppIcons.RESET" Color="Color.Error" OnClick="@this.ResetAsync">@T("Start over")</MudButton>
}
else
{
<MudAlert Severity="Severity.Error" Variant="Variant.Outlined" Class="mb-3">
@T("AI Studio cannot open this conversation. Its file may be damaged, or a newer version of AI Studio stored it.")
</MudAlert>
}
}
else
{
@@ -18,6 +33,15 @@ else
<MudText Typo="Typo.body2" Class="mb-3">@this.Introduction</MudText>
}
@if (!this.IsReadOnly && EmbeddedChatOpening.OffersStart(this.StartRequest, this.conversation))
{
<div class="mb-4">
<MudButton Variant="Variant.Filled" Color="Color.Primary" StartIcon="@AppIcons.CHAT" OnClick="@this.StartAsync" Disabled="@(!this.CanSend)">
@T("Start the conversation")
</MudButton>
</div>
}
@foreach (var block in thread.Blocks)
{
@if (block is { HideFromUser: false, Content: not null })
@@ -50,7 +74,7 @@ else
OnKeyUp="@this.InputKeyEventAsync"
UserAttributes="@this.inputAttributes"
HelperText="@this.TokenText"
Class="mt-2"
Class="@this.InputClass"
Disabled="@(!this.CanSend)"/>
<MudStack Row="true" AlignItems="AlignItems.Center" Spacing="1" Class="mt-2">
@@ -62,6 +86,10 @@ else
{
<MudButton Variant="Variant.Filled" Color="Color.Error" StartIcon="@AppIcons.STOP" OnClick="@this.CancelAsync">@T("Stop")</MudButton>
}
@if (this.CanReset && this.conversation.HasVisibleMessages)
{
<MudButton StartIcon="@AppIcons.RESET" OnClick="@this.ResetAsync" Disabled="@this.IsRunning">@T("Start over")</MudButton>
}
</MudStack>
}
}
app/MindWork AI Studio/Components/EmbeddedChat.razor.cs
+183 -12
View File
@@ -1,5 +1,6 @@
using AIStudio.Chat;
using AIStudio.Chat.Embedded;
using AIStudio.Dialogs;
using AIStudio.Provider;
using AIStudio.Settings.DataModel;
using AIStudio.Tools.Rust;
@@ -8,6 +9,8 @@ using AIStudio.Tools.Services;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web;
using DialogOptions = AIStudio.Dialogs.DialogOptions;
namespace AIStudio.Components;
/// <summary>
@@ -18,7 +21,8 @@ namespace AIStudio.Components;
/// The chat itself lives in EmbeddedChatService, so an answer goes on while the user looks elsewhere; this component
/// shows it and renders whenever the service says it changed. What a request carries beside the conversation, such as
/// the system prompt and the tools, the assistant decides through PrepareAsync. The count of tokens leaves out the
/// context window of the model on purpose: it would tell models apart which the user compares without knowing them.
/// context window of the model by default: it would tell models apart which the user compares without knowing them.
/// An assistant whose requests carry long instructions shows it, see ShowsContextWindow.
/// </remarks>
public partial class EmbeddedChat : MSGComponentBase
{
@@ -56,7 +60,7 @@ public partial class EmbeddedChat : MSGComponentBase
/// Gets or sets how a request is readied before the message goes in, see EmbeddedChatRequest.PrepareAsync.
/// </summary>
[Parameter]
public Func<ChatThread, Task<bool>> PrepareAsync { get; set; } = _ => Task.FromResult(true);
public Func<ChatThread, Task<EmbeddedChatPreparation>> PrepareAsync { get; set; } = _ => Task.FromResult(EmbeddedChatPreparation.READY);
/// <summary>
/// Gets or sets whether messages to the user leave out which provider and which model answer.
@@ -70,6 +74,47 @@ public partial class EmbeddedChat : MSGComponentBase
[Parameter]
public bool IsReadOnly { get; set; }
/// <summary>
/// Gets or sets whether the user may start the conversation over, which deletes it. A chat which this version cannot
/// open then offers that as well.
/// </summary>
[Parameter]
public bool AllowsReset { get; set; }
/// <summary>
/// Gets or sets the question before the conversation starts over, e.g., which names what stays as it is; a general
/// question when left out.
/// </summary>
[Parameter]
public string? ResetQuestion { get; set; }
/// <summary>
/// Gets or sets whether the count of tokens shows how much of the context window of the model the conversation
/// fills: it warns when most of it is used, and the chat sends no more when the next message and its answer would
/// not fit anymore, see EmbeddedChatTokenBudget. Leave it out where the user must not tell the models apart.
/// </summary>
[Parameter]
public bool ShowsContextWindow { get; set; }
/// <summary>
/// Gets or sets how the count of tokens gets the system prompt of the next request, for an assistant which puts it
/// together anew for every request in PrepareAsync; null as its result means it cannot be known now, and the count
/// stays unknown. Without it, the count takes the system prompt the chat stores, which is the one of its last
/// request.
/// </summary>
/// <remarks>
/// It must not fail: whatever goes wrong, sending reports anyway.
/// </remarks>
[Parameter]
public Func<Task<string?>>? SystemPromptForCountAsync { get; set; }
/// <summary>
/// Gets or sets a number which changes whenever what the next request carries beside the conversation changed,
/// e.g., material of the assistant in its system prompt; the chat counts its tokens again then.
/// </summary>
[Parameter]
public int ContextVersion { get; set; }
/// <summary>
/// Gets or sets whether the user may attach files to a message.
/// </summary>
@@ -94,6 +139,20 @@ public partial class EmbeddedChat : MSGComponentBase
[Parameter]
public ContentText? OpeningMessage { get; set; }
/// <summary>
/// Gets or sets a request which lets the model open the conversation, e.g., by asking for what it needs. While the
/// chat holds no message the user sees, it offers a button which sends the request; the user does not see the
/// request, and may write first instead. Leave OpeningMessage out with it.
/// </summary>
[Parameter]
public string? StartRequest { get; set; }
/// <summary>
/// Gets or sets a heading above the chat, or nothing where the place of the chat names it already.
/// </summary>
[Parameter]
public string? Heading { get; set; }
/// <summary>
/// Gets or sets why the provider cannot answer, or null when it can.
/// </summary>
@@ -118,14 +177,25 @@ public partial class EmbeddedChat : MSGComponentBase
[Inject]
private ConversationTokenCounter TokenCounter { get; init; } = null!;
[Inject]
private IDialogService DialogService { get; init; } = null!;
[Inject]
private ILogger<EmbeddedChat> Logger { get; init; } = null!;
/// <summary>
/// Ends a count when the component goes away.
/// </summary>
private readonly CancellationTokenSource countCancellation = new();
/// <summary>
/// The token of countCancellation, taken while the source still lives, see BflChat.
/// The token of countCancellation, taken while the source still lives.
/// </summary>
/// <remarks>
/// A count goes on after an await, when the component may have gone away meanwhile, e.g., because the user moved on
/// to another step of an assistant. The source is disposed by then and refuses to hand out its token; the token
/// taken before still tells that the count was cancelled.
/// </remarks>
private CancellationToken countToken;
/// <summary>
@@ -138,6 +208,12 @@ public partial class EmbeddedChat : MSGComponentBase
/// </summary>
private string countedProviderId = string.Empty;
/// <summary>
/// The version of what a request carries beside the conversation which the tokens were counted for, see
/// ContextVersion.
/// </summary>
private int countedContextVersion;
/// <summary>
/// The chat shown, or null while it loads.
/// </summary>
@@ -170,10 +246,14 @@ public partial class EmbeddedChat : MSGComponentBase
private bool IsRunning => this.conversation?.IsRunning ?? false;
private bool CanSend => this.conversation is { IsAvailable: true, IsRunning: false } && this.ProviderIssue is null;
private EmbeddedChatTokenBudgetState Budget => this.ShowsContextWindow ? EmbeddedChatTokenBudget.Of(this.tokens) : EmbeddedChatTokenBudgetState.UNKNOWN;
private bool CanSend => this.conversation is { IsAvailable: true, IsRunning: false } && this.ProviderIssue is null && this.Budget is not EmbeddedChatTokenBudgetState.FULL;
private bool CanSendMessage => this.CanSend && !string.IsNullOrWhiteSpace(this.userInput);
private bool CanReset => this.AllowsReset && !this.IsReadOnly;
#region Overrides of MSGComponentBase
protected override async Task OnInitializedAsync()
@@ -196,7 +276,7 @@ public partial class EmbeddedChat : MSGComponentBase
this.conversation = await this.ChatService.GetAsync(this.Store, this.Component, this.ChatId, this.CreateThread);
await this.RecountAsync();
}
else if (this.countedProviderId != this.Provider.Id)
else if (this.countedProviderId != this.Provider.Id || this.countedContextVersion != this.ContextVersion)
await this.RecountAsync();
// Not awaited: the answer arrives through ConversationChanged, and the parameters of the next render must not wait for it.
@@ -239,12 +319,14 @@ public partial class EmbeddedChat : MSGComponentBase
/// Counts what the conversation carries so far, while no answer runs.
/// </summary>
/// <remarks>
/// The system prompt counts as the chat stores it: what PrepareAsync adds for a request is not known before. The
/// count is therefore an estimate, and the message being written is left out.
/// The system prompt counts as SystemPromptForCountAsync gives it, otherwise as the chat stores it: what
/// PrepareAsync adds for a request is not known before then. The count is therefore an estimate, and the message
/// being written is left out.
/// </remarks>
private async Task RecountAsync()
{
this.countedProviderId = this.Provider.Id;
this.countedContextVersion = this.ContextVersion;
if (this.IsReadOnly || this.conversation is not { Thread: { } thread, IsRunning: false } || this.ProviderIssue is not null || this.Provider.UsedLLMProvider is LLMProviders.NONE)
{
this.tokens = ConversationTokens.UNAVAILABLE;
@@ -253,7 +335,14 @@ public partial class EmbeddedChat : MSGComponentBase
try
{
var parts = ConversationParts.Of(thread, thread.SystemPrompt, string.Empty, null, false, null);
var systemPrompt = this.SystemPromptForCountAsync is { } systemPromptForCountAsync ? await systemPromptForCountAsync() : thread.SystemPrompt;
if (systemPrompt is null)
{
this.tokens = ConversationTokens.UNAVAILABLE;
return;
}
var parts = ConversationParts.Of(thread, systemPrompt, string.Empty, null, false, null);
this.tokens = await this.TokenCounter.CountAsync(this.Provider, parts, thread.ReportedHistoryFor(this.Provider.Model), this.countToken);
}
catch (OperationCanceledException)
@@ -263,11 +352,58 @@ public partial class EmbeddedChat : MSGComponentBase
}
/// <summary>
/// Gets about how many tokens the conversation carries, or null when nothing could be counted.
/// Gets about how many tokens the conversation carries, with how full the context of the model is when the chat shows
/// it, or null when nothing could be counted.
/// </summary>
private string? TokenText => this.tokens.IsKnown
? string.Format(T("approx. {0} tokens"), TokenAmount.Format(this.tokens.Tokens, Tools.PluginSystem.I18N.I.Culture))
: null;
private string? TokenText
{
get
{
if (!this.tokens.IsKnown)
return null;
var culture = Tools.PluginSystem.I18N.I.Culture;
var counted = TokenAmount.Format(this.tokens.Tokens, culture);
if (!this.ShowsContextWindow)
return string.Format(T("approx. {0} tokens"), counted);
if (!this.tokens.Window.IsKnown)
return string.Format(T("approx. {0} tokens; the context window of this model is unknown"), counted);
var window = TokenAmount.Format(this.tokens.Window.DefaultTokens, culture);
var budget = string.Format(this.tokens.IsEstimate && !this.tokens.HistoryIsReported ? T("approx. {0} of {1} tokens") : T("{0} of {1} tokens"), counted, window);
return this.Budget switch
{
EmbeddedChatTokenBudgetState.FULL => $"{budget}. {this.FullContextText}",
EmbeddedChatTokenBudgetState.WARNING => $"{budget}. {this.NearlyFullContextText}",
_ => budget
};
}
}
/// <summary>
/// Gets what the user can do once the conversation fills the context of the model.
/// </summary>
private string FullContextText => this.CanReset
? TA("This conversation fills the context window of the model. Start it over, or choose a provider whose model reads more at once.")
: TA("This conversation fills the context window of the model. Choose a provider whose model reads more at once.");
/// <summary>
/// Gets the warning once the conversation fills most of the context of the model.
/// </summary>
private string NearlyFullContextText => this.CanReset
? TA("This conversation fills most of the context window of the model. Soon, you will have to start it over.")
: T("This conversation fills most of the context window of the model.");
/// <summary>
/// Gets the classes of the message field; like on the chat page, they colour its helper text with the tokens.
/// </summary>
private string InputClass => this.Budget switch
{
EmbeddedChatTokenBudgetState.FULL => "mt-2 token-budget-exceeded",
EmbeddedChatTokenBudgetState.WARNING => "mt-2 token-budget-nearly-full",
_ => "mt-2"
};
private Task AttachmentsChanged(HashSet<FileAttachment> changedAttachments)
{
@@ -289,6 +425,15 @@ public partial class EmbeddedChat : MSGComponentBase
await this.ChatService.SendAsync(this.ChatId, this.RequestOf(message));
}
/// <summary>
/// Lets the model open the conversation, see StartRequest.
/// </summary>
private async Task StartAsync()
{
if (this.CanSend && !string.IsNullOrWhiteSpace(this.StartRequest))
await this.ChatService.SendAsync(this.ChatId, this.RequestOf(new ContentText { Text = this.StartRequest }) with { IsHidden = true });
}
/// <summary>
/// Sends the opening message. When it cannot be sent, e.g., because the provider may not answer, the message waits
/// in the field instead, so that the user can send it once the reason is gone.
@@ -333,4 +478,30 @@ public partial class EmbeddedChat : MSGComponentBase
/// Stops the answer the model writes.
/// </summary>
private Task CancelAsync() => this.ChatService.CancelAsync(this.ChatId);
/// <summary>
/// Deletes the conversation after asking, so that it starts over.
/// </summary>
private async Task ResetAsync()
{
var parameters = new DialogParameters<ConfirmDialog>
{
{ dialog => dialog.Message, this.ResetQuestion ?? TA("Delete this conversation and start it over?") }
};
var reference = await this.DialogService.ShowAsync<ConfirmDialog>(T("Start over"), parameters, DialogOptions.FULLSCREEN);
var result = await reference.Result;
if (result is null || result.Canceled)
return;
try
{
await this.ChatService.ResetAsync(this.ChatId, this.CreateThread);
}
catch (Exception exception) when (exception is IOException or UnauthorizedAccessException)
{
this.Logger.LogError(exception, "Could not delete the embedded chat '{ChatId}'.", this.ChatId);
await this.MessageBus.SendError(new(AppIcons.DELETE, TA("AI Studio could not delete this conversation. Please try again.")));
}
}
}
app/Tests/BeyondFactsLab/BflChatRequestTests.cs
+165
View File
@@ -0,0 +1,165 @@
using AIStudio.Assistants.BeyondFactsLab;
using AIStudio.Chat;
using AIStudio.Chat.Embedded;
using AIStudio.Provider;
using AIStudio.Settings;
using AIStudio.Settings.DataModel;
using AIStudio.Tools;
using AIStudio.Tools.AssistantSessions;
using AIStudio.Tools.ToolCallingSystem;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging.Abstractions;
namespace AIStudio.Tests.BeyondFactsLab;
/// <summary>
/// Checks what a request of a chat of the BeyondFacts Lab carries when it runs in the embedded chat, without asking any
/// provider.
/// </summary>
[TestFixture]
public sealed class BflChatRequestTests
{
private const AIStudio.Tools.Components LAB = AIStudio.Tools.Components.BEYOND_FACTS_LAB_ASSISTANT;
private const string SYSTEM_PROMPT = "Der Prompt des Schritts.";
private string dataDirectory = string.Empty;
private SettingsManager settingsManager = null!;
private ServiceProvider serviceProvider = null!;
private IServiceProvider previousServiceProvider = null!;
private AIStudio.Settings.Provider provider = null!;
[SetUp]
public void CreateSettings()
{
this.dataDirectory = Path.Combine(Path.GetTempPath(), $"ai-studio-beyondfacts-lab-chat-requests-{Guid.NewGuid():N}");
Directory.CreateDirectory(this.dataDirectory);
// The scheme which trusts Europe gives Mistral MEDIUM, the floor of the lab:
this.settingsManager = new SettingsManager(NullLogger<SettingsManager>.Instance, null!);
this.settingsManager.ConfigurationData.Confidence.ConfidenceScheme = ConfidenceSchemes.TRUST_EUROPE;
this.previousServiceProvider = Program.SERVICE_PROVIDER;
this.serviceProvider = new ServiceCollection().AddSingleton(this.settingsManager).BuildServiceProvider();
Program.SERVICE_PROVIDER = this.serviceProvider;
this.provider = new AIStudio.Settings.Provider(1, Guid.NewGuid().ToString(), "Instance 1", LLMProviders.MISTRAL, new("test-model", null));
}
[TearDown]
public void RestoreApplicationState()
{
Program.SERVICE_PROVIDER = this.previousServiceProvider;
this.serviceProvider.Dispose();
if (Directory.Exists(this.dataDirectory))
Directory.Delete(this.dataDirectory, true);
}
[Test]
public async Task AStepAsksWithThePromptOfTheLabAndReadsOnlyWebPagesGivenToIt()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
var location = new BflStepThreadLocation(created.ProjectId, BflStep.FRAMEWORK);
ChatThread? sent = null;
var service = this.CreateService(thread => sent = thread);
await service.GetAsync(new BflChatStore(store, location), LAB, location.ChatId, () => BflThreadFactory.Create(location));
var isSent = await service.SendAsync(location.ChatId, this.Request(location, "Ich spreche auf einem Podium.", new(SYSTEM_PROMPT, [])));
using (Assert.EnterMultipleScope())
{
Assert.That(isSent, Is.True);
Assert.That(sent!.SystemPrompt, Is.EqualTo(SYSTEM_PROMPT));
Assert.That(sent.RuntimeSelectedToolIds, Is.EquivalentTo(new[] { ToolSelectionRules.READ_WEB_PAGE_TOOL_ID }));
Assert.That(sent.RuntimeToolsAreAssistantManaged, Is.True);
Assert.That(sent.RuntimeComponent, Is.EqualTo(LAB));
Assert.That(sent.DataSourceOptions.DisableDataSources, Is.True);
Assert.That(sent.RequiredOutboundDataRestriction, Is.EqualTo(BflChatTools.STEP_REQUIREMENT));
Assert.That((await store.LoadThreadAsync(location))!.Blocks.Select(block => block.Role), Is.EqualTo(new[] { ChatRole.USER, ChatRole.AI }));
}
}
[Test]
public async Task TheOnboardingAsksWithoutTools()
{
var store = this.CreateStore();
var location = BflOnboardingThreadLocation.INSTANCE;
ChatThread? sent = null;
var service = this.CreateService(thread => sent = thread);
await service.GetAsync(new BflChatStore(store, location), LAB, location.ChatId, () => BflThreadFactory.Create(location));
await service.SendAsync(location.ChatId, this.Request(location, "Passt das Lab zu meinem Interview?", new(SYSTEM_PROMPT, [])));
using (Assert.EnterMultipleScope())
{
Assert.That(sent!.RuntimeSelectedToolIds, Is.Empty);
Assert.That(sent.RequiredOutboundDataRestriction, Is.EqualTo(OutboundDataRequirement.NONE));
Assert.That(File.Exists(Path.Combine(this.dataDirectory, BeyondFactsLabStore.ROOT_DIRECTORY_NAME, "onboarding", "thread.json")), Is.True);
}
}
[Test]
public async Task TheImagesOfTheMaterialGoAlongWithTheRequestOnly()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
var location = new BflStepThreadLocation(created.ProjectId, BflStep.KNOWLEDGE);
var image = new FileAttachmentImage("Poster.png", Path.Combine(this.dataDirectory, "poster-copy.png"), 1_024);
ChatThread? sent = null;
var service = this.CreateService(thread => sent = thread);
await service.GetAsync(new BflChatStore(store, location), LAB, location.ChatId, () => BflThreadFactory.Create(location));
await service.SendAsync(location.ChatId, this.Request(location, BflConversationService.OPENING_REQUEST, new(SYSTEM_PROMPT, [image]), isHidden: true));
var stored = await store.LoadThreadAsync(location);
var storedFile = await File.ReadAllTextAsync(Path.Combine(this.dataDirectory, BeyondFactsLabStore.ROOT_DIRECTORY_NAME, created.ProjectId.ToString("D"), "steps", BflStep.KNOWLEDGE.FolderName, "thread.json"));
using (Assert.EnterMultipleScope())
{
Assert.That(sent!.Blocks[0].Content!.FileAttachments, Is.EqualTo(new FileAttachment[] { image }), "The image goes along with the first message.");
Assert.That(stored!.Blocks[0].Content!.FileAttachments, Is.Empty, "The stored chat never holds an image.");
Assert.That(stored.Blocks[0].HideFromUser, Is.True);
Assert.That(storedFile, Does.Not.Contain("poster-copy.png"));
}
}
[Test]
public async Task AChatStoredBeforeTheLabOfferedToolsIsRestrictedBeforeItsRequest()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
var location = new BflStepThreadLocation(created.ProjectId, BflStep.STRATEGY);
await store.SaveThreadAsync(location, new ChatThread { ChatId = location.ChatId, Name = location.ChatName, Blocks = [] });
ChatThread? sent = null;
var service = this.CreateService(thread => sent = thread);
var conversation = await service.GetAsync(new BflChatStore(store, location), LAB, location.ChatId, () => BflThreadFactory.Create(location));
var restrictionBefore = conversation.Thread!.RequiredOutboundDataRestriction;
await service.SendAsync(location.ChatId, this.Request(location, "Wer sitzt mit auf dem Podium?", new(SYSTEM_PROMPT, [])));
using (Assert.EnterMultipleScope())
{
Assert.That(restrictionBefore, Is.EqualTo(OutboundDataRequirement.NONE));
Assert.That(sent!.RequiredOutboundDataRestriction, Is.EqualTo(BflChatTools.STEP_REQUIREMENT));
Assert.That((await store.LoadThreadAsync(location))!.RequiredOutboundDataRestriction, Is.EqualTo(BflChatTools.STEP_REQUIREMENT), "The chat stores the restriction.");
}
}
private EmbeddedChatRequest Request(BflThreadLocation location, string text, BflRequestMaterial requestMaterial, bool isHidden = false) => new()
{
Provider = this.provider,
Message = new ContentText { Text = text },
IsHidden = isHidden,
PrepareAsync = thread => Task.FromResult(BflConversationService.Prepare(location, this.provider, thread, requestMaterial))
};
private EmbeddedChatService CreateService(Action<ChatThread> sent) => new(this.settingsManager, new AssistantSessionService(MessageBus.INSTANCE), MessageBus.INSTANCE, NullLogger<EmbeddedChatService>.Instance, (_, answer, thread, _) =>
{
sent(thread);
answer.Text = "Worum geht es Ihnen?";
return Task.CompletedTask;
});
private BeyondFactsLabStore CreateStore() => new(NullLogger<BeyondFactsLabStore>.Instance, new BflStorageOptions { DataDirectory = this.dataDirectory });
}
app/Tests/BeyondFactsLab/BflChatStoreTests.cs
+147
View File
@@ -0,0 +1,147 @@
using AIStudio.Assistants.BeyondFactsLab;
using AIStudio.Chat;
using AIStudio.Chat.Embedded;
using AIStudio.Settings;
using AIStudio.Tools;
using AIStudio.Tools.AssistantSessions;
using Microsoft.Extensions.Logging.Abstractions;
namespace AIStudio.Tests.BeyondFactsLab;
/// <summary>
/// Checks that the embedded chats of the BeyondFacts Lab live where the lab keeps its chats, so that every chat stored
/// before stays readable.
/// </summary>
[TestFixture]
public sealed class BflChatStoreTests
{
private string dataDirectory = string.Empty;
private string RootDirectory => Path.Combine(this.dataDirectory, BeyondFactsLabStore.ROOT_DIRECTORY_NAME);
[SetUp]
public void CreateDataDirectory()
{
this.dataDirectory = Path.Combine(Path.GetTempPath(), $"ai-studio-beyondfacts-lab-chat-store-{Guid.NewGuid():N}");
Directory.CreateDirectory(this.dataDirectory);
}
[TearDown]
public void DeleteDataDirectory()
{
if (Directory.Exists(this.dataDirectory))
Directory.Delete(this.dataDirectory, true);
}
[Test]
public async Task AChatStoredBeforeOpensInTheEmbeddedChatWithAllItsMessages()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
var location = new BflStepThreadLocation(created.ProjectId, BflStep.KNOWLEDGE);
var thread = BflThreadFactory.Create(location);
AddMessage(thread, ChatRole.USER, BflConversationService.OPENING_REQUEST, isHidden: true);
AddMessage(thread, ChatRole.AI, "Worauf beruht Ihre Expertise?", isHidden: false);
await store.SaveThreadAsync(location, thread);
var conversation = await CreateService().GetAsync(new BflChatStore(this.CreateStore(), location), AIStudio.Tools.Components.BEYOND_FACTS_LAB_ASSISTANT, location.ChatId, () => BflThreadFactory.Create(location));
using (Assert.EnterMultipleScope())
{
Assert.That(conversation.IsAvailable, Is.True);
Assert.That(conversation.Thread!.ChatId, Is.EqualTo(location.ChatId));
Assert.That(conversation.Thread.Blocks.Select(block => block.HideFromUser), Is.EqualTo(new[] { true, false }), "The hidden request stays hidden.");
Assert.That(conversation.UserMessageCount, Is.Zero);
Assert.That(conversation.Thread.RequiredOutboundDataRestriction, Is.EqualTo(BflChatTools.STEP_REQUIREMENT), "The chat keeps the restriction of its step.");
}
}
[Test]
public async Task AChatOfAStepIsStoredInTheFolderOfTheStep()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
var location = new BflStepThreadLocation(created.ProjectId, BflStep.STRATEGY);
var thread = BflThreadFactory.Create(location);
AddMessage(thread, ChatRole.USER, "Wer sitzt mit auf dem Podium?", isHidden: false);
await new BflChatStore(store, location).SaveThreadAsync(thread);
using (Assert.EnterMultipleScope())
{
Assert.That(File.Exists(Path.Combine(this.RootDirectory, created.ProjectId.ToString("D"), "steps", BflStep.STRATEGY.FolderName, "thread.json")), Is.True);
Assert.That((await store.LoadThreadAsync(location))!.Blocks, Has.Count.EqualTo(1));
Assert.That(store.ReadAllThreadLocations(), Does.ContainKey(location.ChatId), "The cleanup of the provenance store finds the chat.");
}
}
[Test]
public async Task TheOnboardingIsStoredInItsOwnFolder()
{
var store = this.CreateStore();
var location = BflOnboardingThreadLocation.INSTANCE;
var thread = BflThreadFactory.Create(location);
AddMessage(thread, ChatRole.USER, "Passt das Lab zu meinem Interview?", isHidden: false);
await new BflChatStore(store, location).SaveThreadAsync(thread);
using (Assert.EnterMultipleScope())
{
Assert.That(File.Exists(Path.Combine(this.RootDirectory, "onboarding", "thread.json")), Is.True);
Assert.That(store.ReadAllThreadLocations(), Does.ContainKey(location.ChatId));
}
}
[Test]
public async Task AChatOfAnotherPlaceIsRefused()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
var chatStore = new BflChatStore(store, new BflStepThreadLocation(created.ProjectId, BflStep.FRAMEWORK));
var otherLocation = new BflStepThreadLocation(created.ProjectId, BflStep.STRATEGY);
using (Assert.EnterMultipleScope())
{
await Assert.ThrowsAsync<ArgumentException>(async () => await chatStore.LoadThreadAsync(otherLocation.ChatId));
await Assert.ThrowsAsync<ArgumentException>(async () => await chatStore.SaveThreadAsync(BflThreadFactory.Create(otherLocation)));
await Assert.ThrowsAsync<ArgumentException>(async () => await chatStore.DeleteThreadAsync(otherLocation.ChatId));
}
}
[Test]
public async Task StartingOverDeletesTheFileOfTheChat()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
var location = new BflStepThreadLocation(created.ProjectId, BflStep.FRAMEWORK);
var thread = BflThreadFactory.Create(location);
AddMessage(thread, ChatRole.USER, "Hallo", isHidden: false);
await store.SaveThreadAsync(location, thread);
var service = CreateService();
var conversation = await service.GetAsync(new BflChatStore(store, location), AIStudio.Tools.Components.BEYOND_FACTS_LAB_ASSISTANT, location.ChatId, () => BflThreadFactory.Create(location));
var reset = await service.ResetAsync(location.ChatId, () => BflThreadFactory.Create(location));
using (Assert.EnterMultipleScope())
{
Assert.That(reset, Is.True);
Assert.That(await store.LoadThreadAsync(location), Is.Null);
Assert.That(conversation.Thread!.Blocks, Is.Empty);
Assert.That(conversation.Thread.RequiredOutboundDataRestriction, Is.EqualTo(BflChatTools.STEP_REQUIREMENT), "The new conversation starts restricted as well.");
}
}
private static void AddMessage(ChatThread thread, ChatRole role, string text, bool isHidden) => thread.Blocks.Add(new ContentBlock
{
Time = DateTimeOffset.Now,
ContentType = ContentType.TEXT,
Role = role,
Content = new ContentText { Text = text },
HideFromUser = isHidden
});
private static EmbeddedChatService CreateService() => new(new SettingsManager(NullLogger<SettingsManager>.Instance, null!), new AssistantSessionService(MessageBus.INSTANCE), MessageBus.INSTANCE, NullLogger<EmbeddedChatService>.Instance, (_, _, _, _) => Task.CompletedTask);
private BeyondFactsLabStore CreateStore() => new(NullLogger<BeyondFactsLabStore>.Instance, new BflStorageOptions { DataDirectory = this.dataDirectory });
}
app/Tests/BeyondFactsLab/BflMaterialBudgetTests.cs
+3 -2
View File
@@ -1,4 +1,5 @@
using AIStudio.Assistants.BeyondFactsLab;
using AIStudio.Chat.Embedded;
using AIStudio.Models;
namespace AIStudio.Tests.BeyondFactsLab;
@@ -14,7 +15,7 @@ public sealed class BflMaterialBudgetTests
{
var characters = BflMaterialBudget.CharactersFor(ContextWindow.Of(128_000), 90_000);
Assert.That(characters, Is.EqualTo(((128_000 - BflTokenBudget.RESERVE_TOKENS) * 4 - 90_000) / 2));
Assert.That(characters, Is.EqualTo(((128_000 - EmbeddedChatTokenBudget.RESERVE_TOKENS) * 4 - 90_000) / 2));
}
[Test]
@@ -22,7 +23,7 @@ public sealed class BflMaterialBudgetTests
{
var characters = BflMaterialBudget.CharactersFor(ContextWindow.Of(128_000), 90_000, sentImages: 2);
Assert.That(characters, Is.EqualTo(((128_000 - BflTokenBudget.RESERVE_TOKENS - 2 * BflMaterialBudget.TOKENS_PER_IMAGE) * 4 - 90_000) / 2));
Assert.That(characters, Is.EqualTo(((128_000 - EmbeddedChatTokenBudget.RESERVE_TOKENS - 2 * BflMaterialBudget.TOKENS_PER_IMAGE) * 4 - 90_000) / 2));
}
[Test]
app/Tests/BeyondFactsLab/BflPromptOverridesTests.cs
+1 -1
View File
@@ -198,7 +198,7 @@ public sealed class BflPromptOverridesTests
{
var settingsManager = new SettingsManager(NullLogger<SettingsManager>.Instance, null!);
var store = new BeyondFactsLabStore(NullLogger<BeyondFactsLabStore>.Instance, new BflStorageOptions { DataDirectory = this.directory });
var service = new BflConversationService(store, settingsManager, null!, null!, null!, NullLogger<BflConversationService>.Instance);
var service = new BflConversationService(store, null!, settingsManager, null!, null!, NullLogger<BflConversationService>.Instance);
await BflPromptOverrides.CopyBuiltInAsync(store.PromptOverridesDirectory);
settingsManager.ConfigurationData.BeyondFactsLab.AllowPromptOverrides = true;
app/Tests/BeyondFactsLab/BflTokenBudgetTests.cs
-49
View File
@@ -1,49 +0,0 @@
using AIStudio.Assistants.BeyondFactsLab;
using AIStudio.Chat;
using AIStudio.Models;
namespace AIStudio.Tests.BeyondFactsLab;
/// <summary>
/// Checks when the BeyondFacts Lab warns about a full context, and when it stops sending.
/// </summary>
[TestFixture]
public sealed class BflTokenBudgetTests
{
private const int WINDOW = 32_000;
[Test]
public void ACountWhichFailedTellsNothing()
{
Assert.That(BflTokenBudget.Of(ConversationTokens.UNAVAILABLE), Is.EqualTo(BflTokenBudgetState.UNKNOWN));
}
[Test]
public void AModelWithoutAStatementAboutItsWindowTellsNothing()
{
var tokens = new ConversationTokens { IsKnown = true, HistoryTokens = 500_000, Window = ContextWindow.UNKNOWN };
Assert.That(BflTokenBudget.Of(tokens), Is.EqualTo(BflTokenBudgetState.UNKNOWN), "The lab cannot know when such a model is full, so it never stops sending.");
}
[TestCase(0, BflTokenBudgetState.OK)]
[TestCase(25_599, BflTokenBudgetState.OK)]
[TestCase(25_600, BflTokenBudgetState.WARNING)]
[TestCase(WINDOW - BflTokenBudget.RESERVE_TOKENS, BflTokenBudgetState.WARNING)]
[TestCase(WINDOW - BflTokenBudget.RESERVE_TOKENS + 1, BflTokenBudgetState.FULL)]
[TestCase(WINDOW * 2, BflTokenBudgetState.FULL)]
public void TheShareOfTheWindowDecides(int historyTokens, BflTokenBudgetState expected)
{
var tokens = new ConversationTokens { IsKnown = true, HistoryTokens = historyTokens, Window = ContextWindow.Of(WINDOW) };
Assert.That(BflTokenBudget.Of(tokens), Is.EqualTo(expected));
}
[Test]
public void TheMessageBeingWrittenCountsAsWell()
{
var tokens = new ConversationTokens { IsKnown = true, HistoryTokens = 20_000, DraftTokens = 6_000, Window = ContextWindow.Of(WINDOW) };
Assert.That(BflTokenBudget.Of(tokens), Is.EqualTo(BflTokenBudgetState.WARNING));
}
}
app/Tests/Chat/Embedded/EmbeddedChatOpeningTests.cs
+54 -1
View File
@@ -4,13 +4,15 @@ using AIStudio.Chat.Embedded;
namespace AIStudio.Tests.Chat.Embedded;
/// <summary>
/// Checks when an embedded chat sends the message it opens with.
/// Checks when an embedded chat sends the message it opens with, and when it offers to let the model begin.
/// </summary>
[TestFixture]
public sealed class EmbeddedChatOpeningTests
{
private static readonly ContentText OPENING_MESSAGE = new() { Text = "What is new today?" };
private const string START_REQUEST = "Open the conversation with your first message.";
[Test]
public void AnEmptyChatSendsItsOpeningMessage()
{
@@ -61,6 +63,57 @@ public sealed class EmbeddedChatOpeningTests
Assert.That(EmbeddedChatOpening.SendsNow(OPENING_MESSAGE, conversation, wasSent: false), Is.False);
}
[Test]
public void AnEmptyChatOffersToBegin()
{
Assert.That(EmbeddedChatOpening.OffersStart(START_REQUEST, Conversation()), Is.True);
}
[Test]
public void AChatWithoutStartRequestOffersNothing()
{
using (Assert.EnterMultipleScope())
{
Assert.That(EmbeddedChatOpening.OffersStart(null, Conversation()), Is.False);
Assert.That(EmbeddedChatOpening.OffersStart(" ", Conversation()), Is.False);
}
}
[Test]
public void AChatWhoseConversationBeganOffersNothing()
{
var conversation = Conversation();
conversation.Thread!.Blocks.Add(new ContentBlock { Role = ChatRole.AI, ContentType = ContentType.TEXT, Content = new ContentText { Text = "Hello, what do you prepare?" } });
Assert.That(EmbeddedChatOpening.OffersStart(START_REQUEST, conversation), Is.False);
}
[Test]
public void AChatWithOnlyAHiddenRequestStillOffersToBegin()
{
// E.g., the model failed to answer the request which lets it begin:
var conversation = Conversation();
conversation.Thread!.Blocks.Add(new ContentBlock { Role = ChatRole.USER, ContentType = ContentType.TEXT, Content = new ContentText { Text = START_REQUEST }, HideFromUser = true });
Assert.That(EmbeddedChatOpening.OffersStart(START_REQUEST, conversation), Is.True);
}
[Test]
public void AChatWhichLoadsRunsOrCannotBeOpenedOffersNothing()
{
var running = Conversation();
running.IsRunning = true;
var unavailable = Conversation();
unavailable.Thread = null;
using (Assert.EnterMultipleScope())
{
Assert.That(EmbeddedChatOpening.OffersStart(START_REQUEST, null), Is.False);
Assert.That(EmbeddedChatOpening.OffersStart(START_REQUEST, running), Is.False);
Assert.That(EmbeddedChatOpening.OffersStart(START_REQUEST, unavailable), Is.False);
}
}
private static EmbeddedConversation Conversation() => new()
{
ChatId = Guid.NewGuid(),
app/Tests/Chat/Embedded/EmbeddedChatServiceTests.cs
+80 -2
View File
@@ -130,7 +130,7 @@ public sealed class EmbeddedChatServiceTests
var service = this.CreateService(Answer("An answer."));
var conversation = await service.GetAsync(store, COMPONENT, chatId, () => new ChatThread());
var sent = await service.SendAsync(chatId, this.Request("A question.") with { PrepareAsync = _ => Task.FromResult(false) });
var sent = await service.SendAsync(chatId, this.Request("A question.") with { PrepareAsync = _ => Task.FromResult(EmbeddedChatPreparation.REFUSED) });
using (Assert.EnterMultipleScope())
{
@@ -202,7 +202,8 @@ public sealed class EmbeddedChatServiceTests
await service.GetAsync(store, COMPONENT, chatId, () => new ChatThread());
var extraBlock = new ContentBlock { Role = ChatRole.USER, ContentType = ContentType.TEXT, Content = new ContentText { Text = "An image description." } };
await service.SendAsync(chatId, this.Request("A question.") with { ThreadForRequest = thread => thread with { Blocks = [extraBlock, .. thread.Blocks] } });
var preparation = EmbeddedChatPreparation.READY with { ThreadForRequest = thread => thread with { Blocks = [extraBlock, .. thread.Blocks] } };
await service.SendAsync(chatId, this.Request("A question.") with { PrepareAsync = _ => Task.FromResult(preparation) });
using (Assert.EnterMultipleScope())
{
@@ -228,6 +229,83 @@ public sealed class EmbeddedChatServiceTests
}
}
[Test]
public async Task StartingOverDeletesTheConversationAndKeepsTheIdOfTheChat()
{
var store = new InMemoryEmbeddedChatStore();
var chatId = Guid.NewGuid();
var service = this.CreateService(Answer("An answer."));
var conversation = await service.GetAsync(store, COMPONENT, chatId, () => new ChatThread());
await service.SendAsync(chatId, this.Request("A question."));
var reset = await service.ResetAsync(chatId, () => new ChatThread { Name = "Started over" });
using (Assert.EnterMultipleScope())
{
Assert.That(reset, Is.True);
Assert.That(store.IsStored(chatId), Is.False, "The stored conversation is gone.");
Assert.That(conversation.Thread!.Blocks, Is.Empty);
Assert.That(conversation.Thread.ChatId, Is.EqualTo(chatId));
Assert.That(conversation.Thread.Name, Is.EqualTo("Started over"), "The new conversation starts as a new chat does.");
}
}
[Test]
public async Task AConversationDoesNotStartOverWhileTheModelAnswers()
{
var store = new InMemoryEmbeddedChatStore();
var chatId = Guid.NewGuid();
var answering = new TaskCompletionSource();
var release = new TaskCompletionSource();
var service = this.CreateService(async (_, answer, _, _) =>
{
answering.SetResult();
await release.Task;
answer.Text = "An answer.";
});
var conversation = await service.GetAsync(store, COMPONENT, chatId, () => new ChatThread());
var sending = service.SendAsync(chatId, this.Request("A question."));
await answering.Task;
var reset = await service.ResetAsync(chatId, () => new ChatThread());
release.SetResult();
await sending;
using (Assert.EnterMultipleScope())
{
Assert.That(reset, Is.False);
Assert.That(conversation.Thread!.Blocks, Has.Count.EqualTo(2), "The question and its answer stay.");
Assert.That(store.IsStored(chatId), Is.True);
}
}
[Test]
public async Task AChatThisVersionCannotOpenBecomesAvailableWhenItStartsOver()
{
var store = new InMemoryEmbeddedChatStore { CannotOpen = true };
var chatId = Guid.NewGuid();
var service = this.CreateService(Answer("An answer."));
var conversation = await service.GetAsync(store, COMPONENT, chatId, () => new ChatThread());
var wasAvailable = conversation.IsAvailable;
var reset = await service.ResetAsync(chatId, () => new ChatThread());
using (Assert.EnterMultipleScope())
{
Assert.That(wasAvailable, Is.False);
Assert.That(reset, Is.True);
Assert.That(conversation.IsAvailable, Is.True);
}
}
[Test]
public async Task AChatWhichWasNeverLoadedDoesNotStartOver()
{
var service = this.CreateService(Answer("An answer."));
Assert.That(await service.ResetAsync(Guid.NewGuid(), () => new ChatThread()), Is.False);
}
private EmbeddedChatService CreateService(Func<EmbeddedChatRequest, ContentText, ChatThread, CancellationToken, Task> answerAsync) => new(this.settingsManager, new AssistantSessionService(MessageBus.INSTANCE), MessageBus.INSTANCE, NullLogger<EmbeddedChatService>.Instance, answerAsync);
private EmbeddedChatRequest Request(string text) => new() { Provider = this.provider, Message = new ContentText { Text = text } };
app/Tests/Chat/Embedded/EmbeddedChatTokenBudgetTests.cs
+49
View File
@@ -0,0 +1,49 @@
using AIStudio.Chat;
using AIStudio.Chat.Embedded;
using AIStudio.Models;
namespace AIStudio.Tests.Chat.Embedded;
/// <summary>
/// Checks when an embedded chat which shows the context window warns about a full context, and when it stops sending.
/// </summary>
[TestFixture]
public sealed class EmbeddedChatTokenBudgetTests
{
private const int WINDOW = 32_000;
[Test]
public void ACountWhichFailedTellsNothing()
{
Assert.That(EmbeddedChatTokenBudget.Of(ConversationTokens.UNAVAILABLE), Is.EqualTo(EmbeddedChatTokenBudgetState.UNKNOWN));
}
[Test]
public void AModelWithoutAStatementAboutItsWindowTellsNothing()
{
var tokens = new ConversationTokens { IsKnown = true, HistoryTokens = 500_000, Window = ContextWindow.UNKNOWN };
Assert.That(EmbeddedChatTokenBudget.Of(tokens), Is.EqualTo(EmbeddedChatTokenBudgetState.UNKNOWN), "The chat cannot know when such a model is full, so it never stops sending.");
}
[TestCase(0, EmbeddedChatTokenBudgetState.OK)]
[TestCase(25_599, EmbeddedChatTokenBudgetState.OK)]
[TestCase(25_600, EmbeddedChatTokenBudgetState.WARNING)]
[TestCase(WINDOW - EmbeddedChatTokenBudget.RESERVE_TOKENS, EmbeddedChatTokenBudgetState.WARNING)]
[TestCase(WINDOW - EmbeddedChatTokenBudget.RESERVE_TOKENS + 1, EmbeddedChatTokenBudgetState.FULL)]
[TestCase(WINDOW * 2, EmbeddedChatTokenBudgetState.FULL)]
public void TheShareOfTheWindowDecides(int historyTokens, EmbeddedChatTokenBudgetState expected)
{
var tokens = new ConversationTokens { IsKnown = true, HistoryTokens = historyTokens, Window = ContextWindow.Of(WINDOW) };
Assert.That(EmbeddedChatTokenBudget.Of(tokens), Is.EqualTo(expected));
}
[Test]
public void TheMessageBeingWrittenCountsAsWell()
{
var tokens = new ConversationTokens { IsKnown = true, HistoryTokens = 20_000, DraftTokens = 6_000, Window = ContextWindow.Of(WINDOW) };
Assert.That(EmbeddedChatTokenBudget.Of(tokens), Is.EqualTo(EmbeddedChatTokenBudgetState.WARNING));
}
}
app/Tests/Chat/Embedded/InMemoryEmbeddedChatStore.cs
+13
View File
@@ -26,6 +26,12 @@ public sealed class InMemoryEmbeddedChatStore : IEmbeddedChatStore
/// <param name="chatId">The ID of the chat.</param>
public IReadOnlyList<ContentBlock> StoredBlocks(Guid chatId) => this.threads.TryGetValue(chatId, out var thread) ? thread.Blocks : [];
/// <summary>
/// Tells whether a chat is stored.
/// </summary>
/// <param name="chatId">The ID of the chat.</param>
public bool IsStored(Guid chatId) => this.threads.ContainsKey(chatId);
/// <inheritdoc />
public Task<ChatThread?> LoadThreadAsync(Guid chatId, CancellationToken token = default)
{
@@ -43,4 +49,11 @@ public sealed class InMemoryEmbeddedChatStore : IEmbeddedChatStore
this.SaveCount++;
return Task.CompletedTask;
}
/// <inheritdoc />
public Task DeleteThreadAsync(Guid chatId, CancellationToken token = default)
{
this.threads.Remove(chatId);
return Task.CompletedTask;
}
}