squashed merge for retarget

.dotnet.azure/sdk/openai/Azure.AI.OpenAI/src/Custom/Files/AzureOpenAIFile.cs

@@ -61,7 +61,7 @@ internal partial class AzureOpenAIFile : OpenAIFile
     internal AzureOpenAIFile(string id, int? bytes, DateTimeOffset createdAt, string filename, string purpose, AzureOpenAIFileStatus azureStatus)
         : base(id, createdAt, filename, purpose.ToFilePurpose(), bytes, azureStatus.ToFileStatus())
     {
-        _object = InternalListFilesResponseObject.List.ToString();
+        _object = "file";
         _purpose = purpose;
         _azureStatus = azureStatus;
     }

.dotnet.azure/sdk/openai/Azure.AI.OpenAI/src/Custom/Files/AzureOpenAIFileCollection.Serialization.cs

@@ -34,8 +34,11 @@ internal static AzureOpenAIFileCollection DeserializeAzureOpenAIFileCollection(J
             return null;
         }
         IReadOnlyList<AzureOpenAIFile> data = default;
-        InternalListFilesResponseObject @object = default;
-        IDictionary<string, BinaryData> serializedAdditionalRawData = default;
+        string @object = default;
+        string firstId = default;
+        string lastId = default;
+        bool hasMore = false;
+        IDictionary<string, BinaryData> additionalBinaryDataProperties = default;
         Dictionary<string, BinaryData> rawDataDictionary = new Dictionary<string, BinaryData>();
         foreach (var property in element.EnumerateObject())
         {
@@ -51,16 +54,31 @@ internal static AzureOpenAIFileCollection DeserializeAzureOpenAIFileCollection(J
             }
             if (property.NameEquals("object"u8))
             {
-                @object = new InternalListFilesResponseObject(property.Value.GetString());
+                @object = property.Value.GetString();
+                continue;
+            }
+            if (property.NameEquals("first_id"u8))
+            {
+                firstId = property.Value.GetString();
+                continue;
+            }
+            if (property.NameEquals("last_id"u8))
+            {
+                lastId = property.Value.GetString();
+                continue;
+            }
+            if (property.NameEquals("has_more"u8))
+            {
+                hasMore = property.Value.GetBoolean();
                 continue;
             }
             if (true)
             {
                 rawDataDictionary.Add(property.Name, BinaryData.FromString(property.Value.GetRawText()));
             }
         }
-        serializedAdditionalRawData = rawDataDictionary;
-        return new AzureOpenAIFileCollection(data, @object, serializedAdditionalRawData);
+        additionalBinaryDataProperties = rawDataDictionary;
+        return new AzureOpenAIFileCollection(data, @object, firstId, lastId, hasMore, additionalBinaryDataProperties);
     }
 
     void IJsonModel<AzureOpenAIFileCollection>.Write(Utf8JsonWriter writer, ModelReaderWriterOptions options)

.dotnet.azure/sdk/openai/Azure.AI.OpenAI/src/Custom/Files/AzureOpenAIFileCollection.cs

@@ -11,19 +11,25 @@ internal partial class AzureOpenAIFileCollection : OpenAIFileCollection
     internal new IDictionary<string, BinaryData> SerializedAdditionalRawData { get; }
         = new ChangeTrackingDictionary<string, BinaryData>();
 
-    internal InternalListFilesResponseObject Object { get; }
+    internal string Object { get; }
 
     internal AzureOpenAIFileCollection()
         : this(
               new ChangeTrackingList<AzureOpenAIFile>(),
-              InternalListFilesResponseObject.List,
+              "list",
+              firstId: null,
+              lastId: null,
+              hasMore: false,
               new ChangeTrackingDictionary<string, BinaryData>())
     { }
 
     internal AzureOpenAIFileCollection(
         IEnumerable<AzureOpenAIFile> files,
-        InternalListFilesResponseObject @object,
-        IDictionary<string, BinaryData> serializedAdditionalRawData)
-            : base(files.Cast<OpenAIFile>().ToList(), @object, serializedAdditionalRawData)
+        string @object,
+        string firstId,
+        string lastId,
+        bool hasMore,
+        IDictionary<string, BinaryData> additionalBinaryDataProperties)
+            : base(files.Cast<OpenAIFile>().ToList(), @object, firstId, lastId, hasMore, additionalBinaryDataProperties)
     { }
 }

.dotnet/src/Custom/Assistants/Internal/GeneratorStubs.Internal.cs

@@ -206,7 +206,11 @@ internal partial class InternalRunStepDeltaStepDetailsMessageCreationObject { }
 internal partial class InternalRunStepDeltaStepDetailsToolCallsObject { }
 
 [CodeGenModel("RunStepDeltaStepDetailsToolCallsFileSearchObject")]
-internal partial class InternalRunStepDeltaStepDetailsToolCallsFileSearchObject { }
+internal partial class InternalRunStepDeltaStepDetailsToolCallsFileSearchObject
+{
+    [CodeGenMember("FileSearch")]
+    public InternalRunStepDetailsToolCallsFileSearchObjectFileSearch FileSearch { get; set; }
+}
 
 [CodeGenModel("RunStepDeltaStepDetailsToolCallsFunctionObject")]
 internal partial class InternalRunStepDeltaStepDetailsToolCallsFunctionObject { }

.dotnet/src/Custom/Chat/ChatCompletionOptions.Serialization.cs

@@ -95,4 +95,41 @@ private static void DeserializeLogitBiasesValue(JsonProperty property, ref IDict
             logitBias = dictionary;
         }
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void SerializePredictedContentValue(Utf8JsonWriter writer, ModelReaderWriterOptions options)
+    {
+        if (PredictedContent is not null)
+        {
+            writer.WriteStartObject();
+            writer.WritePropertyName("type"u8);
+            writer.WriteStringValue(InternalPredictionContentType.Content.ToString());
+            writer.WritePropertyName("content"u8);
+            writer.WriteObjectValue(PredictedContent, options);
+            writer.WriteEndObject();
+        }
+        else
+        {
+            writer.WriteNullValue();
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void DeserializePredictedContentValue(JsonProperty property, ref ChatMessageContent predictedContent)
+    {
+        if (property.Value.ValueKind == JsonValueKind.Null)
+        {
+            predictedContent = null;
+        }
+        else
+        {
+            foreach (JsonProperty predictionProperty in property.Value.EnumerateObject())
+            {
+                if (predictionProperty.NameEquals("content"u8))
+                {
+                    ChatMessage.DeserializeContentValue(predictionProperty, ref predictedContent);
+                }
+            }
+        }
+    }
 }

.dotnet/src/Custom/Chat/ChatCompletionOptions.cs

@@ -12,6 +12,7 @@ namespace OpenAI.Chat;
 [CodeGenSerialization(nameof(Messages), SerializationValueHook = nameof(SerializeMessagesValue))]
 [CodeGenSerialization(nameof(StopSequences), SerializationValueHook = nameof(SerializeStopSequencesValue), DeserializationValueHook = nameof(DeserializeStopSequencesValue))]
 [CodeGenSerialization(nameof(LogitBiases), SerializationValueHook = nameof(SerializeLogitBiasesValue), DeserializationValueHook = nameof(DeserializeLogitBiasesValue))]
+[CodeGenSerialization(nameof(PredictedContent), SerializationValueHook = nameof(SerializePredictedContentValue), DeserializationValueHook = nameof(DeserializePredictedContentValue))]
 public partial class ChatCompletionOptions
 {
     // CUSTOM:
@@ -177,6 +178,13 @@ public ChatCompletionOptions()
     [CodeGenMember("Store")]
     public bool? StoredOutputEnabled { get; set; }
 
+    /// <summary>
+    /// (o1 and newer reasoning models only) Constrains effort on reasoning for reasoning models.
+    /// Currently supported values are <see cref="ChatReasoningEffort.Low"/>, <see cref="ChatReasoningEffort.Medium"/>, and <see cref="ChatReasoningEffort.High"/>.
+    /// Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+    /// </summary>
+    public ChatReasoningEffort? ReasoningEffort { get; set; }
+
     // CUSTOM: Made internal for automatic enablement via audio options.
     [CodeGenMember("Modalities")]
     private IList<InternalCreateChatCompletionRequestModality> _internalModalities = new ChangeTrackingList<InternalCreateChatCompletionRequestModality>();
@@ -196,4 +204,7 @@ public ChatAudioOptions AudioOptions
                 : [InternalCreateChatCompletionRequestModality.Text, InternalCreateChatCompletionRequestModality.Audio];
         }
     }
+
+    [CodeGenMember("Prediction")]
+    public ChatMessageContent PredictedContent { get; set; }
 }

.dotnet/src/Custom/Chat/ChatMessage.cs

@@ -105,6 +105,17 @@ internal ChatMessage(ChatMessageRole role, string content = null) : this(role)
     public static SystemChatMessage CreateSystemMessage(params ChatMessageContentPart[] contentParts) => new(contentParts);
     #endregion
 
+    #region DeveloperChatMessage
+    /// <inheritdoc cref="DeveloperChatMessage(string)"/>
+    public static DeveloperChatMessage CreateDeveloperMessage(string content) => new(content);
+
+    /// <inheritdoc cref="DeveloperChatMessage(IEnumerable{ChatMessageContentPart})"/>
+    public static DeveloperChatMessage CreateDeveloperMessage(IEnumerable<ChatMessageContentPart> contentParts) => new(contentParts);
+
+    /// <inheritdoc cref="DeveloperChatMessage(ChatMessageContentPart[])"/>
+    public static DeveloperChatMessage CreateDeveloperMessage(params ChatMessageContentPart[] contentParts) => new(contentParts);
+    #endregion
+
     #region UserChatMessage
     /// <inheritdoc cref="UserChatMessage(string)"/>
     public static UserChatMessage CreateUserMessage(string content) => new(content);

.dotnet/src/Custom/Chat/ChatMessageRole.cs

@@ -11,6 +11,11 @@ namespace OpenAI.Chat;
 ///     <note>Description</note>
 /// </listheader>
 /// <item>
+///     <type><see cref="Developer"/> -</type>
+///     <role><c>developer</c> -</role>
+///     <note>Instructions to the model that guide the behavior of future <c>assistant</c> messages. Replaces <c>system</c> in o1 and newer models.</note>
+/// </item>
+/// <item>
 ///     <type><see cref="System"/> -</type>
 ///     <role><c>system</c> -</role>
 ///     <note>Instructions to the model that guide the behavior of future <c>assistant</c> messages.</note>
@@ -59,6 +64,16 @@ public enum ChatMessageRole
     [CodeGenMember("System")]
     System,
 
+    /// <summary>
+    /// The <c>developer</c> role, which provides instructions to the model that guide the behavior of future
+    /// <c>assistant</c> messages
+    /// </summary>
+    /// <remarks>
+    /// <c>developer</c> replaces <c>system</c> when using o1 and newer models.
+    /// </remarks>
+    [CodeGenMember("Developer")]
+    Developer,
+
     /// <summary>
     /// The <c>user</c> role that provides input from the caller as a prompt for model responses.
     /// </summary>

.dotnet/src/Custom/Chat/ChatOutputTokenUsageDetails.cs

@@ -14,4 +14,10 @@ public partial class ChatOutputTokenUsageDetails
     /// <summary> The number of audio tokens in the output. </summary>
     [CodeGenMember("AudioTokens")]
     public int AudioTokenCount { get; }
+
+    [CodeGenMember("AcceptedPredictionTokens")]
+    public int PredictionAcceptedTokenCount { get; }
+
+    [CodeGenMember("RejectedPredictionTokens")]
+    public int PredictionRejectedTokenCount { get; }
 }

.dotnet/src/Custom/Chat/ChatReasoningEffort.cs

@@ -0,0 +1,9 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace OpenAI.Chat;
+
+[CodeGenModel("CreateChatCompletionRequestReasoningEffort")]
+public readonly partial struct ChatReasoningEffort
+{}

.dotnet/src/Custom/Chat/DeveloperChatMessage.Serialization.cs

@@ -0,0 +1,45 @@
+using System;
+using System.ClientModel.Primitives;
+using System.Text.Json;
+
+namespace OpenAI.Chat;
+
+[CodeGenSuppress("global::System.ClientModel.Primitives.IJsonModel<OpenAI.Chat.DeveloperChatMessage>.Write", typeof(Utf8JsonWriter), typeof(ModelReaderWriterOptions))]
+public partial class DeveloperChatMessage : IJsonModel<DeveloperChatMessage>
+{
+    void IJsonModel<DeveloperChatMessage>.Write(Utf8JsonWriter writer, ModelReaderWriterOptions options)
+        => CustomSerializationHelpers.SerializeInstance(this, SerializeDeveloperChatMessage, writer, options);
+
+    internal static void SerializeDeveloperChatMessage(DeveloperChatMessage instance, Utf8JsonWriter writer, ModelReaderWriterOptions options)
+        => instance.WriteCore(writer, options);
+
+    internal override void WriteCore(Utf8JsonWriter writer, ModelReaderWriterOptions options)
+    {
+        writer.WriteStartObject();
+        writer.WritePropertyName("role"u8);
+        writer.WriteStringValue(Role.ToSerialString());
+
+        // Content is required, can be a single string or a collection of ChatMessageContentPart.
+        if (Optional.IsDefined(Content) && Content.IsInnerCollectionDefined())
+        {
+            writer.WritePropertyName("content"u8);
+            if (Content.Count == 1 && Content[0].Text != null)
+            {
+                writer.WriteStringValue(Content[0].Text);
+            }
+            else
+            {
+                writer.WriteStartArray();
+                foreach (ChatMessageContentPart part in Content)
+                {
+                    writer.WriteObjectValue(part, options);
+                }
+                writer.WriteEndArray();
+            }
+        }
+
+        writer.WriteOptionalProperty("name"u8, ParticipantName, options);
+        writer.WriteSerializedAdditionalRawData(_additionalBinaryDataProperties, options);
+        writer.WriteEndObject();
+    }
+}

.dotnet/src/Custom/Chat/DeveloperChatMessage.cs

@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+
+namespace OpenAI.Chat;
+
+/// <summary>
+/// Represents a chat message of the <c>developer</c> role as supplied to a chat completion request. A developer message is
+/// generally supplied as the first message to a chat completion request and guides the model's behavior across future
+/// <c>assistant</c> role response messages. These messages may help control behavior, style, tone, and
+/// restrictions for a model-based assistant. Developer messages replace system messages for o1 models and newer.
+/// </summary>
+[CodeGenModel("ChatCompletionRequestDeveloperMessage")]
+[CodeGenSuppress("DeveloperChatMessage", typeof(ChatMessageContent))]
+public partial class DeveloperChatMessage : ChatMessage
+{
+    /// <summary>
+    /// Creates a new instance of <see cref="DeveloperChatMessage"/> using a collection of content items.
+    /// For <c>system</c> messages, these can only be of type <c>text</c>.
+    /// </summary>
+    /// <param name="contentParts">
+    ///     The collection of content items associated with the message.
+    /// </param>
+    public DeveloperChatMessage(IEnumerable<ChatMessageContentPart> contentParts)
+        : base(ChatMessageRole.System, contentParts)
+    { }
+
+    /// <summary>
+    /// Creates a new instance of <see cref="DeveloperChatMessage"/> using a collection of content items.
+    /// For <c>system</c> messages, these can only be of type <c>text</c>.
+    /// </summary>
+    /// <param name="contentParts">
+    ///     The collection of content items associated with the message.
+    /// </param>
+    public DeveloperChatMessage(params ChatMessageContentPart[] contentParts)
+        : base(ChatMessageRole.Developer, contentParts)
+    {
+        Argument.AssertNotNullOrEmpty(contentParts, nameof(contentParts));
+    }
+
+    /// <summary>
+    /// Creates a new instance of <see cref="DeveloperChatMessage"/> with a single item of text content.
+    /// </summary>
+    /// <param name="content"> The text content of the message. </param>
+    public DeveloperChatMessage(string content)
+        : base(ChatMessageRole.Developer, content)
+    {
+        Argument.AssertNotNull(content, nameof(content));
+    }
+
+    // CUSTOM: Hide the default constructor.
+    internal DeveloperChatMessage()
+    {
+    }
+
+    /// <summary>
+    /// An optional <c>name</c> for the participant.
+    /// </summary>
+    [CodeGenMember("Name")]
+    public string ParticipantName { get; set; }
+}

.dotnet/src/Custom/Chat/Internal/GeneratorStubs.cs

@@ -105,3 +105,8 @@ internal readonly partial struct InternalChatCompletionRequestMessageContentPart
 [CodeGenModel("ChatCompletionMessageAudioChunk")]
 internal partial class InternalChatCompletionMessageAudioChunk { }
 
+[CodeGenModel("PredictionContent")]
+internal partial class InternalPredictionContent { }
+
+[CodeGenModel("PredictionContentType")]
+internal readonly partial struct InternalPredictionContentType { }

.dotnet/src/Custom/Chat/OpenAIChatModelFactory.cs

@@ -116,9 +116,14 @@ public static ChatInputTokenUsageDetails ChatInputTokenUsageDetails(int audioTok
 
     /// <summary> Initializes a new instance of <see cref="OpenAI.Chat.ChatOutputTokenUsageDetails"/>. </summary>
     /// <returns> A new <see cref="OpenAI.Chat.ChatOutputTokenusageDetails"/> instance for mocking. </returns>
-    public static ChatOutputTokenUsageDetails ChatOutputTokenUsageDetails(int reasoningTokenCount = default, int audioTokenCount = default)
+    public static ChatOutputTokenUsageDetails ChatOutputTokenUsageDetails(int reasoningTokenCount = default, int audioTokenCount = default, int predictionAcceptedTokenCount = default, int predictionRejectedTokenCount = 0)
     {
-        return new ChatOutputTokenUsageDetails(reasoningTokenCount, audioTokenCount, additionalBinaryDataProperties: null);
+        return new ChatOutputTokenUsageDetails(
+            audioTokenCount: audioTokenCount,
+            reasoningTokenCount: reasoningTokenCount,
+            predictionAcceptedTokenCount: predictionAcceptedTokenCount,
+            predictionRejectedTokenCount: predictionRejectedTokenCount,
+            additionalBinaryDataProperties: null);
     }
 
     public static ChatResponseAudio ChatResponseAudio(BinaryData data, string id = null, string transcript = null, DateTimeOffset expiresAt = default)

.dotnet/src/Custom/Files/Internal/GeneratorStubs.cs

@@ -3,9 +3,6 @@ namespace OpenAI.Files;
 [CodeGenModel("DeleteFileResponseObject")]
 internal readonly partial struct InternalDeleteFileResponseObject { }
 
-[CodeGenModel("ListFilesResponseObject")]
-internal readonly partial struct InternalListFilesResponseObject { }
-
 [CodeGenModel("OpenAIFileObject")]
 internal readonly partial struct InternalOpenAIFileObject { }