AI-Studio/app/MindWork AI Studio/Tools/ToolCallingSystem/ToolExecutionResult.cs

using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Json.Nodes;

using AIStudio.Provider;
using AIStudio.Settings.DataModel;
using AIStudio.Tools.RAG;

namespace AIStudio.Tools.ToolCallingSystem;

public sealed class ToolExecutionResult
{
    /// <summary>
    /// How a JSON result is written for the model.
    /// </summary>
    /// <remarks>
    /// The result goes into the request as a string, and the request is serialized once more on its
    /// way to the provider, so the model reads whatever this escapes as the escape itself. The
    /// default encoder escapes every character outside ASCII and those HTML treats specially, for
    /// JSON embedded in a web page, which this never is: a German document would reach the model
    /// with every umlaut as six characters. The relaxed encoder escapes only what JSON requires.
    /// </remarks>
    // Internal, so a tool which keeps its result within a budget measures exactly what the model gets:
    internal static readonly JsonSerializerOptions MODEL_CONTENT_OPTIONS = new() { Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping };

    public string? TextContent { get; init; }

    public JsonNode? JsonContent { get; init; }

    public IReadOnlyList<Source> Sources { get; init; } = [];

    /// <summary>
    /// The passages of the sources, exactly as the model reads them in this result.
    /// </summary>
    /// <remarks>
    /// The result itself is not stored with the chat, see ToolInvocationTrace.Result. The passages
    /// are, so the user can still read what the answer rests on after the chat was reloaded. A
    /// passage belongs to one of the Sources, see SourcePassageExtensions.GetPassagesOf.
    /// </remarks>
    public IReadOnlyList<SourcePassage> Passages { get; init; } = [];

    public ConfidenceLevel RequiredProviderConfidence { get; init; } = ConfidenceLevel.NONE;

    /// <summary>
    /// The data security the chat has to keep from now on, because of what this result brings in.
    /// </summary>
    /// <remarks>
    /// The other axis next to RequiredProviderConfidence. A data source which may only be used with
    /// self-hosted providers says so here, and the chat then refuses every other provider from now
    /// on, see ChatThread.RequireDataSecurity. Left at NOT_SPECIFIED, the result says nothing about
    /// it, and the chat stays as it was.
    /// </remarks>
    public DataSourceSecurity RequiredDataSecurity { get; init; } = DataSourceSecurity.NOT_SPECIFIED;

    /// <summary>
    /// Where the chat may still send data from now on, because of what this result brings in.
    /// </summary>
    /// <remarks>
    /// A tool which returns mail content sets the restriction of the mailbox it came from, and the
    /// strictest one when several mailboxes contributed. The chat then keeps it, see
    /// ChatThread.RequireOutboundDataRestriction. Left at NONE, the result says nothing about it,
    /// and the chat stays as it was.
    /// </remarks>
    public OutboundDataRequirement RequiredOutboundDataRestriction { get; init; } = OutboundDataRequirement.NONE;

    public string ToModelContent()
    {
        if (this.JsonContent is not null)
            return this.JsonContent.ToJsonString(MODEL_CONTENT_OPTIONS);

        return this.TextContent ?? string.Empty;
    }
}