Fix Assistants issues with Message role, Code logs (#81)

CHANGELOG.md

@@ -4,7 +4,14 @@
 
 ## Bugs Fixed
 
-- ([#72](https://github.com/openai/openai-dotnet/issues/72)) Fixed `filename` request encoding in operations using `multipart/form-data`, including `files` and `audio`
+- ([#72](https://github.com/openai/openai-dotnet/issues/72)) Fixed `filename` request encoding in operations using `multipart/form-data`, including `files` and `audio` (commit_hash)
+- ([#79](https://github.com/openai/openai-dotnet/issues/79)) Fixed hard-coded `user` role for caller-created Assistants API messages on threads (commit_hash)
+- Fixed non-streaming Assistants API run step details not reporting code interpreter logs when present
+
+## Breaking Changes
+
+**Assistants (beta)**:
+- `AssistantClient.CreateMessage()` and the explicit constructor for `ThreadInitializationMessage` now require a `MessageRole` parameter. This properly enables the ability to create an Assistant message representing conversation history on a new thread.
 
 ## 2.0.0-beta.5 (2024-06-14)
 
@@ -22,7 +29,7 @@
 
 ## Breaking Changes
 
-**Assistants**:
+**Assistants (beta)**:
 - `InputQuote` is removed from Assistants `TextAnnotation` and `TextAnnotationUpdate`, per [openai/openai-openapi@dd73070b](https://github.com/openai/openai-openapi/commit/dd73070b1d507645d24c249a63ebebd3ec38c0cb) ([1af6569](https://github.com/openai/openai-dotnet/commit/1af6569e2ceae9d840b8826e42d7e3b2569b43f6))
 
 ## Other Changes

examples/Assistants/Example01_RetrievalAugmentedGenerationAsync.cs

@@ -86,13 +86,7 @@ public async Task Example01_RetrievalAugmentedGenerationAsync()
  // Now we'll create a thread with a user query about the data already associated with the assistant, then run it
  ThreadCreationOptions threadOptions = new()
  {
- InitialMessages =
- {
- new ThreadInitializationMessage(new List<MessageContent>()
- {
- MessageContent.FromText("How well did product 113045 sell in February? Graph its trend over time."),
- }),
- },
+ InitialMessages = { "How well did product 113045 sell in February? Graph its trend over time." }
  };
 
  ThreadRun threadRun = await assistantClient.CreateThreadAndRunAsync(assistant.Id, threadOptions);

examples/Assistants/Example02b_FunctionCallingStreaming.cs

@@ -84,6 +84,7 @@ public async Task Example02b_FunctionCallingStreaming()
  AssistantThread thread = await client.CreateThreadAsync();
  ThreadMessage message = await client.CreateMessageAsync(
  thread,
+ MessageRole.User,
  [
  "What's the weather in San Francisco today and the likelihood it'll rain?"
  ]);

examples/Assistants/Example05_AssistantsWithVision.cs

@@ -35,6 +35,7 @@ public void Example05_AssistantsWithVision()
  InitialMessages =
  {
  new ThreadInitializationMessage(
+ MessageRole.User,
  [
  "Hello, assistant! Please compare these two images for me:",
  MessageContent.FromImageFileId(pictureOfAppleFile.Id),

examples/Assistants/Example05_AssistantsWithVisionAsync.cs

@@ -36,6 +36,7 @@ public async Task Example05_AssistantsWithVisionAsync()
  InitialMessages =
  {
  new ThreadInitializationMessage(
+ MessageRole.User,
  [
  "Hello, assistant! Please compare these two images for me:",
  MessageContent.FromImageFileId(pictureOfAppleFile.Id),

src/Custom/Assistants/AssistantClient.Convenience.cs

@@ -99,27 +99,31 @@ public virtual ClientResult<bool> DeleteThread(AssistantThread thread)
  /// Creates a new <see cref="ThreadMessage"/> on an existing <see cref="AssistantThread"/>.
  /// </summary>
  /// <param name="thread"> The thread to associate the new message with. </param>
+ /// <param name="role"> The role to associate with the new message. </param>
  /// <param name="content"> The collection of <see cref="MessageContent"/> items for the message. </param>
  /// <param name="options"> Additional options to apply to the new message. </param>
  /// <returns> A new <see cref="ThreadMessage"/>. </returns>
  public virtual Task<ClientResult<ThreadMessage>> CreateMessageAsync(
  AssistantThread thread,
+ MessageRole role,
  IEnumerable<MessageContent> content,
  MessageCreationOptions options = null)
- => CreateMessageAsync(thread?.Id, content, options);
+ => CreateMessageAsync(thread?.Id, role, content, options);
 
  /// <summary>
  /// Creates a new <see cref="ThreadMessage"/> on an existing <see cref="AssistantThread"/>.
  /// </summary>
  /// <param name="thread"> The thread to associate the new message with. </param>
+ /// <param name="role"> The role to associate with the new message. </param>
  /// <param name="content"> The collection of <see cref="MessageContent"/> items for the message. </param>
  /// <param name="options"> Additional options to apply to the new message. </param>
  /// <returns> A new <see cref="ThreadMessage"/>. </returns>
  public virtual ClientResult<ThreadMessage> CreateMessage(
  AssistantThread thread,
+ MessageRole role,
  IEnumerable<MessageContent> content,
  MessageCreationOptions options = null)
- => CreateMessage(thread?.Id, content, options);
+ => CreateMessage(thread?.Id, role, content, options);
 
  /// <summary>
  /// Returns a collection of <see cref="ThreadMessage"/> instances from an existing <see cref="AssistantThread"/>.

src/Custom/Assistants/AssistantClient.cs

@@ -280,18 +280,21 @@ public virtual ClientResult<bool> DeleteThread(string threadId, CancellationToke
  /// Creates a new <see cref="ThreadMessage"/> on an existing <see cref="AssistantThread"/>.
  /// </summary>
  /// <param name="threadId"> The ID of the thread to associate the new message with. </param>
+ /// <param name="role"> The role to associate with the new message. </param>
  /// <param name="content"> The collection of <see cref="MessageContent"/> items for the message. </param>
  /// <param name="options"> Additional options to apply to the new message. </param>
  /// <param name="cancellationToken">A token that can be used to cancel this method call.</param>
  /// <returns> A new <see cref="ThreadMessage"/>. </returns>
  public virtual async Task<ClientResult<ThreadMessage>> CreateMessageAsync(
  string threadId,
+ MessageRole role,
  IEnumerable<MessageContent> content,
  MessageCreationOptions options = null, 
  CancellationToken cancellationToken = default)
  {
  Argument.AssertNotNullOrEmpty(threadId, nameof(threadId));
  options ??= new();
+ options.Role = role;
  options.Content.Clear();
  foreach (MessageContent contentItem in content)
  {
@@ -307,18 +310,21 @@ public virtual async Task<ClientResult<ThreadMessage>> CreateMessageAsync(
  /// Creates a new <see cref="ThreadMessage"/> on an existing <see cref="AssistantThread"/>.
  /// </summary>
  /// <param name="threadId"> The ID of the thread to associate the new message with. </param>
+ /// <param name="role"> The role to associate with the new message. </param>
  /// <param name="content"> The collection of <see cref="MessageContent"/> items for the message. </param>
  /// <param name="options"> Additional options to apply to the new message. </param>
  /// <param name="cancellationToken">A token that can be used to cancel this method call.</param>
  /// <returns> A new <see cref="ThreadMessage"/>. </returns>
  public virtual ClientResult<ThreadMessage> CreateMessage(
  string threadId,
+ MessageRole role,
  IEnumerable<MessageContent> content,
  MessageCreationOptions options = null,
  CancellationToken cancellationToken = default)
  {
  Argument.AssertNotNullOrEmpty(threadId, nameof(threadId));
  options ??= new();
+ options.Role = role;
  options.Content.Clear();
  foreach (MessageContent contentItem in content)
  {

src/Custom/Assistants/AssistantCreationOptions.cs

@@ -50,6 +50,5 @@ public AssistantCreationOptions()
  {
  Metadata = new ChangeTrackingDictionary<string, string>();
  Tools = new ChangeTrackingList<ToolDefinition>();
- ToolResources = new();
  }
 }

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

@@ -207,13 +207,6 @@ internal readonly partial struct InternalListRunStepsResponseObject {}
 [CodeGenModel("RunStepDetailsToolCallsFileSearchObject")]
 internal partial class InternalRunStepFileSearchToolCallDetails { }
 
-[CodeGenModel("RunStepDetailsToolCallsCodeOutputLogsObject")]
-internal partial class InternalRunStepDetailsToolCallsCodeOutputLogsObject
-{
- [CodeGenMember("Logs")]
- internal string InternalLogs { get; }
-}
-
 [CodeGenModel("RunTruncationStrategyType")]
 internal readonly partial struct InternalRunTruncationStrategyType { }
 

src/Custom/Assistants/Internal/InternalRunStepCodeInterpreterLogOutput.cs

@@ -1,6 +1,7 @@
 namespace OpenAI.Assistants
 {
  /// <summary> Text output from the Code Interpreter tool call as part of a run step. </summary>
+ [CodeGenModel("RunStepDetailsToolCallsCodeOutputLogsObject")]
  internal partial class InternalRunStepCodeInterpreterLogOutput : RunStepCodeInterpreterOutput
  {
  /// <summary> The text output from the Code Interpreter tool call. </summary>

src/Custom/Assistants/MessageCreationOptions.cs

@@ -11,6 +11,11 @@ namespace OpenAI.Assistants;
 [CodeGenSerialization(nameof(Content), SerializationValueHook=nameof(SerializeContent))]
 public partial class MessageCreationOptions
 {
+ // CUSTOM: role is hidden, as this required property is promoted to a method parameter
+
+ [CodeGenMember("Role")]
+ internal MessageRole Role { get; set; }
+
  // CUSTOM: content is hidden to allow the promotion of required request information into top-level
  // method signatures.
 

src/Custom/Assistants/RunStepCodeInterpreterOutput.cs

@@ -5,7 +5,7 @@ public abstract partial class RunStepCodeInterpreterOutput
  /// <inheritdoc cref="InternalRunStepDetailsToolCallsCodeOutputImageObject.FileId"/>
  public string ImageFileId => AsInternalImage?.FileId;
  /// <inheritdoc cref="InternalRunStepCodeInterpreterLogOutput.Logs"/>
- public string Logs => AsInternalLogs?.Logs;
+ public string Logs => AsInternalLogs?.InternalLogs;
 
  private InternalRunStepDetailsToolCallsCodeOutputImageObject AsInternalImage => this as InternalRunStepDetailsToolCallsCodeOutputImageObject;
  private InternalRunStepCodeInterpreterLogOutput AsInternalLogs => this as InternalRunStepCodeInterpreterLogOutput;

src/Custom/Assistants/ThreadInitializationMessage.cs

@@ -10,21 +10,24 @@ public partial class ThreadInitializationMessage : MessageCreationOptions
  /// <param name="content">
  /// The content items that should be included in the message, added to the thread being created.
  /// </param>
- public ThreadInitializationMessage(IEnumerable<MessageContent> content) : base(content)
- { }
+ public ThreadInitializationMessage(MessageRole role, IEnumerable<MessageContent> content) : base(content)
+ {
+ Role = role;
+ }
 
  internal ThreadInitializationMessage(MessageCreationOptions baseOptions)
  : base(baseOptions.Role, baseOptions.Content, baseOptions.Attachments, baseOptions.Metadata, null)
  { }
 
  /// <summary>
  /// Implicitly creates a new instance of <see cref="ThreadInitializationMessage"/> from a single item of plain text
- /// content.
+ /// content, assuming the role of <see cref="MessageRole.User"/>.
  /// </summary>
  /// <remarks>
  /// Using a <see cref="string"/> in the position of a <see cref="ThreadInitializationMessage"/> is equivalent to
- /// using the <see cref="ThreadInitializationMessage(IEnumerable{MessageContent})"/> constructor with a single
- /// <see cref="MessageContent.FromText(string)"/> content instance.
+ /// using the <see cref="ThreadInitializationMessage(MessageRole,IEnumerable{MessageContent})"/> constructor with
+ /// <see cref="MessageRole.User"/> and a single <see cref="MessageContent.FromText(string)"/> content instance.
  /// </remarks>
- public static implicit operator ThreadInitializationMessage(string initializationMessage) => new([initializationMessage]);
+ public static implicit operator ThreadInitializationMessage(string initializationMessage)
+ => new(MessageRole.User, [initializationMessage]);
 }

src/Generated/Models/InternalRunStepDetailsToolCallsCodeOutputLogsObject.Serialization.cs → src/Generated/Models/InternalRunStepCodeInterpreterLogOutput.Serialization.cs

@@ -10,14 +10,14 @@
 
 namespace OpenAI.Assistants
 {
- internal partial class InternalRunStepDetailsToolCallsCodeOutputLogsObject : IJsonModel<InternalRunStepDetailsToolCallsCodeOutputLogsObject>
+ internal partial class InternalRunStepCodeInterpreterLogOutput : IJsonModel<InternalRunStepCodeInterpreterLogOutput>
  {
- void IJsonModel<InternalRunStepDetailsToolCallsCodeOutputLogsObject>.Write(Utf8JsonWriter writer, ModelReaderWriterOptions options)
+ void IJsonModel<InternalRunStepCodeInterpreterLogOutput>.Write(Utf8JsonWriter writer, ModelReaderWriterOptions options)
  {
- var format = options.Format == "W" ? ((IPersistableModel<InternalRunStepDetailsToolCallsCodeOutputLogsObject>)this).GetFormatFromOptions(options) : options.Format;
+ var format = options.Format == "W" ? ((IPersistableModel<InternalRunStepCodeInterpreterLogOutput>)this).GetFormatFromOptions(options) : options.Format;
  if (format != "J")
  {
- throw new FormatException($"The model {nameof(InternalRunStepDetailsToolCallsCodeOutputLogsObject)} does not support writing '{format}' format.");
+ throw new FormatException($"The model {nameof(InternalRunStepCodeInterpreterLogOutput)} does not support writing '{format}' format.");
  }
 
  writer.WriteStartObject();
@@ -43,19 +43,19 @@ void IJsonModel<InternalRunStepDetailsToolCallsCodeOutputLogsObject>.Write(Utf8J
  writer.WriteEndObject();
  }
 
- InternalRunStepDetailsToolCallsCodeOutputLogsObject IJsonModel<InternalRunStepDetailsToolCallsCodeOutputLogsObject>.Create(ref Utf8JsonReader reader, ModelReaderWriterOptions options)
+ InternalRunStepCodeInterpreterLogOutput IJsonModel<InternalRunStepCodeInterpreterLogOutput>.Create(ref Utf8JsonReader reader, ModelReaderWriterOptions options)
  {
- var format = options.Format == "W" ? ((IPersistableModel<InternalRunStepDetailsToolCallsCodeOutputLogsObject>)this).GetFormatFromOptions(options) : options.Format;
+ var format = options.Format == "W" ? ((IPersistableModel<InternalRunStepCodeInterpreterLogOutput>)this).GetFormatFromOptions(options) : options.Format;
  if (format != "J")
  {
- throw new FormatException($"The model {nameof(InternalRunStepDetailsToolCallsCodeOutputLogsObject)} does not support reading '{format}' format.");
+ throw new FormatException($"The model {nameof(InternalRunStepCodeInterpreterLogOutput)} does not support reading '{format}' format.");
  }
 
  using JsonDocument document = JsonDocument.ParseValue(ref reader);
- return DeserializeInternalRunStepDetailsToolCallsCodeOutputLogsObject(document.RootElement, options);
+ return DeserializeInternalRunStepCodeInterpreterLogOutput(document.RootElement, options);
  }
 
- internal static InternalRunStepDetailsToolCallsCodeOutputLogsObject DeserializeInternalRunStepDetailsToolCallsCodeOutputLogsObject(JsonElement element, ModelReaderWriterOptions options = null)
+ internal static InternalRunStepCodeInterpreterLogOutput DeserializeInternalRunStepCodeInterpreterLogOutput(JsonElement element, ModelReaderWriterOptions options = null)
  {
  options ??= ModelSerializationExtensions.WireOptions;
 
@@ -85,44 +85,44 @@ internal static InternalRunStepDetailsToolCallsCodeOutputLogsObject DeserializeI
  }
  }
  serializedAdditionalRawData = rawDataDictionary;
- return new InternalRunStepDetailsToolCallsCodeOutputLogsObject(type, serializedAdditionalRawData, logs);
+ return new InternalRunStepCodeInterpreterLogOutput(type, serializedAdditionalRawData, logs);
  }
 
- BinaryData IPersistableModel<InternalRunStepDetailsToolCallsCodeOutputLogsObject>.Write(ModelReaderWriterOptions options)
+ BinaryData IPersistableModel<InternalRunStepCodeInterpreterLogOutput>.Write(ModelReaderWriterOptions options)
  {
- var format = options.Format == "W" ? ((IPersistableModel<InternalRunStepDetailsToolCallsCodeOutputLogsObject>)this).GetFormatFromOptions(options) : options.Format;
+ var format = options.Format == "W" ? ((IPersistableModel<InternalRunStepCodeInterpreterLogOutput>)this).GetFormatFromOptions(options) : options.Format;
 
  switch (format)
  {
  case "J":
  return ModelReaderWriter.Write(this, options);
  default:
- throw new FormatException($"The model {nameof(InternalRunStepDetailsToolCallsCodeOutputLogsObject)} does not support writing '{options.Format}' format.");
+ throw new FormatException($"The model {nameof(InternalRunStepCodeInterpreterLogOutput)} does not support writing '{options.Format}' format.");
  }
  }
 
- InternalRunStepDetailsToolCallsCodeOutputLogsObject IPersistableModel<InternalRunStepDetailsToolCallsCodeOutputLogsObject>.Create(BinaryData data, ModelReaderWriterOptions options)
+ InternalRunStepCodeInterpreterLogOutput IPersistableModel<InternalRunStepCodeInterpreterLogOutput>.Create(BinaryData data, ModelReaderWriterOptions options)
  {
- var format = options.Format == "W" ? ((IPersistableModel<InternalRunStepDetailsToolCallsCodeOutputLogsObject>)this).GetFormatFromOptions(options) : options.Format;
+ var format = options.Format == "W" ? ((IPersistableModel<InternalRunStepCodeInterpreterLogOutput>)this).GetFormatFromOptions(options) : options.Format;
 
  switch (format)
  {
  case "J":
  {
  using JsonDocument document = JsonDocument.Parse(data);
- return DeserializeInternalRunStepDetailsToolCallsCodeOutputLogsObject(document.RootElement, options);
+ return DeserializeInternalRunStepCodeInterpreterLogOutput(document.RootElement, options);
  }
  default:
- throw new FormatException($"The model {nameof(InternalRunStepDetailsToolCallsCodeOutputLogsObject)} does not support reading '{options.Format}' format.");
+ throw new FormatException($"The model {nameof(InternalRunStepCodeInterpreterLogOutput)} does not support reading '{options.Format}' format.");
  }
  }
 
- string IPersistableModel<InternalRunStepDetailsToolCallsCodeOutputLogsObject>.GetFormatFromOptions(ModelReaderWriterOptions options) => "J";
+ string IPersistableModel<InternalRunStepCodeInterpreterLogOutput>.GetFormatFromOptions(ModelReaderWriterOptions options) => "J";
 
- internal static new InternalRunStepDetailsToolCallsCodeOutputLogsObject FromResponse(PipelineResponse response)
+ internal static new InternalRunStepCodeInterpreterLogOutput FromResponse(PipelineResponse response)
  {
  using var document = JsonDocument.Parse(response.Content);
- return DeserializeInternalRunStepDetailsToolCallsCodeOutputLogsObject(document.RootElement);
+ return DeserializeInternalRunStepCodeInterpreterLogOutput(document.RootElement);
  }
 
  internal override BinaryContent ToBinaryContent()

src/Generated/Models/InternalRunStepCodeInterpreterLogOutput.cs

@@ -0,0 +1,29 @@
+// <auto-generated/>
+
+#nullable disable
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenAI.Assistants
+{
+ internal partial class InternalRunStepCodeInterpreterLogOutput : RunStepCodeInterpreterOutput
+ {
+ internal InternalRunStepCodeInterpreterLogOutput(string internalLogs)
+ {
+ Argument.AssertNotNull(internalLogs, nameof(internalLogs));
+
+ Type = "logs";
+ InternalLogs = internalLogs;
+ }
+
+ internal InternalRunStepCodeInterpreterLogOutput(string type, IDictionary<string, BinaryData> serializedAdditionalRawData, string internalLogs) : base(type, serializedAdditionalRawData)
+ {
+ InternalLogs = internalLogs;
+ }
+
+ internal InternalRunStepCodeInterpreterLogOutput()
+ {
+ }
+ }
+}