Working with NJsonSchema to make it more similar to Python w Pydantic and Node with Zod

[twf-datacom]

I saw that the example for math reasoning in the readme specifies the json schema as a string, and then parses the response back out into a json document.

I would like to be able to specify the schema with normal c# classes/records, and parse them back out into those same records. That is how the python and node sdks work.

I tried to use NJsonSchema for this and had some success after doing a few workarounds. I'll share that here. Would the maintainers consider including this technique in the lib, or would you rather not introduce another dependency in NJsonSchema? It might be enough to just include examples, and users can add NJsonSchema if they want.

First, I specify the response format records. Note you need to use the Required annotation to make openai happy. I'm new to c# so please be kind:

public record MathReasoning
{
    [Required]
    public required List<Step> Steps { get; init; }

    [Required]
    public required string FinalAnswer { get; init; }
}

public record Step
{
    [Required]
    public required string Explanation { get; init; }

    [Required]
    public required string Output { get; init; }
}

Then you need to set some json schema generator settings, including a custom processor to remove the 'minLength' because openai doesn't like that either:

public async Task<MathReasoning?> GetCompletions()
    {
        var settings = new SystemTextJsonSchemaGeneratorSettings
        {
            DefaultReferenceTypeNullHandling = ReferenceTypeNullHandling.NotNull,
            SchemaType = SchemaType.JsonSchema, // Ensure we're generating JSON Schema
            GenerateAbstractProperties = false, // Do not generate default values
            GenerateExamples = false, // Do not generate examples
            AlwaysAllowAdditionalObjectProperties = false, // Do not allow additional properties
            SchemaProcessors = { new RemoveMinLengthProcessor() }
        };

        var jsonSchema = JsonSchema.FromType<MathReasoning>(settings);

        ChatCompletionOptions options = new()
        {
            ResponseFormat = ChatResponseFormat.CreateJsonSchemaFormat(
                name: "math_reasoning",
                jsonSchema: BinaryData.FromString(jsonSchema.ToJson()),
            strictSchemaEnabled: true)
        };

        ChatCompletion chatCompletion = await client.CompleteChatAsync(
            ["How can I solve 8x + 7 = -23?"],
            options);

        return JsonSerializer.Deserialize<MathReasoning>(chatCompletion.ToString());
    }

For the min length stripper, I just got gpt to generate this:

public class RemoveMinLengthProcessor : ISchemaProcessor
{
    public void Process(SchemaProcessorContext context)
    {
        RemoveMinLengthConstraints(context.Schema);
    }

    private void RemoveMinLengthConstraints(JsonSchema schema)
    {
        foreach (var property in schema.Properties.Values)
        {
            property.MinLength = null;
        }

        foreach (var definition in schema.Definitions.Values)
        {
            RemoveMinLengthConstraints(definition);
        }
    }
}

There are probably some other json schema properties that openai doesn't like. But I think this is pretty cool because it lets you deal with end to end DTOs rather than loose json documents and strings. I was able to propagate these types up to an api via swagger/swashbuckle, and then generate client typescript code so we get the dtos in the client.