hide convenience APIs

Author: christothes

api/OpenAI.net8.0.cs

@@ -86,7 +86,7 @@ internal CreateResponseOptions(IDictionary<string, string> metadata, float? temp
 
         public ResponseTruncationMode? Truncation { get; set; }
 
-        public IList<ResponseItem> Input { get; }
+        public IList<ResponseItem> Input { get; internal set; }
 
         public IList<Includable> Include { get; set; }
 
@@ -125,5 +125,13 @@ [.. responseCreationOptions.Include.Select(x => x.ToIncludable())],
                 responseCreationOptions.Stream,
                 new JsonPatch());
         }
+
+        internal CreateResponseOptions GetClone()
+        {
+            CreateResponseOptions copiedOptions = (CreateResponseOptions)this.MemberwiseClone();
+            copiedOptions.Patch = _patch;
+
+            return copiedOptions;
+        }
     }
 }

api/OpenAI.netstandard2.0.cs

@@ -117,13 +117,13 @@ protected internal OpenAIResponseClient(ClientPipeline pipeline, string model, O
     /// Gets the endpoint URI for the service.
     /// </summary>
     [Experimental("OPENAI001")]
-    public Uri Endpoint => _endpoint;
+    public virtual Uri Endpoint => _endpoint;
 
     /// <summary>
     /// Gets the name of the model used in requests sent to the service.
     /// </summary>
     [Experimental("OPENAI001")]
-    public string Model => _model;
+    public virtual string Model => _model;
 
     internal virtual Task<ClientResult<OpenAIResponse>> CreateResponseAsync(IEnumerable<ResponseItem> inputItems, ResponseCreationOptions options = null, CancellationToken cancellationToken = default)
     {
@@ -180,15 +180,15 @@ public virtual ClientResult<ResponseResult> CreateResponse(CreateResponseOptions
     {
         Argument.AssertNotNull(options, nameof(options));
 
-        ClientResult result = this.CreateResponse(options, cancellationToken.CanBeCanceled ? new RequestOptions { CancellationToken = cancellationToken } : null);
+        ClientResult result = this.CreateResponse(CreatePerCallOptions(options), cancellationToken.CanBeCanceled ? new RequestOptions { CancellationToken = cancellationToken } : null);
         return ClientResult.FromValue((ResponseResult)result.GetRawResponse().Content, result.GetRawResponse());
     }
 
     public virtual async Task<ClientResult<ResponseResult>> CreateResponseAsync(CreateResponseOptions options, CancellationToken cancellationToken = default)
     {
         Argument.AssertNotNull(options, nameof(options));
 
-        ClientResult result = await this.CreateResponseAsync(options, cancellationToken.CanBeCanceled ? new RequestOptions { CancellationToken = cancellationToken } : null).ConfigureAwait(false);
+        ClientResult result = await this.CreateResponseAsync(CreatePerCallOptions(options), cancellationToken.CanBeCanceled ? new RequestOptions { CancellationToken = cancellationToken } : null).ConfigureAwait(false);
         return ClientResult.FromValue((ResponseResult)result.GetRawResponse().Content, result.GetRawResponse());
     }
 
@@ -215,7 +215,7 @@ internal AsyncCollectionResult<StreamingResponseUpdate> CreateResponseStreamingA
 
     public virtual AsyncCollectionResult<StreamingResponseUpdate> CreateResponseStreamingAsync(CreateResponseOptions options, CancellationToken cancellationToken = default)
     {
-        return CreateResponseStreamingAsync(options, cancellationToken.ToRequestOptions(streaming: true));
+        return CreateResponseStreamingAsync(CreatePerCallOptions(options, true), cancellationToken.ToRequestOptions(streaming: true));
     }
 
     internal AsyncCollectionResult<StreamingResponseUpdate> CreateResponseStreamingAsync(CreateResponseOptions options, RequestOptions requestOptions)
@@ -249,7 +249,7 @@ public virtual CollectionResult<StreamingResponseUpdate> CreateResponseStreaming
         Argument.AssertNotNull(options, nameof(options));
 
         return new SseUpdateCollection<StreamingResponseUpdate>(
-            () => CreateResponse(options, cancellationToken.ToRequestOptions(streaming: true)),
+            () => CreateResponse(CreatePerCallOptions(options, true), cancellationToken.ToRequestOptions(streaming: true)),
             StreamingResponseUpdate.DeserializeStreamingResponseUpdate,
             cancellationToken);
     }
@@ -438,7 +438,26 @@ internal virtual ResponseCreationOptions CreatePerCallOptions(ResponseCreationOp
             : userOptions.GetClone();
 
         copiedOptions.Input = inputItems.ToList();
-        copiedOptions.Model = _model;
+        copiedOptions.Model = Model;
+
+        if (stream)
+        {
+            copiedOptions.Stream = true;
+        }
+
+        return copiedOptions;
+    }
+
+    internal virtual CreateResponseOptions CreatePerCallOptions(CreateResponseOptions userOptions, bool stream = false)
+    {
+        CreateResponseOptions copiedOptions = userOptions is null
+            ? new()
+            : userOptions.GetClone();
+
+        if (copiedOptions.Model is null)
+        {
+            copiedOptions.Model = Model;
+        }
 
         if (stream)
         {

src/Custom/Responses/CreateResponseOptions.cs

@@ -118,5 +118,14 @@ internal ResponseResult(IDictionary<string, string> metadata, float? temperature
         public ResponseTokenUsage Usage { get; }
 
         public bool ParallelToolCalls { get; }
+
+        public string GetOutputText()
+        {
+            IEnumerable<string> outputTextSegments = Output.Where(item => item is InternalResponsesAssistantMessage)
+                .Select(item => item as InternalResponsesAssistantMessage)
+                .SelectMany(message => message.Content.Where(contentPart => contentPart.Kind == ResponseContentPartKind.OutputText)
+                    .Select(outputTextPart => outputTextPart.Text));
+            return outputTextSegments.Any() ? string.Concat(outputTextSegments) : null;
+        }
     }
 }

src/Custom/Responses/OpenAIResponseClient.cs

@@ -488,7 +488,9 @@ public async Task StreamingResponses()
             }
             else if (update is StreamingResponseCompletedUpdate responseCompletedUpdate)
             {
-                finalResponseText = responseCompletedUpdate.Response.OutputText;
+                finalResponseText = responseCompletedUpdate.Response.Output[0] is MessageResponseItem messageItem
+                    ? messageItem.Content[0].Text
+                    : null;
             }
         }
         Assert.That(deltaTextSegments, Has.Count.GreaterThan(0));
@@ -664,12 +666,13 @@ public async Task OutputTextMethod()
     {
         OpenAIResponseClient client = GetTestClient();
         ResponseResult response = await client.CreateResponseAsync(
-            new ([ResponseItem.CreateUserMessageItem("Respond with only the word hello.")]));
-        Assert.That(response?.OutputText?.Length, Is.GreaterThan(0).And.LessThan(7));
-        Assert.That(response?.OutputText?.ToLower(), Does.Contain("hello"));
+            new([ResponseItem.CreateUserMessageItem("Respond with only the word hello.")]));
+        var outputText = response.GetOutputText();
+        Assert.That(outputText.Length, Is.GreaterThan(0).And.LessThan(7));
+        Assert.That(outputText.ToLower(), Does.Contain("hello"));
 
         response.Output.Add(ResponseItem.CreateAssistantMessageItem("More text!"));
-        Assert.That(response?.OutputText?.ToLower(), Does.EndWith("more text!"));
+        Assert.That(response.GetOutputText().ToLower(), Does.EndWith("more text!"));
 
         response = await client.CreateResponseAsync(
             new ([ResponseItem.CreateUserMessageItem("How's the weather?")])
@@ -751,7 +754,7 @@ public async Task FileInputFromIdWorks()
 
         ResponseResult response = await client.CreateResponseAsync(new([messageItem]));
 
-        Assert.That(response?.OutputText?.ToLower(), Does.Contain("pizza"));
+        Assert.That(response?.GetOutputText().ToLower(), Does.Contain("pizza"));
     }
 
     [RecordedTest]
@@ -771,7 +774,7 @@ public async Task FileInputFromBinaryWorks()
 
         ResponseResult response = await client.CreateResponseAsync(new([messageItem]));
 
-        Assert.That(response?.OutputText?.ToLower(), Does.Contain("pizza"));
+        Assert.That(response?.GetOutputText(), Does.Contain("pizza"));
     }
 
     [RecordedTest]