diff --git a/InferenceWeb.Tests/ApiExceptionMiddlewareTests.cs b/InferenceWeb.Tests/ApiExceptionMiddlewareTests.cs
new file mode 100644
index 0000000..71487cc
--- /dev/null
+++ b/InferenceWeb.Tests/ApiExceptionMiddlewareTests.cs
@@ -0,0 +1,225 @@
+using System.Text;
+using System.Text.Json;
+using Microsoft.AspNetCore.Http;
+using TensorSharp.Server.Logging;
+
+namespace InferenceWeb.Tests;
+
+///
+/// No request may answer with a framework error page. Before this middleware
+/// existed, an exception escaping an endpoint hit the Developer Exception Page
+/// that WebApplication.CreateBuilder installs ahead of all application
+/// middleware, and a client sending Accept: text/html got the throwing
+/// file's verbatim source back — which is how issue #142 was reported, with the
+/// source of ToolFunctionParser.cs arriving in place of a completion. In
+/// Production the same request got a bodiless 500 instead.
+///
+public class ApiExceptionMiddlewareTests
+{
+ private static DefaultHttpContext ContextFor(string path)
+ {
+ var ctx = new DefaultHttpContext();
+ ctx.Request.Path = path;
+ ctx.Response.Body = new MemoryStream();
+ return ctx;
+ }
+
+ private static async Task BodyOf(HttpContext ctx)
+ {
+ ctx.Response.Body.Seek(0, SeekOrigin.Begin);
+ using var reader = new StreamReader(ctx.Response.Body, Encoding.UTF8);
+ return await reader.ReadToEndAsync();
+ }
+
+ ///
+ /// Raise the throw the reporter hit — a legal tool spec whose enum
+ /// holds integers, read by an accessor that only accepts strings — from
+ /// inside the pipeline, exactly as a request parser does. It has to be
+ /// thrown here rather than caught and re-thrown by value: throw ex;
+ /// resets TargetSite, which is how the middleware tells a caller's
+ /// unreadable body from a fault of the server's own.
+ ///
+ private static Task ThrowJsonKindMismatch()
+ {
+ using var doc = JsonDocument.Parse("""{"enum":[1,2,3]}""");
+ foreach (var v in doc.RootElement.GetProperty("enum").EnumerateArray())
+ _ = v.GetString();
+ throw new Xunit.Sdk.XunitException("GetString() on a Number was expected to throw.");
+ }
+
+ private static Exception JsonKindMismatch()
+ {
+ try
+ {
+ ThrowJsonKindMismatch().GetAwaiter().GetResult();
+ throw new Xunit.Sdk.XunitException("unreachable");
+ }
+ catch (InvalidOperationException ex)
+ {
+ return ex;
+ }
+ }
+
+ [Fact]
+ public async Task JsonKindMismatch_OnOpenAiRoute_Becomes400NotAnHtmlPage()
+ {
+ var ctx = ContextFor("/v1/chat/completions");
+
+ await ApiExceptionMiddleware.InvokeAsync(ctx, ThrowJsonKindMismatch);
+
+ Assert.Equal(400, ctx.Response.StatusCode);
+ string body = await BodyOf(ctx);
+ using var doc = JsonDocument.Parse(body);
+ var error = doc.RootElement.GetProperty("error");
+ Assert.Equal("invalid_request_error", error.GetProperty("type").GetString());
+ // The message describes the caller's own JSON, so it is safe to echo and
+ // is the only thing that tells them which value the server choked on.
+ Assert.Contains("Number", error.GetProperty("message").GetString());
+ Assert.DoesNotContain(" throw parseFailure);
+
+ Assert.Equal(400, ctx.Response.StatusCode);
+ using var doc = JsonDocument.Parse(await BodyOf(ctx));
+ Assert.Equal("invalid_request_error", doc.RootElement.GetProperty("error").GetProperty("type").GetString());
+ }
+
+ [Fact]
+ public async Task ServerFault_Becomes500AndLeaksNothingAboutTheException()
+ {
+ var ctx = ContextFor("/v1/chat/completions");
+ var fault = new NullReferenceException("Object reference not set — /home/dev/TensorSharp/Secret.cs:line 42");
+
+ await ApiExceptionMiddleware.InvokeAsync(ctx, () => throw fault);
+
+ Assert.Equal(500, ctx.Response.StatusCode);
+ string body = await BodyOf(ctx);
+ Assert.Equal("internal_error",
+ JsonDocument.Parse(body).RootElement.GetProperty("error").GetProperty("type").GetString());
+
+ // A server fault's detail belongs in the log, which RequestLoggingMiddleware
+ // has already written by the time the exception reaches here.
+ Assert.DoesNotContain("Secret.cs", body);
+ Assert.DoesNotContain("NullReferenceException", body);
+ Assert.DoesNotContain("Object reference", body);
+ }
+
+ [Fact]
+ public async Task OnOllamaOrWebUiRoute_UsesTheFlatErrorShape()
+ {
+ var ctx = ContextFor("/api/chat");
+
+ await ApiExceptionMiddleware.InvokeAsync(ctx, ThrowJsonKindMismatch);
+
+ Assert.Equal(400, ctx.Response.StatusCode);
+ using var doc = JsonDocument.Parse(await BodyOf(ctx));
+ Assert.Equal(JsonValueKind.String, doc.RootElement.GetProperty("error").ValueKind);
+ }
+
+ [Fact]
+ public async Task CorrelationIdSurvivesTheClearedResponse()
+ {
+ // RequestLoggingMiddleware sets this on the way in and documents it as
+ // present on every response; Response.Clear() would otherwise drop it
+ // from exactly the responses a user needs to quote.
+ var ctx = ContextFor("/v1/chat/completions");
+ ctx.Response.Headers[RequestLoggingMiddleware.RequestIdHeader] = "abc123";
+
+ await ApiExceptionMiddleware.InvokeAsync(ctx, ThrowJsonKindMismatch);
+
+ Assert.Equal("abc123", ctx.Response.Headers[RequestLoggingMiddleware.RequestIdHeader]);
+ }
+
+ [Fact]
+ public async Task AfterResponseStarted_TheExceptionPropagates()
+ {
+ // A streaming completion that fails mid-body has already committed its
+ // status line; dropping the connection is the only signal SSE has.
+ var ctx = ContextFor("/v1/chat/completions");
+ ctx.Features.Set(new StartedResponseFeature());
+
+ await Assert.ThrowsAsync(() =>
+ ApiExceptionMiddleware.InvokeAsync(ctx, () => throw new InvalidOperationException("mid-stream")));
+ }
+
+ [Fact]
+ public async Task ClientAbort_IsNotAnsweredAtAll()
+ {
+ // The caller hung up before the response started: there is no socket
+ // left to write an error body to, so the cancellation propagates rather
+ // than turning into a 500 nobody can read.
+ var ctx = ContextFor("/v1/chat/completions");
+ using var aborted = new CancellationTokenSource();
+ await aborted.CancelAsync();
+ ctx.RequestAborted = aborted.Token;
+
+ await Assert.ThrowsAnyAsync(() =>
+ ApiExceptionMiddleware.InvokeAsync(ctx, () => Task.FromCanceled(aborted.Token)));
+
+ Assert.Equal(200, ctx.Response.StatusCode);
+ Assert.Equal(string.Empty, await BodyOf(ctx));
+ }
+
+ [Fact]
+ public async Task CancellationThatIsNotAClientAbort_StillBecomesAnError()
+ {
+ // An internal timeout is a server fault, not a hang-up: the connection
+ // is alive and deserves an answer.
+ var ctx = ContextFor("/v1/chat/completions");
+ using var unrelated = new CancellationTokenSource();
+ await unrelated.CancelAsync();
+
+ await ApiExceptionMiddleware.InvokeAsync(ctx, () => Task.FromCanceled(unrelated.Token));
+
+ Assert.Equal(500, ctx.Response.StatusCode);
+ }
+
+ [Fact]
+ public async Task NoException_PassesThroughUntouched()
+ {
+ var ctx = ContextFor("/v1/chat/completions");
+ ctx.Response.StatusCode = 200;
+
+ await ApiExceptionMiddleware.InvokeAsync(ctx, () => Task.CompletedTask);
+
+ Assert.Equal(200, ctx.Response.StatusCode);
+ Assert.Equal(string.Empty, await BodyOf(ctx));
+ }
+
+ [Fact]
+ public void OnlyJsonReadFailuresCountAsAMalformedRequest()
+ {
+ Assert.True(ApiExceptionMiddleware.IsMalformedRequest(JsonKindMismatch()));
+ Assert.False(ApiExceptionMiddleware.IsMalformedRequest(new NullReferenceException()));
+ // An InvalidOperationException raised by our own code is a server fault,
+ // not a client one — only System.Text.Json's are attributed to the body.
+ Assert.False(ApiExceptionMiddleware.IsMalformedRequest(new InvalidOperationException("ours")));
+ }
+
+ private sealed class StartedResponseFeature : Microsoft.AspNetCore.Http.Features.IHttpResponseFeature
+ {
+ public int StatusCode { get; set; } = 200;
+ public string ReasonPhrase { get; set; }
+ public IHeaderDictionary Headers { get; set; } = new HeaderDictionary();
+ public Stream Body { get; set; } = new MemoryStream();
+ public bool HasStarted => true;
+ public void OnStarting(System.Func callback, object state) { }
+ public void OnCompleted(System.Func callback, object state) { }
+ }
+}
diff --git a/InferenceWeb.Tests/ToolFunctionParseTests.cs b/InferenceWeb.Tests/ToolFunctionParseTests.cs
index 77972c1..e7f5d24 100644
--- a/InferenceWeb.Tests/ToolFunctionParseTests.cs
+++ b/InferenceWeb.Tests/ToolFunctionParseTests.cs
@@ -122,6 +122,39 @@ public void ToolWithoutParametersIsStillUsable()
Assert.Empty(tools[0].Required);
}
+ ///
+ /// A tool's parameters is a JSON Schema document, so enum may
+ /// hold values of any type and type may be a union. Both reach the
+ /// model as prompt text, so the spelling matters: a boolean has to arrive as
+ /// JSON's true rather than .NET's True, and a nullable field
+ /// has to keep a type name the renderers recognise instead of degrading to
+ /// any. Same rule as the server's tool parser (issue #142).
+ ///
+ [Fact]
+ public void JsonSchemaValuesThatAreNotStringsKeepTheirJsonSpelling()
+ {
+ var tools = ToolFunction.ParseList("""
+ [{
+ "name": "configure",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "level": { "type": "integer", "enum": [0, 1, 2] },
+ "persist": { "type": "boolean", "enum": [true, false] },
+ "scope": { "type": ["string", "null"] },
+ "choice": { "type": "string", "enum": ["a", null] }
+ }
+ }
+ }]
+ """);
+
+ var fn = Assert.Single(tools);
+ Assert.Equal(new[] { "0", "1", "2" }, fn.Parameters["level"].Enum);
+ Assert.Equal(new[] { "true", "false" }, fn.Parameters["persist"].Enum);
+ Assert.Equal("string", fn.Parameters["scope"].Type);
+ Assert.Equal(new[] { "a", "null" }, fn.Parameters["choice"].Enum);
+ }
+
///
/// Every failure mode has to surface as a (or a
/// subclass of it, e.g. JsonReaderException) so the CLI's single catch turns
diff --git a/InferenceWeb.Tests/ToolFunctionParserBenchmark.cs b/InferenceWeb.Tests/ToolFunctionParserBenchmark.cs
new file mode 100644
index 0000000..e83d525
--- /dev/null
+++ b/InferenceWeb.Tests/ToolFunctionParserBenchmark.cs
@@ -0,0 +1,297 @@
+// Copyright (c) Zhongkai Fu. All rights reserved.
+// https://github.com/zhongkaifu/TensorSharp
+//
+// This file is part of TensorSharp.
+//
+// TensorSharp is licensed under the BSD-3-Clause license found in the LICENSE file in the root directory of this source tree.
+//
+// TensorSharp is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the BSD-3-Clause License for more details.
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using TensorSharp.Models;
+using TensorSharp.Server.RequestParsers;
+
+namespace InferenceWeb.Tests;
+
+///
+/// Micro-benchmark for . Implemented as XUnit
+/// Facts so it runs under dotnet test alongside the correctness suite;
+/// numbers are printed to stdout (look for the [ToolFunctionParser.*]
+/// banner). Needs no model, no GPU and no native init.
+///
+/// This sits on the synchronous prologue of every chat request that declares
+/// tools — OpenAIChatAdapter.ChatCompletionsAsync parses the spec before
+/// it takes a queue ticket — so an agent harness that re-sends its whole tool
+/// catalogue on every turn pays this cost per request, ahead of any inference.
+/// The corpus below is sized for that case: a catalogue the size of a real MCP
+/// server's, not a single toy tool.
+///
+///
+/// A/Bs the current
+/// kind-checked parser against , a verbatim copy
+/// of the pre-#142 implementation. That implementation threw on half the specs
+/// in this file, so the A/B runs on the all-strings corpus it could still handle
+/// — the only input on which the two are comparable — to show that reading
+/// before each access costs nothing.
+///
+///
+public class ToolFunctionParserBenchmark
+{
+ // A tool catalogue the size of a working agent harness: 12 tools x 6
+ // parameters, each parameter carrying a description and half of them an
+ // enum. ~14 KB of JSON, comparable to what a filesystem+shell+search MCP
+ // server advertises.
+ private const int ToolCount = 12;
+ private const int ParamsPerTool = 6;
+
+ private static readonly string StringOnlySpec = BuildSpec(mixedKinds: false);
+ private static readonly string MixedKindSpec = BuildSpec(mixedKinds: true);
+
+ // Both candidates are warmed before either is timed, and the rounds
+ // alternate between them, so neither is charged for tiered-JIT promotion or
+ // for a cold ArrayPool — measuring them one after the other made whichever
+ // ran first look ~3x slower than it is.
+ private const int Warmup = 500;
+ private const int Rounds = 6;
+ private const int ItersPerRound = 1000;
+
+ ///
+ /// One process-wide warm-up, run once before any measurement. .NET promotes
+ /// a method to its optimized tier on call count and elapsed time, so a
+ /// per-benchmark warm-up loop is not enough on its own: whichever benchmark
+ /// happened to run first still measured tier-0 code and read ~3.5x slower
+ /// than the very same parser did one call later.
+ ///
+ private static readonly bool Warmed = WarmUp();
+
+ private static bool WarmUp()
+ {
+ var sw = Stopwatch.StartNew();
+ while (sw.ElapsedMilliseconds < 750)
+ {
+ Run(StringOnlySpec, 20, ToolFunctionParser.ParseOpenAI);
+ Run(StringOnlySpec, 20, LegacyParseOpenAI);
+ Run(MixedKindSpec, 20, ToolFunctionParser.ParseOpenAI);
+ }
+ return true;
+ }
+
+ [Fact]
+ public void Parse_KindTolerantVersusLegacyStringOnlyParser()
+ {
+ Assert.True(Warmed);
+ Console.WriteLine($"[ToolFunctionParser] corpus: {ToolCount} tools x {ParamsPerTool} params, " +
+ $"{Encoding.UTF8.GetByteCount(StringOnlySpec) / 1024.0:F1} KB JSON, " +
+ $"{Rounds} rounds x {ItersPerRound} parses, best round reported");
+
+ var candidates = new (string Label, Func> Parse)[]
+ {
+ ("legacy (pre-#142, string-only)", LegacyParseOpenAI),
+ ("current (kind-checked)", ToolFunctionParser.ParseOpenAI),
+ };
+ double[] best = BenchAlternating(StringOnlySpec, candidates);
+
+ double legacy = best[0], current = best[1];
+ Console.WriteLine($"[ToolFunctionParser] current / legacy = {current / legacy:F3}x " +
+ $"({(legacy - current) / legacy * 100:+0.0;-0.0}% faster)");
+
+ // The A/B is only meaningful if both parsers saw the same catalogue.
+ using var doc = JsonDocument.Parse(StringOnlySpec);
+ Assert.Equal(ToolCount, ToolFunctionParser.ParseOpenAI(doc.RootElement).Count);
+ Assert.Equal(ToolCount, LegacyParseOpenAI(doc.RootElement).Count);
+ }
+
+ [Fact]
+ public void Parse_MixedKindSpec_IsNotAPathologicalCase()
+ {
+ Assert.True(Warmed);
+ Console.WriteLine($"[ToolFunctionParser] mixed-kind corpus: " +
+ $"{Encoding.UTF8.GetByteCount(MixedKindSpec) / 1024.0:F1} KB JSON " +
+ $"(integer/boolean enums, union types — the shapes that used to throw)");
+
+ // The same parser over both corpora: the kinds the legacy parser could
+ // not read must not cost materially more than the ones it could.
+ var candidates = new (string, Func>)[]
+ {
+ ("current (all strings)", ToolFunctionParser.ParseOpenAI),
+ };
+ double strings = BenchAlternating(StringOnlySpec, candidates)[0];
+ double mixed = BenchAlternating(MixedKindSpec,
+ [("current (mixed kinds)", ToolFunctionParser.ParseOpenAI)])[0];
+
+ Console.WriteLine($"[ToolFunctionParser] mixed / strings = {mixed / strings:F3}x");
+
+ using var doc = JsonDocument.Parse(MixedKindSpec);
+ var tools = ToolFunctionParser.ParseOpenAI(doc.RootElement);
+ Assert.Equal(ToolCount, tools.Count);
+ Assert.All(tools, t => Assert.Equal(ParamsPerTool, t.Parameters.Count));
+ }
+
+ ///
+ /// Time every candidate over the same corpus, reporting each one's fastest
+ /// round in microseconds per spec. Returns the results in candidate order.
+ ///
+ private static double[] BenchAlternating(
+ string json, (string Label, Func> Parse)[] candidates)
+ {
+ var best = new double[candidates.Length];
+ Array.Fill(best, double.MaxValue);
+ int checksum = 0;
+
+ foreach (var candidate in candidates)
+ checksum += Run(json, Warmup, candidate.Parse);
+
+ for (int round = 0; round < Rounds; round++)
+ {
+ for (int c = 0; c < candidates.Length; c++)
+ {
+ var sw = Stopwatch.StartNew();
+ checksum += Run(json, ItersPerRound, candidates[c].Parse);
+ sw.Stop();
+ best[c] = Math.Min(best[c], sw.Elapsed.TotalMilliseconds * 1000.0 / ItersPerRound);
+ }
+ }
+
+ for (int c = 0; c < candidates.Length; c++)
+ {
+ Console.WriteLine($"[ToolFunctionParser] {candidates[c].Label,-32} {best[c],8:F2} us/spec " +
+ $"{1_000_000.0 / best[c],10:N0} spec/s");
+ }
+ Console.WriteLine($"[ToolFunctionParser] (checksum {checksum})");
+ return best;
+ }
+
+ private static int Run(string json, int iters, Func> parse)
+ {
+ // Each iteration re-parses the document too, because that is what the
+ // request path actually does — timing the parser against a pre-parsed
+ // JsonDocument would measure a call that never happens in production.
+ int tools = 0;
+ for (int i = 0; i < iters; i++)
+ {
+ using var doc = JsonDocument.Parse(json);
+ tools += parse(doc.RootElement).Count;
+ }
+ return tools;
+ }
+
+ ///
+ /// The parser exactly as it stood before the issue #142 fix
+ /// (ToolFunctionParser.ParseOpenAI/ParseFunction at commit
+ /// b353392), kept only as the benchmark's baseline. It throws
+ /// on any tool spec that puts a
+ /// non-string where it expected one, so it can only be run on
+ /// .
+ ///
+ private static List LegacyParseOpenAI(JsonElement body)
+ {
+ if (!body.TryGetProperty("tools", out var toolsEl) || toolsEl.ValueKind != JsonValueKind.Array)
+ return null;
+
+ var tools = new List();
+ foreach (var toolEl in toolsEl.EnumerateArray())
+ {
+ string type = toolEl.TryGetProperty("type", out var t) ? t.GetString() : "function";
+ if (type != "function") continue;
+ if (!toolEl.TryGetProperty("function", out var fnEl)) continue;
+
+ var tf = new ToolFunction
+ {
+ Name = fnEl.TryGetProperty("name", out var n) ? n.GetString() : "",
+ Description = fnEl.TryGetProperty("description", out var d) ? d.GetString() : ""
+ };
+
+ if (fnEl.TryGetProperty("parameters", out var paramsEl))
+ {
+ if (paramsEl.TryGetProperty("properties", out var propsEl) &&
+ propsEl.ValueKind == JsonValueKind.Object)
+ {
+ tf.Parameters = new Dictionary();
+ foreach (var prop in propsEl.EnumerateObject())
+ {
+ var tp = new ToolParameter
+ {
+ Type = prop.Value.TryGetProperty("type", out var pt) ? pt.GetString() : "string",
+ Description = prop.Value.TryGetProperty("description", out var pd) ? pd.GetString() : null
+ };
+ if (prop.Value.TryGetProperty("enum", out var enumEl) && enumEl.ValueKind == JsonValueKind.Array)
+ tp.Enum = enumEl.EnumerateArray().Select(e => e.GetString()).ToList();
+ tf.Parameters[prop.Name] = tp;
+ }
+ }
+ if (paramsEl.TryGetProperty("required", out var reqEl) && reqEl.ValueKind == JsonValueKind.Array)
+ tf.Required = reqEl.EnumerateArray().Select(e => e.GetString()).ToList();
+ }
+
+ tools.Add(tf);
+ }
+ return tools.Count > 0 ? tools : null;
+ }
+
+ ///
+ /// Build an OpenAI Chat Completions tools catalogue. With
+ /// the schemas use the JSON Schema spellings
+ /// that the legacy parser could not read — integer and boolean enums, and
+ /// "type": ["…", "null"] for nullable fields — while keeping the same
+ /// tool and parameter counts so the two corpora stay comparable.
+ ///
+ private static string BuildSpec(bool mixedKinds)
+ {
+ var tools = new List
internal static class ToolFunctionParser
{
public static List ParseOllama(JsonElement body)
{
- if (!body.TryGetProperty("tools", out var toolsEl) || toolsEl.ValueKind != JsonValueKind.Array)
+ if (!TryGetArray(body, "tools", out var toolsEl))
return null;
var tools = new List();
foreach (var toolEl in toolsEl.EnumerateArray())
{
- if (!toolEl.TryGetProperty("function", out var fnEl))
+ if (!TryGetObject(toolEl, "function", out var fnEl))
continue;
- var tf = ParseFunction(fnEl);
- if (tf != null)
- tools.Add(tf);
+ tools.Add(ParseFunction(fnEl));
}
return tools.Count > 0 ? tools : null;
}
public static List ParseOpenAI(JsonElement body)
{
- if (!body.TryGetProperty("tools", out var toolsEl) || toolsEl.ValueKind != JsonValueKind.Array)
+ if (!TryGetArray(body, "tools", out var toolsEl))
return null;
var tools = new List();
foreach (var toolEl in toolsEl.EnumerateArray())
{
- string type = toolEl.TryGetProperty("type", out var t) ? t.GetString() : "function";
- if (type != "function") continue;
- if (!toolEl.TryGetProperty("function", out var fnEl)) continue;
+ if (!IsFunctionTool(toolEl)) continue;
+ if (!TryGetObject(toolEl, "function", out var fnEl)) continue;
- var tf = ParseFunction(fnEl);
- if (tf != null)
- tools.Add(tf);
+ tools.Add(ParseFunction(fnEl));
}
return tools.Count > 0 ? tools : null;
}
@@ -67,53 +84,179 @@ public static List ParseOpenAI(JsonElement body)
///
public static List ParseOpenAIResponses(JsonElement body)
{
- if (!body.TryGetProperty("tools", out var toolsEl) || toolsEl.ValueKind != JsonValueKind.Array)
+ if (!TryGetArray(body, "tools", out var toolsEl))
return null;
var tools = new List();
foreach (var toolEl in toolsEl.EnumerateArray())
{
- string type = toolEl.TryGetProperty("type", out var t) ? t.GetString() : "function";
- if (type != "function") continue;
+ if (!IsFunctionTool(toolEl)) continue;
- var tf = ParseFunction(toolEl);
- if (tf != null)
- tools.Add(tf);
+ tools.Add(ParseFunction(toolEl));
}
return tools.Count > 0 ? tools : null;
}
+ ///
+ /// An OpenAI tools entry names its kind in type; anything else —
+ /// the Responses API also carries server-side built-ins such as
+ /// web_search — is not a function we can offer the model. A
+ /// missing or null type means "function", which is what every
+ /// Chat Completions client intends, while a type that is not a
+ /// string at all is not a function declaration.
+ ///
+ private static bool IsFunctionTool(JsonElement toolEl)
+ {
+ if (toolEl.ValueKind != JsonValueKind.Object)
+ return false;
+ if (!toolEl.TryGetProperty("type", out var typeEl))
+ return true;
+
+ return typeEl.ValueKind switch
+ {
+ JsonValueKind.Null => true,
+ JsonValueKind.String => typeEl.GetString() == "function",
+ _ => false,
+ };
+ }
+
+ ///
+ /// Parse one function declaration — {name, description, parameters},
+ /// where parameters is a JSON Schema object. Never returns null.
+ ///
private static ToolFunction ParseFunction(JsonElement fnEl)
{
var tf = new ToolFunction
{
- Name = fnEl.TryGetProperty("name", out var n) ? n.GetString() : "",
- Description = fnEl.TryGetProperty("description", out var d) ? d.GetString() : ""
+ Name = ReadString(fnEl, "name") ?? string.Empty,
+ Description = ReadString(fnEl, "description") ?? string.Empty
};
- if (fnEl.TryGetProperty("parameters", out var paramsEl))
+ // "parameters": null on an argument-less tool is common, and so is
+ // omitting it entirely; both leave the defaults from ToolFunction.
+ if (!TryGetObject(fnEl, "parameters", out var paramsEl))
+ return tf;
+
+ if (TryGetObject(paramsEl, "properties", out var propsEl))
{
- if (paramsEl.TryGetProperty("properties", out var propsEl) &&
- propsEl.ValueKind == JsonValueKind.Object)
+ tf.Parameters = new Dictionary();
+ foreach (var prop in propsEl.EnumerateObject())
+ tf.Parameters[prop.Name] = ParseParameter(prop.Value);
+ }
+
+ if (TryGetArray(paramsEl, "required", out var reqEl))
+ {
+ // "required" lists property names, so a non-string entry names
+ // nothing and is dropped rather than carried through as a null.
+ var required = new List();
+ foreach (var item in reqEl.EnumerateArray())
{
- tf.Parameters = new Dictionary();
- foreach (var prop in propsEl.EnumerateObject())
- {
- var tp = new ToolParameter
- {
- Type = prop.Value.TryGetProperty("type", out var pt) ? pt.GetString() : "string",
- Description = prop.Value.TryGetProperty("description", out var pd) ? pd.GetString() : null
- };
- if (prop.Value.TryGetProperty("enum", out var enumEl) && enumEl.ValueKind == JsonValueKind.Array)
- tp.Enum = enumEl.EnumerateArray().Select(e => e.GetString()).ToList();
- tf.Parameters[prop.Name] = tp;
- }
+ if (item.ValueKind == JsonValueKind.String)
+ required.Add(item.GetString());
}
- if (paramsEl.TryGetProperty("required", out var reqEl) && reqEl.ValueKind == JsonValueKind.Array)
- tf.Required = reqEl.EnumerateArray().Select(e => e.GetString()).ToList();
+ tf.Required = required;
}
return tf;
}
+
+ ///
+ /// Parse one property schema. An absent type keeps the historical
+ /// "string" default; a schema that is not even an object (JSON
+ /// Schema allows a bare true/false in a property slot)
+ /// yields that same untyped default.
+ ///
+ private static ToolParameter ParseParameter(JsonElement schema)
+ {
+ var tp = new ToolParameter
+ {
+ Type = ReadSchemaType(schema) ?? "string",
+ Description = ReadString(schema, "description") ?? string.Empty
+ };
+
+ if (TryGetArray(schema, "enum", out var enumEl))
+ {
+ // ToolParameter.Enum is a list of strings, but the schema's values
+ // need not be. Render a non-string member as its raw JSON text so
+ // it round-trips exactly when the prompt renderers re-serialize
+ // the schema: 1 stays 1 and true stays true. JsonElement.ToString()
+ // is the wrong tool here — it renders booleans in .NET's casing
+ // ("True") and null as an empty string.
+ var values = new List();
+ foreach (var item in enumEl.EnumerateArray())
+ values.Add(item.ValueKind == JsonValueKind.String ? item.GetString() : item.GetRawText());
+ tp.Enum = values;
+ }
+
+ return tp;
+ }
+
+ ///
+ /// Read a property schema's type. JSON Schema allows a union —
+ /// "type": ["string", "null"] is the standard spelling of a
+ /// nullable field — while holds a single
+ /// name, because it is re-emitted into the prompt as a JSON Schema string
+ /// and switched on when rendering Harmony's TypeScript tool namespace. So
+ /// keep the first real type and drop the "null" member, whose
+ /// meaning the required list already carries.
+ ///
+ private static string ReadSchemaType(JsonElement schema)
+ {
+ if (schema.ValueKind != JsonValueKind.Object || !schema.TryGetProperty("type", out var typeEl))
+ return null;
+
+ if (typeEl.ValueKind == JsonValueKind.String)
+ return typeEl.GetString();
+
+ if (typeEl.ValueKind == JsonValueKind.Array)
+ {
+ string first = null;
+ foreach (var item in typeEl.EnumerateArray())
+ {
+ if (item.ValueKind != JsonValueKind.String)
+ continue;
+ string name = item.GetString();
+ first ??= name;
+ if (name != "null")
+ return name;
+ }
+ return first;
+ }
+
+ return null;
+ }
+
+ /// Read as a string, or null unless it is one.
+ private static string ReadString(JsonElement obj, string name)
+ => obj.ValueKind == JsonValueKind.Object
+ && obj.TryGetProperty(name, out var value)
+ && value.ValueKind == JsonValueKind.String
+ ? value.GetString()
+ : null;
+
+ private static bool TryGetObject(JsonElement obj, string name, out JsonElement value)
+ => TryGetOfKind(obj, name, JsonValueKind.Object, out value);
+
+ private static bool TryGetArray(JsonElement obj, string name, out JsonElement value)
+ => TryGetOfKind(obj, name, JsonValueKind.Array, out value);
+
+ ///
+ /// is
+ /// itself only safe on an object — it throws on any other kind — so the
+ /// container is checked before the member.
+ ///
+ private static bool TryGetOfKind(JsonElement obj, string name, JsonValueKind kind, out JsonElement value)
+ {
+ value = default;
+ if (obj.ValueKind != JsonValueKind.Object
+ || !obj.TryGetProperty(name, out var found)
+ || found.ValueKind != kind)
+ {
+ return false;
+ }
+
+ value = found;
+ return true;
+ }
}
}