Let's go faster: full (8/16) spec update, minimal/targeted public API

.dotnet/CHANGELOG.md

@@ -4,6 +4,11 @@
 
 ### Features Added
 
+- Added support for the new [structured outputs](https://platform.openai.com/docs/guides/structured-outputs/introduction) response format feature, which enables chat completions, assistants, and tools on each of those clients to provide a specific JSON Schema that generated content should adhere to.
+  - To enable top-level structured outputs for response content, use `ChatResponseFormat.CreateJsonSchemaFormat()` and `AssistantResponseFormat.CreateJsonSchemaFormat()` as the `ResponseFormat` in method options like `ChatCompletionOptions`
+  - To enable structured outputs for function tools, set `StrictParameterSchemaEnabled` to `true` on the tool definition
+  - For more information, please see [the new section in readme.md](readme.md#how-to-use-structured-outputs)
+- Chat completions: the request message types of `AssistantChatMessage`, `SystemChatMessage`, and `ToolChatMessage` now support array-based content part collections in addition to simple string input.
 - Added the following model factories (static classes that can be used to instantiate OpenAI models for mocking in non-live test scenarios):
   - `OpenAIAudioModelFactory` in the `OpenAI.Audio` namespace (commit_hash)
   - `OpenAIEmbeddingsModelFactory` in the `OpenAI.Embeddings` namespace (commit_hash)
@@ -22,8 +27,12 @@
 
 ### Bugs Fixed
 
+- The `Assistants` namespace `VectorStoreCreationHelper` type now properly includes a `ChunkingStrategy` property.
+
 ### Other Changes
 
+- `ChatCompletion.ToString()` will no longer throw an exception when no content is present, as is the case for tool calls. Additionally, if a tool call is present with no content, `ToString()` will return the serialized form of the first available tool call.
+
 ## 2.0.0-beta.8 (2024-07-31)
 
 ### Breaking Changes

.dotnet/README.md

@@ -17,6 +17,7 @@ It is generated from our [OpenAPI specification](https://github.com/openai/opena
   - [Using the `OpenAIClient` class](#using-the-openaiclient-class)
 - [How to use chat completions with streaming](#how-to-use-chat-completions-with-streaming)
 - [How to use chat completions with tools and function calling](#how-to-use-chat-completions-with-tools-and-function-calling)
+- [How to use structured outputs](#how-to-use-structured-outputs)
 - [How to generate text embeddings](#how-to-generate-text-embeddings)
 - [How to generate images](#how-to-generate-images)
 - [How to transcribe audio](#how-to-transcribe-audio)
@@ -296,6 +297,60 @@ do
 } while (requiresAction);
 ```
 
+## How to use structured outputs
+
+Beginning with the `gpt-4o-mini`, `gpt-4o-mini-2024-07-18`, and `gpt-4o-2024-08-06` model snapshots, structured outputs are available for both top-level response content and tool calls in the chat completion and assistants APIs.
+
+For information about the feature, see [the Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs/introduction).
+
+To use structured outputs to constrain chat completion content, set an appropriate `ChatResponseFormat` as in the following example:
+
+```csharp
+ChatCompletionOptions options = new()
+{
+    ResponseFormat = ChatResponseFormat.CreateJsonSchemaFormat(
+        name: "math_reasoning",
+        jsonSchema: BinaryData.FromString("""
+            {
+                "type": "object",
+                "properties": {
+                "steps": {
+                    "type": "array",
+                    "items": {
+                    "type": "object",
+                    "properties": {
+                        "explanation": { "type": "string" },
+                        "output": { "type": "string" }
+                    },
+                    "required": ["explanation", "output"],
+                    "additionalProperties": false
+                    }
+                },
+                "final_answer": { "type": "string" }
+                },
+                "required": ["steps", "final_answer"],
+                "additionalProperties": false
+            }
+            """),
+    strictSchemaEnabled: true)
+};
+
+ChatCompletion chatCompletion = await client.CompleteChatAsync(
+    ["How can I solve 8x + 7 = -23?"],
+    options);
+
+using JsonDocument structuredJson = JsonDocument.Parse(chatCompletion.ToString());
+
+Console.WriteLine($"Final answer: {structuredJson.RootElement.GetProperty("final_answer").GetString()}");
+Console.WriteLine("Reasoning steps:");
+
+foreach (JsonElement stepElement in structuredJson.RootElement.GetProperty("steps").EnumerateArray())
+{
+    Console.WriteLine($"  - Explanation: {stepElement.GetProperty("explanation").GetString()}");
+    Console.WriteLine($"    Output: {stepElement.GetProperty("output")}");
+}
+```
+
 ## How to generate text embeddings
 
 In this example, you want to create a trip-planning website that allows customers to write a prompt describing the kind of hotel that they are looking for and then offers hotel recommendations that closely match this description. To achieve this, it is possible to use text embeddings to measure the relatedness of text strings. In summary, you can get embeddings of the hotel descriptions, store them in a vector database, and use them to build a search index that you can query using the embedding of a given customer's prompt.