Support interop with JsonNode and JsonElement when working with AWS.Runtime Documents

[rhdunn]

Describe the feature

The Document class in AWS.Runtime is a simple JSON model class that is used to e.g. pass the JSON schema and response for AWS bedrock tool use.

.NET natively supports JsonNode and JsonDocument/JsonElement for working with JSON. Currently it is difficult to interoperate with these classes:

• Document.FromObject only supports JsonElement -- for JsonNode you need to do `Document.FromObject(JsonDocument.Parse(node.ToJsonString()).RootElement);
• There is no way to convert from a Document to a JsonNode or JsonElement.

Use Case

I have a JsonNode object that defines the JSON schema (via GetJsonSchemaAsNode) that I want to use to specify an AWS Bedrock tool as using (setting the Json property of the ToolSpecification). I also want to use that JSON schema object to deserialize the JSON back into a .NET class. I'm using JsonNode because I need it to work with other parts of the project.

Proposed Solution

I propose for Document.FromObject:

• A Document.FromObject(JsonDocument doc) overload that evaluates to Document.FromObject(doc.RootElement);
• A Document.FromObject(JsonNode node) overload that evaluates to Document.FromObject(JsonDocument.Parse(node.ToJsonString())) or equivalent.

I also propose the following converters to convert to the corresponding .NET types:

• JsonDocument Document.AsJsonDocument();
• JsonElement Document.AsJsonElement();
• JsonNode Document.AsJsonNode().

Other Information

No response

Acknowledgements

• I may be able to implement this feature request
• This feature might incur a breaking change

AWS .NET SDK and/or Package version used

AWS.BedrockRuntime 4.0.1.1

Targeted .NET Platform

.NET 8

Operating System and version

Windows 11

[normj]

I agree we need to improve the usability but one of the purposes of the Document class, which there are variants of this type across all the AWS SDKs, is agnostic of the underlying wire protocol. Just so happens that today all the usages are JSON but that won't necessary always be the case.

I suspect we should add some extension/utility methods for easy conversion between JSON and the Document but don't want to nest JSON logic inside the Document type.

[rhdunn]

I'm happy with there being opt-in extension methods for the JSON interoperability. That satisfies my goals of 1) not having to write the conversions myself; and 2) reducing the potential for bugs due to any data model changes in the AWS code or misunderstanding the usage of the Document API.

[arthurmmedeiros]

@rhdunn I'm curious to know if you were able to find a workaround for this part:

There is no way to convert from a Document to a JsonNode or JsonElement.

I'm currently unable to parse the Input property which is a Document from the Bedrock response.

[rhdunn]

@arthurmmedeiros I had to write a converter:

    public static JsonNode? ToJsonNode(this Document doc)
    {
        switch (doc.Type)
        {
            case DocumentType.Dictionary:
                return new JsonObject(doc.AsDictionary()
                    .Select(pair => KeyValuePair.Create(pair.Key, pair.Value.ToJsonNode())));
            case DocumentType.List:
                return new JsonArray(doc.AsList()
                    .Select(node => node.ToJsonNode())
                    .ToArray());
            case DocumentType.Null:
                return null;
            case DocumentType.Bool:
                return JsonValue.Create(doc.AsBool());
            case DocumentType.Double:
                return JsonValue.Create(doc.AsDouble());
            case DocumentType.Int:
                return JsonValue.Create(doc.AsInt());
            case DocumentType.Long:
                return JsonValue.Create(doc.AsLong());
            case DocumentType.String:
                return JsonValue.Create(doc.AsString());
            default:
                throw new Exception($"Unsupported document type: {doc.Type}");
        }
    }

I can then pass that to JsonSchemaFormat<T>.Deserialize:

jsonSchemaFormat.Deserialize(content.ToolUse.Input.ToJsonNode()!)