Merge pull request #30 from StevanFreeborn/stevanfreeborn/feat/add-support-for-models-API

feat: add support for models API

Author: StevanFreeborn

.vscode/settings.json

@@ -1,4 +1,5 @@
 {
+  "editor.formatOnSave": true,
   "dotnet.defaultSolution": "AnthropicClient.sln",
   "cSpell.words": [
     "Browsable",

README.md

@@ -134,6 +134,73 @@ if (response.IsFailure)
 Console.WriteLine("Token Count: {0}", response.Value.InputTokens);
 ```
 
+### List Models
+
+The `AnthropicApiClient` exposes a method named `ListModelsAsync` that can be used to list the available models. The method takes an optional `PagingRequest` instance as a parameter.
+
+```csharp
+using AnthropicClient;
+
+var response = await client.ListModelsAsync();
+
+if (response.IsFailure)
+{
+  Console.WriteLine("Failed to list models");
+  Console.WriteLine("Error Type: {0}", response.Error.Error.Type);
+  Console.WriteLine("Error Message: {0}", response.Error.Error.Message);
+  return;
+}
+
+foreach (var model in response.Value.Data)
+{
+  Console.WriteLine("Model Id: {0}", model.Id);
+  Console.WriteLine("Model Name: {0}", model.DisplayName);
+}
+```
+
+Using the `PagingRequest` instance allows you to specify the number of models to return and the page of models to return.
+
+```csharp
+using AnthropicClient;
+using AnthropicClient.Models;
+
+var response = await client.ListModelsAsync(new PagingRequest(afterId: "claude-3-5-sonnet-20241022", limit: 2));
+
+if (response.IsFailure)
+{
+  Console.WriteLine("Failed to list models");
+  Console.WriteLine("Error Type: {0}", response.Error.Error.Type);
+  Console.WriteLine("Error Message: {0}", response.Error.Error.Message);
+  return;
+}
+
+foreach (var model in response.Value.Data)
+{
+  Console.WriteLine("Model Id: {0}", model.Id);
+  Console.WriteLine("Model Name: {0}", model.DisplayName);
+}
+```
+
+### Get Model
+
+The `AnthropicApiClient` exposes a method named `GetModelAsync` that can be used to get a model by its id.
+
+```csharp
+using AnthropicClient;
+
+var response = await client.GetModelAsync("claude-3-5-sonnet-20241022");
+
+if (response.IsFailure)
+{
+  Console.WriteLine("Failed to get model");
+  Console.WriteLine("Error Type: {0}", response.Error.Error.Type);
+  Console.WriteLine("Error Message: {0}", response.Error.Error.Message);
+  return;
+}
+
+Console.WriteLine("Model Id: {0}", response.Value.Id);
+```
+
 ### Create a message
 
 The `AnthropicApiClient` exposes a method named `CreateMessageAsync` that can be used to create a message. The method requires a `MessageRequest` or a `StreamMessageRequest` instance as a parameter. The `MessageRequest` class is used to create a message whose response is not streamed and the `StreamMessageRequest` class is used to create a message whose response is streamed. The `MessageRequest` instance's properties can be set to configure how the message is created.

src/AnthropicClient/AnthropicApiClient.cs

@@ -1,6 +1,7 @@
 using System.Net.Http.Headers;
 using System.Text;
 using System.Text.Json;
+using System.Threading.Tasks;
 
 using AnthropicClient.Json;
 using AnthropicClient.Models;
@@ -33,6 +34,28 @@ public interface IAnthropicApiClient
   /// <param name="request">The count message tokens request.</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);
+
+  /// <summary>
+  /// Lists the models asynchronously.
+  /// </summary>
+  /// <param name="request">The paging request to use for listing the models.</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);
+
+  /// <summary>
+  /// Lists the models asynchronously
+  /// </summary>
+  /// <param name="limit">The maximum number of models to return in each page.</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);
+
+  /// <summary>
+  /// Gets a model by its ID asynchronously.
+  /// </summary>
+  /// <param name="modelId">The ID of the model to get.</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);
 }
 
 /// <inheritdoc cref="IAnthropicApiClient"/>
@@ -42,6 +65,7 @@ public class AnthropicApiClient : IAnthropicApiClient
   private const string ApiKeyHeader = "x-api-key";
   private const string MessagesEndpoint = "messages";
   private const string CountTokensEndpoint = "messages/count_tokens";
+  private const string ModelsEndpoint = "models";
   private const string JsonContentType = "application/json";
   private const string EventPrefix = "event:";
   private const string DataPrefix = "data:";
@@ -76,7 +100,7 @@ public AnthropicApiClient(string apiKey, HttpClient httpClient)
     }
   }
 
-  /// <inheritdoc />
+  /// <inheritdoc/>
   public async Task<AnthropicResult<MessageResponse>> CreateMessageAsync(MessageRequest request)
   {
     var response = await SendRequestAsync(MessagesEndpoint, request);
@@ -99,7 +123,7 @@ public async Task<AnthropicResult<MessageResponse>> CreateMessageAsync(MessageRe
     return AnthropicResult<MessageResponse>.Success(msgResponse, anthropicHeaders);
   }
 
-  /// <inheritdoc />
+  /// <inheritdoc/>
   public async IAsyncEnumerable<AnthropicEvent> CreateMessageAsync(StreamMessageRequest request)
   {
     var response = await SendRequestAsync(MessagesEndpoint, request);
@@ -263,7 +287,7 @@ msgResponse is not null
     } while (true);
   }
 
-  /// <inheritdoc />
+  /// <inheritdoc/>
   public async Task<AnthropicResult<TokenCountResponse>> CountMessageTokensAsync(CountMessageTokensRequest request)
   {
     var response = await SendRequestAsync(CountTokensEndpoint, request);
@@ -277,10 +301,82 @@ public async Task<AnthropicResult<TokenCountResponse>> CountMessageTokensAsync(C
     }
 
     var msgResponse = Deserialize<TokenCountResponse>(responseContent) ?? new TokenCountResponse();
-
     return AnthropicResult<TokenCountResponse>.Success(msgResponse, anthropicHeaders);
   }
 
+  /// <inheritdoc/>
+  public async Task<AnthropicResult<Page<AnthropicModel>>> ListModelsAsync(PagingRequest? request = null)
+  {
+    var pagingRequest = request ?? new PagingRequest();
+    var endpoint = $"{ModelsEndpoint}?{pagingRequest.ToQueryParameters()}";
+    var response = await SendRequestAsync(endpoint);
+    var anthropicHeaders = new AnthropicHeaders(response.Headers);
+    var responseContent = await response.Content.ReadAsStringAsync();
+
+    if (response.IsSuccessStatusCode is false)
+    {
+      var error = Deserialize<AnthropicError>(responseContent) ?? new AnthropicError();
+      return AnthropicResult<Page<AnthropicModel>>.Failure(error, anthropicHeaders);
+    }
+
+    var page = Deserialize<Page<AnthropicModel>>(responseContent) ?? new Page<AnthropicModel>();
+    return AnthropicResult<Page<AnthropicModel>>.Success(page, anthropicHeaders);
+  }
+
+  /// <inheritdoc/>
+  public async IAsyncEnumerable<AnthropicResult<Page<AnthropicModel>>> ListAllModelsAsync(int limit = 20)
+  {
+    var pagingRequest = new PagingRequest(limit: limit);
+    string Endpoint() => $"{ModelsEndpoint}?{pagingRequest.ToQueryParameters()}";
+    bool hasMore;
+
+    do
+    {
+      var response = await SendRequestAsync(Endpoint());
+      var anthropicHeaders = new AnthropicHeaders(response.Headers);
+      var responseContent = await response.Content.ReadAsStringAsync();
+
+      if (response.IsSuccessStatusCode is false)
+      {
+        var error = Deserialize<AnthropicError>(responseContent) ?? new AnthropicError();
+        yield return AnthropicResult<Page<AnthropicModel>>.Failure(error, anthropicHeaders);
+        yield break;
+      }
+
+      var page = Deserialize<Page<AnthropicModel>>(responseContent) ?? new Page<AnthropicModel>();
+
+      if (page.HasMore && page.LastId is not null)
+      {
+        hasMore = true;
+        pagingRequest = new PagingRequest(limit: limit, afterId: page.LastId);
+      }
+      else
+      {
+        hasMore = false;
+      }
+
+      yield return AnthropicResult<Page<AnthropicModel>>.Success(page, anthropicHeaders);
+    } while (hasMore);
+  }
+
+  /// <inheritdoc/>
+  public async Task<AnthropicResult<AnthropicModel>> GetModelAsync(string modelId)
+  {
+    var endpoint = $"{ModelsEndpoint}/{modelId}";
+    var response = await SendRequestAsync(endpoint);
+    var anthropicHeaders = new AnthropicHeaders(response.Headers);
+    var responseContent = await response.Content.ReadAsStringAsync();
+
+    if (response.IsSuccessStatusCode is false)
+    {
+      var error = Deserialize<AnthropicError>(responseContent) ?? new AnthropicError();
+      return AnthropicResult<AnthropicModel>.Failure(error, anthropicHeaders);
+    }
+
+    var model = Deserialize<AnthropicModel>(responseContent) ?? new AnthropicModel();
+    return AnthropicResult<AnthropicModel>.Success(model, anthropicHeaders);
+  }
+
   private ToolCall? GetToolCall(MessageResponse response, List<Tool> tools)
   {
     var toolUse = response.Content.OfType<ToolUseContent>().FirstOrDefault();
@@ -300,6 +396,11 @@ public async Task<AnthropicResult<TokenCountResponse>> CountMessageTokensAsync(C
     return new ToolCall(tool, toolUse);
   }
 
+  private async Task<HttpResponseMessage> SendRequestAsync(string endpoint)
+  {
+    return await _httpClient.GetAsync(endpoint);
+  }
+
   private async Task<HttpResponseMessage> SendRequestAsync<T>(string endpoint, T request)
   {
     var requestJson = Serialize(request);

src/AnthropicClient/Models/AnthropicModel.cs

@@ -0,0 +1,31 @@
+using System.Text.Json.Serialization;
+
+namespace AnthropicClient.Models;
+
+/// <summary>
+/// Represents an Anthropic model.
+/// </summary>
+public class AnthropicModel
+{
+  /// <summary>
+  /// The type of the model.
+  /// </summary>
+  public string Type { get; init; } = string.Empty;
+
+  /// <summary>
+  /// The id of the model.
+  /// </summary>
+  public string Id { get; init; } = string.Empty;
+
+  /// <summary>
+  /// The display name of the model.
+  /// </summary>
+  [JsonPropertyName("display_name")]
+  public string DisplayName { get; init; } = string.Empty;
+
+  /// <summary>
+  /// The created date of the model.
+  /// </summary>
+  [JsonPropertyName("created_at")]
+  public DateTimeOffset CreatedAt { get; init; }
+}

src/AnthropicClient/Models/Page.cs

@@ -0,0 +1,38 @@
+using System.Text.Json.Serialization;
+
+namespace AnthropicClient.Models;
+
+/// <summary>
+/// Represents a page.
+/// </summary>
+public class Page
+{
+  /// <summary>
+  /// The id of the first item in the page.
+  /// </summary>
+  [JsonPropertyName("first_id")]
+  public string? FirstId { get; init; } = string.Empty;
+
+  /// <summary>
+  /// The id of the last item in the page.
+  /// </summary>
+  [JsonPropertyName("last_id")]
+  public string? LastId { get; init; } = string.Empty;
+
+  /// <summary>
+  /// Indicates whether there is more data to be retrieved.
+  /// </summary>
+  [JsonPropertyName("has_more")]
+  public bool HasMore { get; init; }
+}
+
+/// <summary>
+/// Represents a page with data.
+/// </summary>
+public class Page<T> : Page
+{
+  /// <summary>
+  /// The data in the page.
+  /// </summary>
+  public T[] Data { get; init; } = [];
+}