MindWorkAI/AI-Studio
1
0 Fork 0
mirror of https://github.com/MindWorkAI/AI-Studio.git synced 2026-10-06 04:49:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Share the readers that refuse wrong tool arguments

Browse Source
This commit is contained in:
Thorsten Sommer committed 2026-09-24 16:40:01 +02:00
1 parent a75ffc54a6
commit 5f958367b0
5 files changed
+295 -92
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

app/MindWork AI Studio/Tools/ToolCallingSystem/ToolCallingImplementations/ReadWebPageTool.cs
+1 -13
View File
@@ -129,7 +129,7 @@ public sealed class ReadWebPageTool(WebPageRetrievalService webPageRetrievalServ
public async Task<ToolExecutionResult> ExecuteAsync(JsonElement arguments, ToolExecutionContext context, CancellationToken token = default)
{
var urlText = ReadRequiredString(arguments, URL_ARGUMENT);
var urlText = ToolArgumentReader.ReadRequiredString(arguments, URL_ARGUMENT);
if (!Uri.TryCreate(urlText, UriKind.Absolute, out var url) || url is not { Scheme: "http" or "https" })
throw new ArgumentException("Argument 'url' must be a valid HTTP or HTTPS URL.");
@@ -337,18 +337,6 @@ public sealed class ReadWebPageTool(WebPageRetrievalService webPageRetrievalServ
.Split(['\r', '\n', ',', ';'], StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
.Where(x => !string.IsNullOrWhiteSpace(x)) ?? [];
private static string ReadRequiredString(JsonElement arguments, string propertyName)
{
if (!arguments.TryGetProperty(propertyName, out var value) || value.ValueKind is not JsonValueKind.String)
throw new ArgumentException($"Missing required argument '{propertyName}'.");
var text = value.GetString()?.Trim() ?? string.Empty;
if (string.IsNullOrWhiteSpace(text))
throw new ArgumentException($"Missing required argument '{propertyName}'.");
return text;
}
private static string FormatUrlForLog(Uri url)
{
var builder = new UriBuilder(url)
app/MindWork AI Studio/Tools/ToolCallingSystem/ToolCallingImplementations/WebSearch/WebSearchTool.cs
+5 -78
View File
@@ -111,11 +111,6 @@ public sealed class WebSearchTool(IEnumerable<IWebSearchBackend> backends, WebPa
/// </remarks>
private static readonly string[] TIME_RANGES = [TIME_RANGE_DAY, TIME_RANGE_WEEK, TIME_RANGE_MONTH, TIME_RANGE_YEAR];
/// <summary>
/// How much of a wrongly passed argument an error message repeats back to the model.
/// </summary>
private const int MAX_ARGUMENT_ECHO_LENGTH = 40;
public string ImplementationKey => ToolSelectionRules.WEB_SEARCH_TOOL_ID;
/// <inheritdoc />
@@ -826,95 +821,27 @@ public sealed class WebSearchTool(IEnumerable<IWebSearchBackend> backends, WebPa
/// <summary>
/// Reads the search query, the one argument the model always has to pass.
/// </summary>
internal static string ReadQuery(JsonElement arguments)
{
var query = ReadOptionalString(arguments, QUERY_ARGUMENT, whenLeftOut: null);
if (string.IsNullOrWhiteSpace(query))
throw new ArgumentException($"Missing required argument '{QUERY_ARGUMENT}'.");
return query;
}
internal static string ReadQuery(JsonElement arguments) => ToolArgumentReader.ReadRequiredString(arguments, QUERY_ARGUMENT);
/// <summary>
/// Reads the language tag the model asked for, or null for the configured language.
/// </summary>
internal static string? ReadLanguage(JsonElement arguments) => ReadOptionalString(arguments, LANGUAGE_ARGUMENT, "to use the configured language");
internal static string? ReadLanguage(JsonElement arguments) => ToolArgumentReader.ReadOptionalString(arguments, LANGUAGE_ARGUMENT, "to use the configured language");
/// <summary>
/// Reads the time range the model asked for, or null for no restriction.
/// </summary>
internal static string? ReadTimeRange(JsonElement arguments)
{
if (!TryGetArgument(arguments, TIME_RANGE_ARGUMENT, out var value))
return null;
var timeRange = value.ValueKind is JsonValueKind.String ? value.GetString()?.Trim() : null;
if (timeRange is null || !TIME_RANGES.Contains(timeRange, StringComparer.Ordinal))
throw InvalidArgument(TIME_RANGE_ARGUMENT, value, $"one of {string.Join(", ", TIME_RANGES)}", "to search without a time restriction");
return timeRange;
}
internal static string? ReadTimeRange(JsonElement arguments) => ToolArgumentReader.ReadOptionalChoice(arguments, TIME_RANGE_ARGUMENT, TIME_RANGES, "to search without a time restriction");
/// <summary>
/// Reads the result page the model asked for, or null for the first one.
/// </summary>
internal static int? ReadPage(JsonElement arguments) => ReadOptionalPositiveInt(arguments, PAGE_ARGUMENT, "to get the first page");
internal static int? ReadPage(JsonElement arguments) => ToolArgumentReader.ReadOptionalPositiveInt(arguments, PAGE_ARGUMENT, "to get the first page");
/// <summary>
/// Reads how many results the model asked for, or null for the configured number.
/// </summary>
internal static int? ReadLimit(JsonElement arguments) => ReadOptionalPositiveInt(arguments, LIMIT_ARGUMENT, "to get as many results as configured");
/// <summary>
/// Looks up an argument, treating null the same as leaving it out.
/// </summary>
private static bool TryGetArgument(JsonElement arguments, string propertyName, out JsonElement value) =>
arguments.TryGetProperty(propertyName, out value) && value.ValueKind is not JsonValueKind.Null;
private static string? ReadOptionalString(JsonElement arguments, string propertyName, string? whenLeftOut)
{
if (!TryGetArgument(arguments, propertyName, out var value))
return null;
if (value.ValueKind is not JsonValueKind.String)
throw InvalidArgument(propertyName, value, "a string", whenLeftOut);
return value.GetString()?.Trim();
}
private static int? ReadOptionalPositiveInt(JsonElement arguments, string propertyName, string whenLeftOut)
{
if (!TryGetArgument(arguments, propertyName, out var value))
return null;
if (value.ValueKind is not JsonValueKind.Number || !value.TryGetInt32(out var intValue) || intValue <= 0)
throw InvalidArgument(propertyName, value, "a positive integer", whenLeftOut);
return intValue;
}
/// <summary>
/// Builds the error a model gets for an argument it passed wrongly.
/// </summary>
/// <remarks>
/// The model reads this and tries again, so it says what arrived, what would have been right,
/// and, for an optional argument, that leaving it out is always an option. A model which
/// believes the argument has to be there otherwise keeps trying placeholders, and every attempt
/// costs one of the tool calls an answer may make.
/// </remarks>
/// <param name="propertyName">The argument.</param>
/// <param name="value">What the model passed, as it arrived.</param>
/// <param name="expectation">What the argument must be, completing "must be ...".</param>
/// <param name="whenLeftOut">What happens without the argument, completing "Leave it out ...", or null for a required one.</param>
private static ArgumentException InvalidArgument(string propertyName, JsonElement value, string expectation, string? whenLeftOut)
{
var receivedValue = value.GetRawText();
if (receivedValue.Length > MAX_ARGUMENT_ECHO_LENGTH)
receivedValue = $"{receivedValue[..MAX_ARGUMENT_ECHO_LENGTH]}...";
var message = $"Argument '{propertyName}' must be {expectation}, but was {receivedValue}.";
return new ArgumentException(whenLeftOut is null ? message : $"{message} Leave it out {whenLeftOut}.");
}
internal static int? ReadLimit(JsonElement arguments) => ToolArgumentReader.ReadOptionalPositiveInt(arguments, LIMIT_ARGUMENT, "to get as many results as configured");
private static string FormatQueryForLog(string query)
{