com.openai.unity 8.0.0 (#235)

- Updated Assistants Beta v2
- Added support for specifying project id
- Added BatchEndpoint
- Added VectorStoresEndpoint
- Added Message.ctr to specify specific tool call id, function name, and content
- Renamed OpenAI.Images.ResponseFormat to OpenAI.Images.ImageResponseFormat
- Changed ThreadEndpoint.CancelRunAsync return type from RunResponse to bool
- Fixed Json defined Tools/Functions being improperly added to tool cache
- Added Tool.TryUnregisterTool to remove a tool from the cache

Author: StephenHodgson

Documentation~/README.md

@@ -15,7 +15,7 @@
 
 namespace OpenAI.Editor
 {
-    public class OpenAIDashboard : AbstractEditorDashboard
+    public sealed class OpenAIDashboard : AbstractEditorDashboard
     {
         #region GUIContent
 

Editor/OpenAIDashboard.cs

@@ -1,7 +1,7 @@
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
-using System;
 using Newtonsoft.Json;
+using System;
 using UnityEngine.Scripting;
 
 namespace OpenAI.Assistants
@@ -10,11 +10,12 @@ namespace OpenAI.Assistants
     /// File attached to an assistant.
     /// </summary>
     [Preserve]
+    [Obsolete("Removed. Use Assistant.ToolResources instead.")]
     public sealed class AssistantFileResponse : BaseResponse
     {
         [Preserve]
         [JsonConstructor]
-        public AssistantFileResponse(
+        internal AssistantFileResponse(
             string id,
             string @object,
             int createdAtUnixTimeSeconds,

Runtime/Assistants/AssistantExtensions.cs

@@ -1,31 +1,35 @@
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
 using Newtonsoft.Json;
+using OpenAI.Extensions;
 using System;
 using System.Collections.Generic;
 using UnityEngine.Scripting;
 
 namespace OpenAI.Assistants
 {
     /// <summary>
-    /// Purpose-built AI that uses OpenAI’s models and calls tools.
+    /// Purpose-built AI that uses OpenAI's models and calls tools.
     /// </summary>
     [Preserve]
     public sealed class AssistantResponse : BaseResponse
     {
         [Preserve]
         [JsonConstructor]
-        public AssistantResponse(
-            string id,
-            string @object,
-            int createdAtUnixTimeSeconds,
-            string name,
-            string description,
-            string model,
-            string instructions,
-            IReadOnlyList<Tool> tools,
-            IReadOnlyList<string> fileIds,
-            Dictionary<string, string> metadata)
+        internal AssistantResponse(
+            [JsonProperty("id")] string id,
+            [JsonProperty("object")] string @object,
+            [JsonProperty("created_at")] int createdAtUnixTimeSeconds,
+            [JsonProperty("name")] string name,
+            [JsonProperty("description")] string description,
+            [JsonProperty("model")] string model,
+            [JsonProperty("instructions")] string instructions,
+            [JsonProperty("tools")] IReadOnlyList<Tool> tools,
+            [JsonProperty("tool_resources")] ToolResources toolResources,
+            [JsonProperty("metadata")] Dictionary<string, string> metadata,
+            [JsonProperty("temperature")] double temperature,
+            [JsonProperty("top_p")] double topP,
+            [JsonProperty("response_format")][JsonConverter(typeof(ResponseFormatConverter))] ChatResponseFormat responseFormat)
         {
             Id = id;
             Object = @object;
@@ -35,8 +39,11 @@ public AssistantResponse(
             Model = model;
             Instructions = instructions;
             Tools = tools;
-            FileIds = fileIds;
+            ToolResources = toolResources;
             Metadata = metadata;
+            Temperature = temperature;
+            TopP = topP;
+            ResponseFormat = responseFormat;
         }
 
         /// <summary>
@@ -106,14 +113,24 @@ public AssistantResponse(
         [JsonProperty("tools")]
         public IReadOnlyList<Tool> Tools { get; }
 
+        /// <summary>
+        /// A set of resources that are used by the assistant's tools.
+        /// The resources are specific to the type of tool.
+        /// For example, the code_interpreter tool requires a list of file IDs,
+        /// while the file_search tool requires a list of vector store IDs.
+        /// </summary>
+        [Preserve]
+        [JsonProperty("tool_resources")]
+        public ToolResources ToolResources { get; }
+
         /// <summary>
         /// A list of file IDs attached to this assistant.
         /// There can be a maximum of 20 files attached to the assistant.
         /// Files are ordered by their creation date in ascending order.
         /// </summary>
-        [Preserve]
-        [JsonProperty("file_ids")]
-        public IReadOnlyList<string> FileIds { get; }
+        [JsonIgnore]
+        [Obsolete("Files removed from Assistants. Files now belong to ToolResources.")]
+        public IReadOnlyList<string> FileIds => null;
 
         /// <summary>
         /// Set of 16 key-value pairs that can be attached to an object.
@@ -124,6 +141,41 @@ public AssistantResponse(
         [JsonProperty("metadata")]
         public IReadOnlyDictionary<string, string> Metadata { get; }
 
+        /// <summary>
+        /// What sampling temperature to use, between 0 and 2.
+        /// Higher values like 0.8 will make the output more random,
+        /// while lower values like 0.2 will make it more focused and deterministic.
+        /// </summary>
+        [Preserve]
+        [JsonProperty("temperature")]
+        public double Temperature { get; }
+
+        /// <summary>
+        /// An alternative to sampling with temperature, called nucleus sampling,
+        /// where the model considers the results of the tokens with top_p probability mass.
+        /// So 0.1 means only the tokens comprising the top 10% probability mass are considered.
+        /// </summary>
+        [Preserve]
+        [JsonProperty("top_p")]
+        public double TopP { get; }
+
+        /// <summary>
+        /// Specifies the format that the model must output.
+        /// Setting to <see cref="ChatResponseFormat.Json"/> enables JSON mode,
+        /// which guarantees the message the model generates is valid JSON.
+        /// </summary>
+        /// <remarks>
+        /// Important: When using JSON mode you must still instruct the model to produce JSON yourself via some conversation message,
+        /// for example via your system message. If you don't do this, the model may generate an unending stream of
+        /// whitespace until the generation reaches the token limit, which may take a lot of time and give the appearance
+        /// of a "stuck" request. Also note that the message content may be partial (i.e. cut off) if finish_reason="length",
+        /// which indicates the generation exceeded max_tokens or the conversation exceeded the max context length.
+        /// </remarks>
+        [Preserve]
+        [JsonProperty("response_format")]
+        [JsonConverter(typeof(ResponseFormatConverter))]
+        public ChatResponseFormat ResponseFormat { get; }
+
         [Preserve]
         public static implicit operator string(AssistantResponse assistant) => assistant?.Id;
 

Runtime/Assistants/AssistantFileResponse.cs

@@ -21,7 +21,7 @@ internal AssistantsEndpoint(OpenAIClient client) : base(client) { }
         /// </summary>
         /// <param name="query"><see cref="ListQuery"/>.</param>
         /// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
-        /// <returns><see cref="ListResponse{Assistant}"/></returns>
+        /// <returns><see cref="ListResponse{AssistantResponse}"/></returns>
         public async Task<ListResponse<AssistantResponse>> ListAssistantsAsync(ListQuery query = null, CancellationToken cancellationToken = default)
         {
             var response = await Rest.GetAsync(GetUrl(queryParameters: query), parameters: new RestParameters(client.DefaultRequestHeaders), cancellationToken);
@@ -38,8 +38,8 @@ public async Task<ListResponse<AssistantResponse>> ListAssistantsAsync(ListQuery
         public async Task<AssistantResponse> CreateAssistantAsync(CreateAssistantRequest request = null, CancellationToken cancellationToken = default)
         {
             request ??= new CreateAssistantRequest();
-            var jsonContent = JsonConvert.SerializeObject(request, OpenAIClient.JsonSerializationOptions);
-            var response = await Rest.PostAsync(GetUrl(), jsonContent, new RestParameters(client.DefaultRequestHeaders), cancellationToken);
+            var payload = JsonConvert.SerializeObject(request, OpenAIClient.JsonSerializationOptions);
+            var response = await Rest.PostAsync(GetUrl(), payload, new RestParameters(client.DefaultRequestHeaders), cancellationToken);
             response.Validate(EnableDebug);
             return response.Deserialize<AssistantResponse>(client);
         }
@@ -66,8 +66,8 @@ public async Task<AssistantResponse> RetrieveAssistantAsync(string assistantId,
         /// <returns><see cref="AssistantResponse"/>.</returns>
         public async Task<AssistantResponse> ModifyAssistantAsync(string assistantId, CreateAssistantRequest request, CancellationToken cancellationToken = default)
         {
-            var jsonContent = JsonConvert.SerializeObject(request, OpenAIClient.JsonSerializationOptions);
-            var response = await Rest.PostAsync(GetUrl($"/{assistantId}"), jsonContent, new RestParameters(client.DefaultRequestHeaders), cancellationToken);
+            var payload = JsonConvert.SerializeObject(request, OpenAIClient.JsonSerializationOptions);
+            var response = await Rest.PostAsync(GetUrl($"/{assistantId}"), payload, new RestParameters(client.DefaultRequestHeaders), cancellationToken);
             response.Validate(EnableDebug);
             return response.Deserialize<AssistantResponse>(client);
         }
@@ -82,10 +82,10 @@ public async Task<bool> DeleteAssistantAsync(string assistantId, CancellationTok
         {
             var response = await Rest.DeleteAsync(GetUrl($"/{assistantId}"), new RestParameters(client.DefaultRequestHeaders), cancellationToken);
             response.Validate(EnableDebug);
-            return JsonConvert.DeserializeObject<DeletedResponse>(response.Body, OpenAIClient.JsonSerializationOptions)?.Deleted ?? false;
+            return response.Deserialize<DeletedResponse>(client)?.Deleted ?? false;
         }
 
-        #region Files
+        #region Files (Obsolete)
 
         /// <summary>
         /// Returns a list of assistant files.
@@ -94,6 +94,7 @@ public async Task<bool> DeleteAssistantAsync(string assistantId, CancellationTok
         /// <param name="query"><see cref="ListQuery"/>.</param>
         /// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
         /// <returns><see cref="ListResponse{AssistantFile}"/>.</returns>
+        [Obsolete("Files removed from Assistants. Files now belong to ToolResources.")]
         public async Task<ListResponse<AssistantFileResponse>> ListFilesAsync(string assistantId, ListQuery query = null, CancellationToken cancellationToken = default)
         {
             var response = await Rest.GetAsync(GetUrl($"/{assistantId}/files", query), new RestParameters(client.DefaultRequestHeaders), cancellationToken);
@@ -111,15 +112,16 @@ public async Task<ListResponse<AssistantFileResponse>> ListFilesAsync(string ass
         /// </param>
         /// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
         /// <returns><see cref="AssistantFileResponse"/>.</returns>
+        [Obsolete("Files removed from Assistants. Files now belong to ToolResources.")]
         public async Task<AssistantFileResponse> AttachFileAsync(string assistantId, FileResponse file, CancellationToken cancellationToken = default)
         {
-            if (file?.Purpose?.Equals("assistants") != true)
+            if (file?.Purpose?.Equals(FilePurpose.Assistants) != true)
             {
                 throw new InvalidOperationException($"{nameof(file)}.{nameof(file.Purpose)} must be 'assistants'!");
             }
 
-            var jsonContent = JsonConvert.SerializeObject(new { file_id = file.Id }, OpenAIClient.JsonSerializationOptions);
-            var response = await Rest.PostAsync(GetUrl($"/{assistantId}/files"), jsonContent, new RestParameters(client.DefaultRequestHeaders), cancellationToken);
+            var payload = JsonConvert.SerializeObject(new { file_id = file.Id }, OpenAIClient.JsonSerializationOptions);
+            var response = await Rest.PostAsync(GetUrl($"/{assistantId}/files"), payload, new RestParameters(client.DefaultRequestHeaders), cancellationToken);
             response.Validate(EnableDebug);
             return response.Deserialize<AssistantFileResponse>(client);
         }
@@ -131,6 +133,7 @@ public async Task<AssistantFileResponse> AttachFileAsync(string assistantId, Fil
         /// <param name="fileId">The ID of the file we're getting.</param>
         /// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
         /// <returns><see cref="AssistantFileResponse"/>.</returns>
+        [Obsolete("Files removed from Assistants. Files now belong to ToolResources.")]
         public async Task<AssistantFileResponse> RetrieveFileAsync(string assistantId, string fileId, CancellationToken cancellationToken = default)
         {
             var response = await Rest.GetAsync(GetUrl($"/{assistantId}/files/{fileId}"), new RestParameters(client.DefaultRequestHeaders), cancellationToken);
@@ -150,13 +153,14 @@ public async Task<AssistantFileResponse> RetrieveFileAsync(string assistantId, s
         /// <param name="fileId">The ID of the file to delete.</param>
         /// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
         /// <returns>True, if file was removed.</returns>
+        [Obsolete("Files removed from Assistants. Files now belong to ToolResources.")]
         public async Task<bool> RemoveFileAsync(string assistantId, string fileId, CancellationToken cancellationToken = default)
         {
             var response = await Rest.DeleteAsync(GetUrl($"/{assistantId}/files/{fileId}"), new RestParameters(client.DefaultRequestHeaders), cancellationToken);
             response.Validate(EnableDebug);
-            return JsonConvert.DeserializeObject<DeletedResponse>(response.Body, OpenAIClient.JsonSerializationOptions)?.Deleted ?? false;
+            return response.Deserialize<DeletedResponse>(client)?.Deleted ?? false;
         }
 
-        #endregion Files
+        #endregion Files (Obsolete)
     }
 }