From 0a1c6a0135d997baa5475d1f6417772bae160a05 Mon Sep 17 00:00:00 2001
From: Stevan Freeborn <65925598+StevanFreeborn@users.noreply.github.com>
Date: Mon, 19 May 2025 19:52:16 +0000
Subject: [PATCH 1/8] fix: copilot first attempt

---
 src/AnthropicClient/AnthropicApiClient.cs  | 112 +++++++++------------
 src/AnthropicClient/IAnthropicApiClient.cs |  39 ++++---
 2 files changed, 75 insertions(+), 76 deletions(-)

diff --git a/src/AnthropicClient/AnthropicApiClient.cs b/src/AnthropicClient/AnthropicApiClient.cs
index 826b735..5ea4e02 100644
--- a/src/AnthropicClient/AnthropicApiClient.cs
+++ b/src/AnthropicClient/AnthropicApiClient.cs
@@ -1,4 +1,5 @@
 using System.Net.Http.Headers;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Text.Json;
 
@@ -50,13 +51,12 @@ public AnthropicApiClient(string apiKey, HttpClient httpClient)
       _httpClient.DefaultRequestHeaders.Add(pair.Key, pair.Value);
     }
   }
-
   /// <inheritdoc/>
-  public async Task<AnthropicResult<MessageResponse>> CreateMessageAsync(MessageRequest request)
+  public async Task<AnthropicResult<MessageResponse>> CreateMessageAsync(MessageRequest request, CancellationToken cancellationToken = default)
   {
-    var response = await SendRequestAsync(MessagesEndpoint, request);
+    var response = await SendRequestAsync(MessagesEndpoint, request, cancellationToken);
     var anthropicHeaders = new AnthropicHeaders(response.Headers);
-    var responseContent = await response.Content.ReadAsStringAsync();
+    var responseContent = await response.Content.ReadAsStringAsync(cancellationToken);
 
     if (response.IsSuccessStatusCode is false)
     {
@@ -75,13 +75,13 @@ public async Task<AnthropicResult<MessageResponse>> CreateMessageAsync(MessageRe
   }
 
   /// <inheritdoc/>
-  public async IAsyncEnumerable<AnthropicEvent> CreateMessageAsync(StreamMessageRequest request)
+  public async IAsyncEnumerable<AnthropicEvent> CreateMessageAsync(StreamMessageRequest request, [EnumeratorCancellation] CancellationToken cancellationToken = default)
   {
-    var response = await SendRequestAsync(MessagesEndpoint, request);
+    var response = await SendRequestAsync(MessagesEndpoint, request, cancellationToken);
 
     if (response.IsSuccessStatusCode is false)
     {
-      var error = Deserialize<AnthropicError>(await response.Content.ReadAsStringAsync()) ?? new AnthropicError();
+      var error = Deserialize<AnthropicError>(await response.Content.ReadAsStringAsync(cancellationToken)) ?? new AnthropicError();
       yield return new AnthropicEvent(EventType.Error, new ErrorEventData(error.Error));
       yield break;
     }
@@ -237,73 +237,66 @@ msgResponse is not null
       }
     } while (true);
   }
-
   /// <inheritdoc/>
-  public async Task<AnthropicResult<MessageBatchResponse>> CreateMessageBatchAsync(MessageBatchRequest request)
+  public async Task<AnthropicResult<MessageBatchResponse>> CreateMessageBatchAsync(MessageBatchRequest request, CancellationToken cancellationToken = default)
   {
-    var response = await SendRequestAsync(MessageBatchesEndpoint, request);
-    return await CreateResultAsync<MessageBatchResponse>(response);
+    var response = await SendRequestAsync(MessageBatchesEndpoint, request, cancellationToken);
+    return await CreateResultAsync<MessageBatchResponse>(response, cancellationToken);
   }
-
   /// <inheritdoc/>
-  public async Task<AnthropicResult<MessageBatchResponse>> GetMessageBatchAsync(string batchId)
+  public async Task<AnthropicResult<MessageBatchResponse>> GetMessageBatchAsync(string batchId, CancellationToken cancellationToken = default)
   {
-    var response = await SendRequestAsync($"{MessageBatchesEndpoint}/{batchId}");
-    return await CreateResultAsync<MessageBatchResponse>(response);
+    var response = await SendRequestAsync($"{MessageBatchesEndpoint}/{batchId}", cancellationToken: cancellationToken);
+    return await CreateResultAsync<MessageBatchResponse>(response, cancellationToken);
   }
-
   /// <inheritdoc/>
-  public async Task<AnthropicResult<Page<MessageBatchResponse>>> ListMessageBatchesAsync(PagingRequest? request = null)
+  public async Task<AnthropicResult<Page<MessageBatchResponse>>> ListMessageBatchesAsync(PagingRequest? request = null, CancellationToken cancellationToken = default)
   {
     var pagingRequest = request ?? new PagingRequest();
     var endpoint = $"{MessageBatchesEndpoint}?{pagingRequest.ToQueryParameters()}";
-    var response = await SendRequestAsync(endpoint);
-    return await CreateResultAsync<Page<MessageBatchResponse>>(response);
+    var response = await SendRequestAsync(endpoint, cancellationToken: cancellationToken);
+    return await CreateResultAsync<Page<MessageBatchResponse>>(response, cancellationToken);
   }
-
   /// <inheritdoc/>
-  public async IAsyncEnumerable<AnthropicResult<Page<MessageBatchResponse>>> ListAllMessageBatchesAsync(int limit = 20)
+  public async IAsyncEnumerable<AnthropicResult<Page<MessageBatchResponse>>> ListAllMessageBatchesAsync(int limit = 20, [EnumeratorCancellation] CancellationToken cancellationToken = default)
   {
-    await foreach (var result in GetAllPagesAsync<MessageBatchResponse>(MessageBatchesEndpoint, limit))
+    await foreach (var result in GetAllPagesAsync<MessageBatchResponse>(MessageBatchesEndpoint, limit, cancellationToken))
     {
       yield return result;
     }
   }
-
   /// <inheritdoc/>
-  public async Task<AnthropicResult<MessageBatchResponse>> CancelMessageBatchAsync(string batchId)
+  public async Task<AnthropicResult<MessageBatchResponse>> CancelMessageBatchAsync(string batchId, CancellationToken cancellationToken = default)
   {
     var endpoint = $"{MessageBatchesEndpoint}/{batchId}/cancel";
-    var response = await SendRequestAsync(endpoint, HttpMethod.Post);
-    return await CreateResultAsync<MessageBatchResponse>(response);
+    var response = await SendRequestAsync(endpoint, HttpMethod.Post, cancellationToken);
+    return await CreateResultAsync<MessageBatchResponse>(response, cancellationToken);
   }
-
   /// <inheritdoc/>
-  public async Task<AnthropicResult<MessageBatchDeleteResponse>> DeleteMessageBatchAsync(string batchId)
+  public async Task<AnthropicResult<MessageBatchDeleteResponse>> DeleteMessageBatchAsync(string batchId, CancellationToken cancellationToken = default)
   {
     var endpoint = $"{MessageBatchesEndpoint}/{batchId}";
-    var response = await SendRequestAsync(endpoint, HttpMethod.Delete);
-    return await CreateResultAsync<MessageBatchDeleteResponse>(response);
+    var response = await SendRequestAsync(endpoint, HttpMethod.Delete, cancellationToken);
+    return await CreateResultAsync<MessageBatchDeleteResponse>(response, cancellationToken);
   }
-
   /// <inheritdoc/>
-  public async Task<AnthropicResult<IAsyncEnumerable<MessageBatchResultItem>>> GetMessageBatchResultsAsync(string batchId)
+  public async Task<AnthropicResult<IAsyncEnumerable<MessageBatchResultItem>>> GetMessageBatchResultsAsync(string batchId, CancellationToken cancellationToken = default)
   {
-    var response = await SendRequestAsync($"{MessageBatchesEndpoint}/{batchId}/results");
+    var response = await SendRequestAsync($"{MessageBatchesEndpoint}/{batchId}/results", cancellationToken: cancellationToken);
     var anthropicHeaders = new AnthropicHeaders(response.Headers);
 
     if (response.IsSuccessStatusCode is false)
     {
-      var content = await response.Content.ReadAsStringAsync();
+      var content = await response.Content.ReadAsStringAsync(cancellationToken);
       var error = Deserialize<AnthropicError>(content) ?? new AnthropicError();
       return AnthropicResult<IAsyncEnumerable<MessageBatchResultItem>>.Failure(error, anthropicHeaders);
     }
 
     return AnthropicResult<IAsyncEnumerable<MessageBatchResultItem>>.Success(ReadResultsAsync(), anthropicHeaders);
 
-    async IAsyncEnumerable<MessageBatchResultItem> ReadResultsAsync()
+    async IAsyncEnumerable<MessageBatchResultItem> ReadResultsAsync([EnumeratorCancellation] CancellationToken ct = default)
     {
-      using var responseContent = await response.Content.ReadAsStreamAsync();
+      using var responseContent = await response.Content.ReadAsStreamAsync(ct);
       using var streamReader = new StreamReader(responseContent);
 
       var line = await streamReader.ReadLineAsync();
@@ -317,41 +310,36 @@ async IAsyncEnumerable<MessageBatchResultItem> ReadResultsAsync()
       }
     }
   }
-
   /// <inheritdoc/>
-  public async Task<AnthropicResult<TokenCountResponse>> CountMessageTokensAsync(CountMessageTokensRequest request)
+  public async Task<AnthropicResult<TokenCountResponse>> CountMessageTokensAsync(CountMessageTokensRequest request, CancellationToken cancellationToken = default)
   {
-    var response = await SendRequestAsync(CountTokensEndpoint, request);
-    return await CreateResultAsync<TokenCountResponse>(response);
+    var response = await SendRequestAsync(CountTokensEndpoint, request, cancellationToken);
+    return await CreateResultAsync<TokenCountResponse>(response, cancellationToken);
   }
-
   /// <inheritdoc/>
-  public async Task<AnthropicResult<Page<AnthropicModel>>> ListModelsAsync(PagingRequest? request = null)
+  public async Task<AnthropicResult<Page<AnthropicModel>>> ListModelsAsync(PagingRequest? request = null, CancellationToken cancellationToken = default)
   {
     var pagingRequest = request ?? new PagingRequest();
     var endpoint = $"{ModelsEndpoint}?{pagingRequest.ToQueryParameters()}";
-    var response = await SendRequestAsync(endpoint);
-    return await CreateResultAsync<Page<AnthropicModel>>(response);
+    var response = await SendRequestAsync(endpoint, cancellationToken: cancellationToken);
+    return await CreateResultAsync<Page<AnthropicModel>>(response, cancellationToken);
   }
-
   /// <inheritdoc/>
-  public async IAsyncEnumerable<AnthropicResult<Page<AnthropicModel>>> ListAllModelsAsync(int limit = 20)
+  public async IAsyncEnumerable<AnthropicResult<Page<AnthropicModel>>> ListAllModelsAsync(int limit = 20, [EnumeratorCancellation] CancellationToken cancellationToken = default)
   {
-    await foreach (var result in GetAllPagesAsync<AnthropicModel>(ModelsEndpoint, limit))
+    await foreach (var result in GetAllPagesAsync<AnthropicModel>(ModelsEndpoint, limit, cancellationToken))
     {
       yield return result;
     }
   }
-
   /// <inheritdoc/>
-  public async Task<AnthropicResult<AnthropicModel>> GetModelAsync(string modelId)
+  public async Task<AnthropicResult<AnthropicModel>> GetModelAsync(string modelId, CancellationToken cancellationToken = default)
   {
     var endpoint = $"{ModelsEndpoint}/{modelId}";
-    var response = await SendRequestAsync(endpoint);
-    return await CreateResultAsync<AnthropicModel>(response);
+    var response = await SendRequestAsync(endpoint, cancellationToken: cancellationToken);
+    return await CreateResultAsync<AnthropicModel>(response, cancellationToken);
   }
-
-  private async IAsyncEnumerable<AnthropicResult<Page<T>>> GetAllPagesAsync<T>(string endpoint, int limit = 20)
+  private async IAsyncEnumerable<AnthropicResult<Page<T>>> GetAllPagesAsync<T>(string endpoint, int limit = 20, [EnumeratorCancellation] CancellationToken cancellationToken = default)
   {
     var pagingRequest = new PagingRequest(limit: limit);
     string Endpoint() => $"{endpoint}?{pagingRequest.ToQueryParameters()}";
@@ -359,9 +347,9 @@ private async IAsyncEnumerable<AnthropicResult<Page<T>>> GetAllPagesAsync<T>(str
 
     do
     {
-      var response = await SendRequestAsync(Endpoint());
+      var response = await SendRequestAsync(Endpoint(), cancellationToken: cancellationToken);
       var anthropicHeaders = new AnthropicHeaders(response.Headers);
-      var responseContent = await response.Content.ReadAsStringAsync();
+      var responseContent = await response.Content.ReadAsStringAsync(cancellationToken);
 
       if (response.IsSuccessStatusCode is false)
       {
@@ -404,11 +392,10 @@ private async IAsyncEnumerable<AnthropicResult<Page<T>>> GetAllPagesAsync<T>(str
 
     return new ToolCall(tool, toolUse);
   }
-
-  private async Task<AnthropicResult<T>> CreateResultAsync<T>(HttpResponseMessage response) where T : new()
+  private async Task<AnthropicResult<T>> CreateResultAsync<T>(HttpResponseMessage response, CancellationToken cancellationToken = default) where T : new()
   {
     var anthropicHeaders = new AnthropicHeaders(response.Headers);
-    var responseContent = await response.Content.ReadAsStringAsync();
+    var responseContent = await response.Content.ReadAsStringAsync(cancellationToken);
 
     if (response.IsSuccessStatusCode is false)
     {
@@ -419,18 +406,17 @@ private async IAsyncEnumerable<AnthropicResult<Page<T>>> GetAllPagesAsync<T>(str
     var model = Deserialize<T>(responseContent) ?? new T();
     return AnthropicResult<T>.Success(model, anthropicHeaders);
   }
-
-  private async Task<HttpResponseMessage> SendRequestAsync(string endpoint, HttpMethod? method = null)
+  private async Task<HttpResponseMessage> SendRequestAsync(string endpoint, HttpMethod? method = null, CancellationToken cancellationToken = default)
   {
     var request = new HttpRequestMessage(method ?? HttpMethod.Get, endpoint);
-    return await _httpClient.SendAsync(request);
+    return await _httpClient.SendAsync(request, cancellationToken);
   }
 
-  private async Task<HttpResponseMessage> SendRequestAsync<T>(string endpoint, T request)
+  private async Task<HttpResponseMessage> SendRequestAsync<T>(string endpoint, T request, CancellationToken cancellationToken = default)
   {
     var requestJson = Serialize(request);
     var requestContent = new StringContent(requestJson, Encoding.UTF8, JsonContentType);
-    return await _httpClient.PostAsync(endpoint, requestContent);
+    return await _httpClient.PostAsync(endpoint, requestContent, cancellationToken);
   }
 
   private string Serialize<T>(T obj) => JsonSerializer.Serialize(obj, JsonSerializationOptions.DefaultOptions);
diff --git a/src/AnthropicClient/IAnthropicApiClient.cs b/src/AnthropicClient/IAnthropicApiClient.cs
index 27c7e00..7b33bbe 100644
--- a/src/AnthropicClient/IAnthropicApiClient.cs
+++ b/src/AnthropicClient/IAnthropicApiClient.cs
@@ -11,91 +11,104 @@ public interface IAnthropicApiClient
   /// Creates a message asynchronously.
   /// </summary>
   /// <param name="request">The message request to create.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>A task that represents the asynchronous operation. The task result contains the response as an <see cref="AnthropicResult{T}"/>.</returns>
-  Task<AnthropicResult<MessageResponse>> CreateMessageAsync(MessageRequest request);
+  Task<AnthropicResult<MessageResponse>> CreateMessageAsync(MessageRequest request, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Creates a message asynchronously and streams the response.
   /// </summary>
   /// <param name="request">The message request to create.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>An asynchronous enumerable that yields the response event by event.</returns>
-  IAsyncEnumerable<AnthropicEvent> CreateMessageAsync(StreamMessageRequest request);
+  IAsyncEnumerable<AnthropicEvent> CreateMessageAsync(StreamMessageRequest request, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Creates a batch of messages asynchronously.
   /// </summary>
   /// <param name="request">The message batch request to create.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>A task that represents the asynchronous operation. The task result contains the response as an <see cref="AnthropicResult{T}"/> where T is <see cref="MessageBatchResponse"/>.</returns>
-  Task<AnthropicResult<MessageBatchResponse>> CreateMessageBatchAsync(MessageBatchRequest request);
+  Task<AnthropicResult<MessageBatchResponse>> CreateMessageBatchAsync(MessageBatchRequest request, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Gets a message batch asynchronously.
   /// </summary>
   /// <param name="batchId">The ID of the message batch to get.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>A task that represents the asynchronous operation. The task result contains the response as an <see cref="AnthropicResult{T}"/> where T is <see cref="MessageBatchResponse"/>.</returns>
-  Task<AnthropicResult<MessageBatchResponse>> GetMessageBatchAsync(string batchId);
+  Task<AnthropicResult<MessageBatchResponse>> GetMessageBatchAsync(string batchId, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Lists the message batches asynchronously.
   /// </summary>
   /// <param name="request">The paging request to use for listing the message batches.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>A task that represents the asynchronous operation. The task result contains the response as an <see cref="AnthropicResult{T}"/> where T is <see cref="Page{T}"/> where T is <see cref="MessageBatchResponse"/>.</returns>
-  Task<AnthropicResult<Page<MessageBatchResponse>>> ListMessageBatchesAsync(PagingRequest? request = null);
+  Task<AnthropicResult<Page<MessageBatchResponse>>> ListMessageBatchesAsync(PagingRequest? request = null, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Lists all message batches asynchronously.
   /// </summary>
   /// <param name="limit">The maximum number of message batches to return in each page.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>An asynchronous enumerable that yields the response as an <see cref="AnthropicResult{T}"/> where T is <see cref="Page{T}"/> where T is <see cref="MessageBatchResponse"/>.</returns>
-  IAsyncEnumerable<AnthropicResult<Page<MessageBatchResponse>>> ListAllMessageBatchesAsync(int limit = 20);
+  IAsyncEnumerable<AnthropicResult<Page<MessageBatchResponse>>> ListAllMessageBatchesAsync(int limit = 20, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Cancels a message batch asynchronously.
   /// </summary>
   /// <param name="batchId">The ID of the message batch to cancel.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>A task that represents the asynchronous operation. The task result contains the response as an <see cref="AnthropicResult{T}"/> where T is <see cref="MessageBatchResponse"/>.</returns>
-  Task<AnthropicResult<MessageBatchResponse>> CancelMessageBatchAsync(string batchId);
+  Task<AnthropicResult<MessageBatchResponse>> CancelMessageBatchAsync(string batchId, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Deletes a message batch asynchronously.
   /// </summary>
   /// <param name="batchId">The ID of the message batch to delete.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>A task that represents the asynchronous operation. The task result contains the response as an <see cref="AnthropicResult{T}"/> where T is <see cref="MessageBatchDeleteResponse"/>.</returns>
-  Task<AnthropicResult<MessageBatchDeleteResponse>> DeleteMessageBatchAsync(string batchId);
+  Task<AnthropicResult<MessageBatchDeleteResponse>> DeleteMessageBatchAsync(string batchId, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Gets the results of a message batch asynchronously.
   /// </summary>
   /// <param name="batchId">The ID of the message batch to get the results for.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>A task that represents the asynchronous operation. The task result contains the response as an <see cref="AnthropicResult{T}"/> where T is <see cref="IAsyncEnumerable{T}"/> where T is <see cref="MessageBatchResultItem"/>.</returns>
-  Task<AnthropicResult<IAsyncEnumerable<MessageBatchResultItem>>> GetMessageBatchResultsAsync(string batchId);
+  Task<AnthropicResult<IAsyncEnumerable<MessageBatchResultItem>>> GetMessageBatchResultsAsync(string batchId, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Counts the tokens in a message asynchronously.
   /// </summary>
   /// <param name="request">The count message tokens request.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>A task that represents the asynchronous operation. The task result contains the response as an <see cref="AnthropicResult{T}"/> where T is <see cref="TokenCountResponse"/>.</returns>
-  Task<AnthropicResult<TokenCountResponse>> CountMessageTokensAsync(CountMessageTokensRequest request);
+  Task<AnthropicResult<TokenCountResponse>> CountMessageTokensAsync(CountMessageTokensRequest request, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Lists the models asynchronously.
   /// </summary>
   /// <param name="request">The paging request to use for listing the models.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>A task that represents the asynchronous operation. The task result contains the response as an <see cref="AnthropicResult{T}"/> where T is <see cref="Page{T}"/> where T is <see cref="AnthropicModel"/>.</returns>
-  Task<AnthropicResult<Page<AnthropicModel>>> ListModelsAsync(PagingRequest? request = null);
+  Task<AnthropicResult<Page<AnthropicModel>>> ListModelsAsync(PagingRequest? request = null, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Lists the models asynchronously
   /// </summary>
   /// <param name="limit">The maximum number of models to return in each page.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>An asynchronous enumerable that yields the response as an <see cref="AnthropicResult{T}"/> where T is <see cref="Page{T}"/> where T is <see cref="AnthropicModel"/>.</returns>
   /// 
-  IAsyncEnumerable<AnthropicResult<Page<AnthropicModel>>> ListAllModelsAsync(int limit = 20);
+  IAsyncEnumerable<AnthropicResult<Page<AnthropicModel>>> ListAllModelsAsync(int limit = 20, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Gets a model by its ID asynchronously.
   /// </summary>
   /// <param name="modelId">The ID of the model to get.</param>
+  /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
   /// <returns>A task that represents the asynchronous operation. The task result contains the response as an <see cref="AnthropicResult{T}"/> where T is <see cref="AnthropicModel"/>.</returns>
-  Task<AnthropicResult<AnthropicModel>> GetModelAsync(string modelId);
+  Task<AnthropicResult<AnthropicModel>> GetModelAsync(string modelId, CancellationToken cancellationToken = default);
 }
\ No newline at end of file

From 595326c7a9454e3c9d4a5c9d95777e723896e1a0 Mon Sep 17 00:00:00 2001
From: Stevan Freeborn <65925598+StevanFreeborn@users.noreply.github.com>
Date: Mon, 19 May 2025 15:14:11 -0500
Subject: [PATCH 2/8] fix: cleanup copilot mistakes with passing cancellation
 token to methods that don't accept them

---
 src/AnthropicClient/AnthropicApiClient.cs | 46 +++++++++++++++--------
 1 file changed, 31 insertions(+), 15 deletions(-)

diff --git a/src/AnthropicClient/AnthropicApiClient.cs b/src/AnthropicClient/AnthropicApiClient.cs
index 5ea4e02..58f0944 100644
--- a/src/AnthropicClient/AnthropicApiClient.cs
+++ b/src/AnthropicClient/AnthropicApiClient.cs
@@ -51,12 +51,13 @@ public AnthropicApiClient(string apiKey, HttpClient httpClient)
       _httpClient.DefaultRequestHeaders.Add(pair.Key, pair.Value);
     }
   }
+
   /// <inheritdoc/>
   public async Task<AnthropicResult<MessageResponse>> CreateMessageAsync(MessageRequest request, CancellationToken cancellationToken = default)
   {
     var response = await SendRequestAsync(MessagesEndpoint, request, cancellationToken);
     var anthropicHeaders = new AnthropicHeaders(response.Headers);
-    var responseContent = await response.Content.ReadAsStringAsync(cancellationToken);
+    var responseContent = await response.Content.ReadAsStringAsync();
 
     if (response.IsSuccessStatusCode is false)
     {
@@ -81,7 +82,8 @@ public async IAsyncEnumerable<AnthropicEvent> CreateMessageAsync(StreamMessageRe
 
     if (response.IsSuccessStatusCode is false)
     {
-      var error = Deserialize<AnthropicError>(await response.Content.ReadAsStringAsync(cancellationToken)) ?? new AnthropicError();
+      var errorContent = await response.Content.ReadAsStringAsync();
+      var error = Deserialize<AnthropicError>(errorContent) ?? new AnthropicError();
       yield return new AnthropicEvent(EventType.Error, new ErrorEventData(error.Error));
       yield break;
     }
@@ -237,26 +239,30 @@ msgResponse is not null
       }
     } while (true);
   }
+
   /// <inheritdoc/>
   public async Task<AnthropicResult<MessageBatchResponse>> CreateMessageBatchAsync(MessageBatchRequest request, CancellationToken cancellationToken = default)
   {
     var response = await SendRequestAsync(MessageBatchesEndpoint, request, cancellationToken);
-    return await CreateResultAsync<MessageBatchResponse>(response, cancellationToken);
+    return await CreateResultAsync<MessageBatchResponse>(response);
   }
+
   /// <inheritdoc/>
   public async Task<AnthropicResult<MessageBatchResponse>> GetMessageBatchAsync(string batchId, CancellationToken cancellationToken = default)
   {
     var response = await SendRequestAsync($"{MessageBatchesEndpoint}/{batchId}", cancellationToken: cancellationToken);
-    return await CreateResultAsync<MessageBatchResponse>(response, cancellationToken);
+    return await CreateResultAsync<MessageBatchResponse>(response);
   }
+
   /// <inheritdoc/>
   public async Task<AnthropicResult<Page<MessageBatchResponse>>> ListMessageBatchesAsync(PagingRequest? request = null, CancellationToken cancellationToken = default)
   {
     var pagingRequest = request ?? new PagingRequest();
     var endpoint = $"{MessageBatchesEndpoint}?{pagingRequest.ToQueryParameters()}";
     var response = await SendRequestAsync(endpoint, cancellationToken: cancellationToken);
-    return await CreateResultAsync<Page<MessageBatchResponse>>(response, cancellationToken);
+    return await CreateResultAsync<Page<MessageBatchResponse>>(response);
   }
+
   /// <inheritdoc/>
   public async IAsyncEnumerable<AnthropicResult<Page<MessageBatchResponse>>> ListAllMessageBatchesAsync(int limit = 20, [EnumeratorCancellation] CancellationToken cancellationToken = default)
   {
@@ -265,20 +271,23 @@ public async IAsyncEnumerable<AnthropicResult<Page<MessageBatchResponse>>> ListA
       yield return result;
     }
   }
+
   /// <inheritdoc/>
   public async Task<AnthropicResult<MessageBatchResponse>> CancelMessageBatchAsync(string batchId, CancellationToken cancellationToken = default)
   {
     var endpoint = $"{MessageBatchesEndpoint}/{batchId}/cancel";
     var response = await SendRequestAsync(endpoint, HttpMethod.Post, cancellationToken);
-    return await CreateResultAsync<MessageBatchResponse>(response, cancellationToken);
+    return await CreateResultAsync<MessageBatchResponse>(response);
   }
+
   /// <inheritdoc/>
   public async Task<AnthropicResult<MessageBatchDeleteResponse>> DeleteMessageBatchAsync(string batchId, CancellationToken cancellationToken = default)
   {
     var endpoint = $"{MessageBatchesEndpoint}/{batchId}";
     var response = await SendRequestAsync(endpoint, HttpMethod.Delete, cancellationToken);
-    return await CreateResultAsync<MessageBatchDeleteResponse>(response, cancellationToken);
+    return await CreateResultAsync<MessageBatchDeleteResponse>(response);
   }
+
   /// <inheritdoc/>
   public async Task<AnthropicResult<IAsyncEnumerable<MessageBatchResultItem>>> GetMessageBatchResultsAsync(string batchId, CancellationToken cancellationToken = default)
   {
@@ -287,7 +296,7 @@ public async Task<AnthropicResult<IAsyncEnumerable<MessageBatchResultItem>>> Get
 
     if (response.IsSuccessStatusCode is false)
     {
-      var content = await response.Content.ReadAsStringAsync(cancellationToken);
+      var content = await response.Content.ReadAsStringAsync();
       var error = Deserialize<AnthropicError>(content) ?? new AnthropicError();
       return AnthropicResult<IAsyncEnumerable<MessageBatchResultItem>>.Failure(error, anthropicHeaders);
     }
@@ -296,7 +305,7 @@ public async Task<AnthropicResult<IAsyncEnumerable<MessageBatchResultItem>>> Get
 
     async IAsyncEnumerable<MessageBatchResultItem> ReadResultsAsync([EnumeratorCancellation] CancellationToken ct = default)
     {
-      using var responseContent = await response.Content.ReadAsStreamAsync(ct);
+      using var responseContent = await response.Content.ReadAsStreamAsync();
       using var streamReader = new StreamReader(responseContent);
 
       var line = await streamReader.ReadLineAsync();
@@ -310,20 +319,23 @@ async IAsyncEnumerable<MessageBatchResultItem> ReadResultsAsync([EnumeratorCance
       }
     }
   }
+
   /// <inheritdoc/>
   public async Task<AnthropicResult<TokenCountResponse>> CountMessageTokensAsync(CountMessageTokensRequest request, CancellationToken cancellationToken = default)
   {
     var response = await SendRequestAsync(CountTokensEndpoint, request, cancellationToken);
-    return await CreateResultAsync<TokenCountResponse>(response, cancellationToken);
+    return await CreateResultAsync<TokenCountResponse>(response);
   }
+
   /// <inheritdoc/>
   public async Task<AnthropicResult<Page<AnthropicModel>>> ListModelsAsync(PagingRequest? request = null, CancellationToken cancellationToken = default)
   {
     var pagingRequest = request ?? new PagingRequest();
     var endpoint = $"{ModelsEndpoint}?{pagingRequest.ToQueryParameters()}";
     var response = await SendRequestAsync(endpoint, cancellationToken: cancellationToken);
-    return await CreateResultAsync<Page<AnthropicModel>>(response, cancellationToken);
+    return await CreateResultAsync<Page<AnthropicModel>>(response);
   }
+
   /// <inheritdoc/>
   public async IAsyncEnumerable<AnthropicResult<Page<AnthropicModel>>> ListAllModelsAsync(int limit = 20, [EnumeratorCancellation] CancellationToken cancellationToken = default)
   {
@@ -332,13 +344,15 @@ public async IAsyncEnumerable<AnthropicResult<Page<AnthropicModel>>> ListAllMode
       yield return result;
     }
   }
+
   /// <inheritdoc/>
   public async Task<AnthropicResult<AnthropicModel>> GetModelAsync(string modelId, CancellationToken cancellationToken = default)
   {
     var endpoint = $"{ModelsEndpoint}/{modelId}";
     var response = await SendRequestAsync(endpoint, cancellationToken: cancellationToken);
-    return await CreateResultAsync<AnthropicModel>(response, cancellationToken);
+    return await CreateResultAsync<AnthropicModel>(response);
   }
+
   private async IAsyncEnumerable<AnthropicResult<Page<T>>> GetAllPagesAsync<T>(string endpoint, int limit = 20, [EnumeratorCancellation] CancellationToken cancellationToken = default)
   {
     var pagingRequest = new PagingRequest(limit: limit);
@@ -349,7 +363,7 @@ private async IAsyncEnumerable<AnthropicResult<Page<T>>> GetAllPagesAsync<T>(str
     {
       var response = await SendRequestAsync(Endpoint(), cancellationToken: cancellationToken);
       var anthropicHeaders = new AnthropicHeaders(response.Headers);
-      var responseContent = await response.Content.ReadAsStringAsync(cancellationToken);
+      var responseContent = await response.Content.ReadAsStringAsync();
 
       if (response.IsSuccessStatusCode is false)
       {
@@ -392,10 +406,11 @@ private async IAsyncEnumerable<AnthropicResult<Page<T>>> GetAllPagesAsync<T>(str
 
     return new ToolCall(tool, toolUse);
   }
-  private async Task<AnthropicResult<T>> CreateResultAsync<T>(HttpResponseMessage response, CancellationToken cancellationToken = default) where T : new()
+
+  private async Task<AnthropicResult<T>> CreateResultAsync<T>(HttpResponseMessage response) where T : new()
   {
     var anthropicHeaders = new AnthropicHeaders(response.Headers);
-    var responseContent = await response.Content.ReadAsStringAsync(cancellationToken);
+    var responseContent = await response.Content.ReadAsStringAsync();
 
     if (response.IsSuccessStatusCode is false)
     {
@@ -406,6 +421,7 @@ private async IAsyncEnumerable<AnthropicResult<Page<T>>> GetAllPagesAsync<T>(str
     var model = Deserialize<T>(responseContent) ?? new T();
     return AnthropicResult<T>.Success(model, anthropicHeaders);
   }
+
   private async Task<HttpResponseMessage> SendRequestAsync(string endpoint, HttpMethod? method = null, CancellationToken cancellationToken = default)
   {
     var request = new HttpRequestMessage(method ?? HttpMethod.Get, endpoint);

From 24ecff969ed47b49fb4f0246032816ae4b9888d6 Mon Sep 17 00:00:00 2001
From: Stevan Freeborn <65925598+StevanFreeborn@users.noreply.github.com>
Date: Mon, 19 May 2025 15:14:50 -0500
Subject: [PATCH 3/8] chore: upgrade test project to .NET 9

---
 tests/AnthropicClient.Tests/AnthropicClient.Tests.csproj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/AnthropicClient.Tests/AnthropicClient.Tests.csproj b/tests/AnthropicClient.Tests/AnthropicClient.Tests.csproj
index 0a5f3db..6be8f1a 100644
--- a/tests/AnthropicClient.Tests/AnthropicClient.Tests.csproj
+++ b/tests/AnthropicClient.Tests/AnthropicClient.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <IsPackable>false</IsPackable>
@@ -54,7 +54,7 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
-  
+
   <ItemGroup>
     <None Update="Files/**">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>

From e68428c8bacd0d5073f182ba61551821c5cb6996 Mon Sep 17 00:00:00 2001
From: Stevan Freeborn <65925598+StevanFreeborn@users.noreply.github.com>
Date: Mon, 19 May 2025 15:16:53 -0500
Subject: [PATCH 4/8] chore: upgrade dependencies

---
 src/AnthropicClient/AnthropicClient.csproj     |  4 ++--
 .../AnthropicClient.Tests.csproj               | 18 +++++++++---------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/AnthropicClient/AnthropicClient.csproj b/src/AnthropicClient/AnthropicClient.csproj
index 8f16d24..0a58e81 100644
--- a/src/AnthropicClient/AnthropicClient.csproj
+++ b/src/AnthropicClient/AnthropicClient.csproj
@@ -34,8 +34,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
-    <PackageReference Include="System.Text.Json" Version="8.0.5" />
+    <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="9.0.5" />
+    <PackageReference Include="System.Text.Json" Version="9.0.5" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All" />
   </ItemGroup>
 
diff --git a/tests/AnthropicClient.Tests/AnthropicClient.Tests.csproj b/tests/AnthropicClient.Tests/AnthropicClient.Tests.csproj
index 6be8f1a..1962db3 100644
--- a/tests/AnthropicClient.Tests/AnthropicClient.Tests.csproj
+++ b/tests/AnthropicClient.Tests/AnthropicClient.Tests.csproj
@@ -10,21 +10,21 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="6.12.2" />
-    <PackageReference Include="Microsoft.Extensions.Configuration" Version="8.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="8.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="8.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="FluentAssertions" Version="7.2.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="9.0.5" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="9.0.5" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="9.0.5" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="RichardSzalay.MockHttp" Version="7.0.0" />
     <PackageReference Include="System.Linq.Async" Version="6.0.1" />
     <PackageReference Include="SystemTextJson.JsonDiffPatch.Xunit" Version="2.0.0" />
-    <PackageReference Include="xunit" Version="2.9.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.0" />
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.msbuild" Version="6.0.2">
+    <PackageReference Include="coverlet.msbuild" Version="6.0.4">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>

From e2d4ee735adeb5823b7908e17e7e3b353684d656 Mon Sep 17 00:00:00 2001
From: Stevan Freeborn <65925598+StevanFreeborn@users.noreply.github.com>
Date: Mon, 19 May 2025 15:21:51 -0500
Subject: [PATCH 5/8] chore: update workflows to use .NET 9

---
 .github/workflows/publish.yml      | 12 ++++++------
 .github/workflows/pull_request.yml |  8 ++++----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 2825527..8668753 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -13,10 +13,10 @@ jobs:
         with:
           fetch-depth: 0
           token: ${{ secrets.ACTIONS_PAT }}
-      - name: Setup .NET 8
+      - name: Setup .NET 9
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.x
+          dotnet-version: 9.x
       - name: Install versionize
         run: dotnet tool install --global Versionize
       - name: Setup git
@@ -53,10 +53,10 @@ jobs:
           fetch-depth: 0
           ref: ${{ github.ref }}
           token: ${{ secrets.ACTIONS_PAT }}
-      - name: Setup .NET 8
+      - name: Setup .NET 9
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.x
+          dotnet-version: 9.x
       - name: Get project version
         uses: kzrnm/get-net-sdk-project-versions-action@v1
         id: get-version
@@ -88,10 +88,10 @@ jobs:
           fetch-depth: 0
           ref: ${{ github.ref }}
           token: ${{ secrets.ACTIONS_PAT }}
-      - name: Setup .NET 8
+      - name: Setup .NET 9
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.x
+          dotnet-version: 9.x
       - name: Install Docfx
         run: dotnet tool install --global docfx
       - name: Get project version
diff --git a/.github/workflows/pull_request.yml b/.github/workflows/pull_request.yml
index b6a83cd..f12943b 100644
--- a/.github/workflows/pull_request.yml
+++ b/.github/workflows/pull_request.yml
@@ -15,10 +15,10 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
-      - name: Setup .NET 8
+      - name: Setup .NET 9
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.x
+          dotnet-version: 9.x
       - name: Restore dependencies
         run: dotnet restore
       - name: Format code
@@ -28,10 +28,10 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
-      - name: Setup .NET 8
+      - name: Setup .NET 9
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.x
+          dotnet-version: 9.x
       - name: Install report generator
         run: dotnet tool install --global dotnet-reportgenerator-globaltool --version 5.3.7
       - name: Restore dependencies

From 5d4fb290ba24095ea564cf8a33366dd53ab4ba44 Mon Sep 17 00:00:00 2001
From: Stevan Freeborn <65925598+StevanFreeborn@users.noreply.github.com>
Date: Mon, 19 May 2025 15:28:08 -0500
Subject: [PATCH 6/8] fix: cleanup based on copilot review comments

---
 .vscode/settings.json                      | 9 +++++++++
 src/AnthropicClient/AnthropicApiClient.cs  | 2 +-
 src/AnthropicClient/IAnthropicApiClient.cs | 4 ++--
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/.vscode/settings.json b/.vscode/settings.json
index b2f391d..11a990d 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -3,9 +3,18 @@
   "dotnet.defaultSolution": "AnthropicClient.sln",
   "cSpell.words": [
     "Browsable",
+    "buildtransitive",
+    "contentfiles",
+    "Docfx",
+    "globaltool",
     "haikus",
+    "Linq",
+    "msbuild",
     "nameof",
+    "reportgenerator",
+    "reporttypes",
     "Szalay",
+    "targetdir",
     "typeof"
   ],
   "dotnet.unitTests.runSettingsPath": "./tests/AnthropicClient.Tests/.runsettings"
diff --git a/src/AnthropicClient/AnthropicApiClient.cs b/src/AnthropicClient/AnthropicApiClient.cs
index 58f0944..f05f3e6 100644
--- a/src/AnthropicClient/AnthropicApiClient.cs
+++ b/src/AnthropicClient/AnthropicApiClient.cs
@@ -303,7 +303,7 @@ public async Task<AnthropicResult<IAsyncEnumerable<MessageBatchResultItem>>> Get
 
     return AnthropicResult<IAsyncEnumerable<MessageBatchResultItem>>.Success(ReadResultsAsync(), anthropicHeaders);
 
-    async IAsyncEnumerable<MessageBatchResultItem> ReadResultsAsync([EnumeratorCancellation] CancellationToken ct = default)
+    async IAsyncEnumerable<MessageBatchResultItem> ReadResultsAsync()
     {
       using var responseContent = await response.Content.ReadAsStreamAsync();
       using var streamReader = new StreamReader(responseContent);
diff --git a/src/AnthropicClient/IAnthropicApiClient.cs b/src/AnthropicClient/IAnthropicApiClient.cs
index 7b33bbe..12d98c7 100644
--- a/src/AnthropicClient/IAnthropicApiClient.cs
+++ b/src/AnthropicClient/IAnthropicApiClient.cs
@@ -88,7 +88,7 @@ public interface IAnthropicApiClient
   Task<AnthropicResult<TokenCountResponse>> CountMessageTokensAsync(CountMessageTokensRequest request, CancellationToken cancellationToken = default);
 
   /// <summary>
-  /// Lists the models asynchronously.
+  /// Lists the models asynchronously getting a page of models.
   /// </summary>
   /// <param name="request">The paging request to use for listing the models.</param>
   /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
@@ -96,7 +96,7 @@ public interface IAnthropicApiClient
   Task<AnthropicResult<Page<AnthropicModel>>> ListModelsAsync(PagingRequest? request = null, CancellationToken cancellationToken = default);
 
   /// <summary>
-  /// Lists the models asynchronously
+  /// Lists the model asynchronously getting all the pages of models.
   /// </summary>
   /// <param name="limit">The maximum number of models to return in each page.</param>
   /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>

From 702685bd10b94211f03f3ab28c9a25ad5b2b9e8f Mon Sep 17 00:00:00 2001
From: Stevan Freeborn <65925598+StevanFreeborn@users.noreply.github.com>
Date: Mon, 19 May 2025 15:30:12 -0500
Subject: [PATCH 7/8] docs: update src/AnthropicClient/IAnthropicApiClient.cs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 src/AnthropicClient/IAnthropicApiClient.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/AnthropicClient/IAnthropicApiClient.cs b/src/AnthropicClient/IAnthropicApiClient.cs
index 12d98c7..26d22b8 100644
--- a/src/AnthropicClient/IAnthropicApiClient.cs
+++ b/src/AnthropicClient/IAnthropicApiClient.cs
@@ -88,7 +88,7 @@ public interface IAnthropicApiClient
   Task<AnthropicResult<TokenCountResponse>> CountMessageTokensAsync(CountMessageTokensRequest request, CancellationToken cancellationToken = default);
 
   /// <summary>
-  /// Lists the models asynchronously getting a page of models.
+  /// Lists models asynchronously, returning a single page of results.
   /// </summary>
   /// <param name="request">The paging request to use for listing the models.</param>
   /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>

From 16ee80a3a4346d537b0d0b784698482009c1f424 Mon Sep 17 00:00:00 2001
From: Stevan Freeborn <65925598+StevanFreeborn@users.noreply.github.com>
Date: Mon, 19 May 2025 15:30:29 -0500
Subject: [PATCH 8/8] docs: update src/AnthropicClient/IAnthropicApiClient.cs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 src/AnthropicClient/IAnthropicApiClient.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/AnthropicClient/IAnthropicApiClient.cs b/src/AnthropicClient/IAnthropicApiClient.cs
index 26d22b8..e4f63b9 100644
--- a/src/AnthropicClient/IAnthropicApiClient.cs
+++ b/src/AnthropicClient/IAnthropicApiClient.cs
@@ -96,7 +96,7 @@ public interface IAnthropicApiClient
   Task<AnthropicResult<Page<AnthropicModel>>> ListModelsAsync(PagingRequest? request = null, CancellationToken cancellationToken = default);
 
   /// <summary>
-  /// Lists the model asynchronously getting all the pages of models.
+  /// Lists all models asynchronously, returning every page of results.
   /// </summary>
   /// <param name="limit">The maximum number of models to return in each page.</param>
   /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>