anthropic-client/tests/AnthropicClient.Tests/Integration/AnthropicApiClientTests.cs

using AnthropicClient.Tests.Files;

namespace AnthropicClient.Tests.Integration;

public class AnthropicApiClientTests : IntegrationTest
{
  [Theory]
  [ClassData(typeof(ErrorTestData))]
  public async Task CreateMessageAsync_WhenCalledAndErrorReturned_ItShouldHandleError(
    HttpStatusCode statusCode,
    string content,
    Type errorType
  )
  {
    _mockHttpMessageHandler
      .WhenCreateMessageRequest()
      .Respond(
        statusCode,
        "application/json",
        content
      );

    var request = new MessageRequest(
      model: AnthropicModels.Claude3Haiku,
      messages: [new(MessageRole.User, [new TextContent("Hello!")])]
    );

    var result = await Client.CreateMessageAsync(request);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();

    var actualErrorType = result.Error.Error!.GetType();
    actualErrorType.Should().Be(errorType);
  }

  [Fact]
  public async Task CreateMessageAsync_WhenCalledRequestFailsAndCanNotDeserializeError_ItShouldReturnUnknownError()
  {
    _mockHttpMessageHandler
      .WhenCreateMessageRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"null"
      );

    var request = new MessageRequest(
      model: AnthropicModels.Claude3Haiku,
      messages: [new(MessageRole.User, [new TextContent("Hello!")])]
    );

    var result = await Client.CreateMessageAsync(request);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<ApiError>();
  }

  [Fact]
  public async Task CreateMessageAsync_WhenCalledRequestSucceedsAndCanNotDeserializeResponse_ItShouldReturnEmptyResponse()
  {
    _mockHttpMessageHandler
      .WhenCreateMessageRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"null"
      );

    var request = new MessageRequest(
      model: AnthropicModels.Claude3Haiku,
      messages: [new(MessageRole.User, [new TextContent("Hello!")])]
    );

    var result = await Client.CreateMessageAsync(request);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeEquivalentTo(new MessageResponse());
  }

  [Fact]
  public async Task CreateMessageAsync_WhenCalledAndMessageCreatedWithTextContent_ItShouldReturnMessage()
  {
    _mockHttpMessageHandler
      .WhenCreateMessageRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""content"": [
              {
                ""text"": ""Hi! My name is Claude."",
                ""type"": ""text""
              }
            ],
            ""id"": ""msg_013Zva2CMHLNnXjNJJKqJ2EF"",
            ""model"": ""claude-3-5-sonnet-20240620"",
            ""role"": ""assistant"",
            ""stop_reason"": ""end_turn"",
            ""stop_sequence"": null,
            ""type"": ""message"",
            ""usage"": {
              ""input_tokens"": 10,
              ""output_tokens"": 25
            }
          }"
      );

    var request = new MessageRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [new(MessageRole.User, [new TextContent("Hello!")])]
    );

    var result = await Client.CreateMessageAsync(request);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<MessageResponse>();

    var message = result.Value;
    message.Id.Should().Be("msg_013Zva2CMHLNnXjNJJKqJ2EF");
    message.Model.Should().Be("claude-3-5-sonnet-20240620");
    message.Role.Should().Be("assistant");
    message.StopReason.Should().Be("end_turn");
    message.StopSequence.Should().BeNull();
    message.Type.Should().Be("message");
    message.Usage.InputTokens.Should().Be(10);
    message.Usage.OutputTokens.Should().Be(25);
    message.Content.Should().HaveCount(1);
    message.ToolCall.Should().BeNull();

    var textContent = message.Content[0];
    textContent.Should().BeOfType<TextContent>();
    textContent.As<TextContent>().Text.Should().Be("Hi! My name is Claude.");
    textContent.As<TextContent>().Type.Should().Be("text");
  }

  [Fact]
  public async Task CreateMessageAsync_WhenCalledAndMessageCreatedWithToolUseContentAndToolIsProvided_ItShouldReturnMessageWithToolCall()
  {
    _mockHttpMessageHandler
      .WhenCreateMessageRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""content"": [
              {
                ""id"": ""toolu_01D7FLrfh4GYq7yT1ULFeyMV"",
                ""name"": ""get_stock_price"",
                ""input"": { ""ticker"": ""^GSPC"" },
                ""type"": ""tool_use""
              }
            ],
            ""id"": ""msg_01D7FLrfh4GYq7yT1ULFeyMV"",
            ""model"": ""claude-3-5-sonnet-20240620"",
            ""role"": ""assistant"",
            ""stop_reason"": ""end_turn"",
            ""stop_sequence"": null,
            ""type"": ""message"",
            ""usage"": {
              ""input_tokens"": 10,
              ""output_tokens"": 25
            }
          }"
      );

    var func = (string ticker) => ticker;

    var request = new MessageRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [
        new(MessageRole.User, [new TextContent("Hello!")]),
      ],
      tools: [
        Tool.CreateFromFunction("get_stock_price", "Gets the stock price for a given ticker", func)
      ]
    );

    var result = await Client.CreateMessageAsync(request);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<MessageResponse>();

    var message = result.Value;
    message.Id.Should().Be("msg_01D7FLrfh4GYq7yT1ULFeyMV");
    message.Model.Should().Be("claude-3-5-sonnet-20240620");
    message.Role.Should().Be("assistant");
    message.StopReason.Should().Be("end_turn");
    message.StopSequence.Should().BeNull();
    message.Type.Should().Be("message");
    message.Usage.InputTokens.Should().Be(10);
    message.Usage.OutputTokens.Should().Be(25);
    message.Content.Should().HaveCount(1);
    message.ToolCall.Should().NotBeNull();

    var toolUseContent = message.Content[0];
    toolUseContent.Should().BeOfType<ToolUseContent>();

    toolUseContent.As<ToolUseContent>().Id.Should().Be("toolu_01D7FLrfh4GYq7yT1ULFeyMV");
    toolUseContent.As<ToolUseContent>().Name.Should().Be("get_stock_price");
    toolUseContent.As<ToolUseContent>().Type.Should().Be("tool_use");

    var input = toolUseContent.As<ToolUseContent>().Input;
    var ticker = input.GetValueOrDefault("ticker");
    ticker!.ToString().Should().Be("^GSPC");

    var toolCallResult = await message.ToolCall!.InvokeAsync();
    toolCallResult.IsSuccess.Should().BeTrue();
    toolCallResult.Value!.ToString().Should().Be("^GSPC");
  }


  [Fact]
  public async Task CreateMessageAsync_WhenCalledAndMessageCreatedWithToolUseButNoToolProvided_ItShouldReturnMessageWithoutToolCall()
  {
    _mockHttpMessageHandler
      .WhenCreateMessageRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""content"": [
              {
                ""id"": ""toolu_01D7FLrfh4GYq7yT1ULFeyMV"",
                ""name"": ""get_stock_price"",
                ""input"": { ""ticker"": ""^GSPC"" },
                ""type"": ""tool_use""
              }
            ],
            ""id"": ""msg_01D7FLrfh4GYq7yT1ULFeyMV"",
            ""model"": ""claude-3-5-sonnet-20240620"",
            ""role"": ""assistant"",
            ""stop_reason"": ""end_turn"",
            ""stop_sequence"": null,
            ""type"": ""message"",
            ""usage"": {
              ""input_tokens"": 10,
              ""output_tokens"": 25
            }
          }"
      );

    var request = new MessageRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [
        new(MessageRole.User, [new TextContent("Hello!")]),
      ]
    );

    var result = await Client.CreateMessageAsync(request);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<MessageResponse>();

    var message = result.Value;
    message.Id.Should().Be("msg_01D7FLrfh4GYq7yT1ULFeyMV");
    message.Model.Should().Be("claude-3-5-sonnet-20240620");
    message.Role.Should().Be("assistant");
    message.StopReason.Should().Be("end_turn");
    message.StopSequence.Should().BeNull();
    message.Type.Should().Be("message");
    message.Usage.InputTokens.Should().Be(10);
    message.Usage.OutputTokens.Should().Be(25);
    message.Content.Should().HaveCount(1);
    message.ToolCall.Should().BeNull();

    var toolUseContent = message.Content[0];
    toolUseContent.Should().BeOfType<ToolUseContent>();

    toolUseContent.As<ToolUseContent>().Id.Should().Be("toolu_01D7FLrfh4GYq7yT1ULFeyMV");
    toolUseContent.As<ToolUseContent>().Name.Should().Be("get_stock_price");
    toolUseContent.As<ToolUseContent>().Type.Should().Be("tool_use");

    var input = toolUseContent.As<ToolUseContent>().Input;
    var ticker = input.GetValueOrDefault("ticker");
    ticker!.ToString().Should().Be("^GSPC");
  }

  [Theory]
  [ClassData(typeof(EventTestData))]
  public async Task CreateMessageAsync_WhenCalledAndMessageIsStreamed_ItShouldHandleAllEventTypes(string eventString, AnthropicEvent anthropicEvent)
  {
    _mockHttpMessageHandler
      .WhenCreateStreamMessageRequest()
      .Respond(
        HttpStatusCode.OK,
        "text/event-stream",
        new MemoryStream(Encoding.UTF8.GetBytes(eventString))
      );

    var request = new StreamMessageRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [
        new(MessageRole.User, [new TextContent("Hello!")]),
      ]
    );

    var result = Client.CreateMessageAsync(request);
    var e = await result.FirstOrDefaultAsync();

    e.Should().BeEquivalentTo(anthropicEvent);
  }

  [Fact]
  public async Task CreateMessageAsync_WhenCalledAndMessageIsStreamed_ItShouldReturnAllExpectedEvents()
  {
    var eventStream = EventTestData.GetEventStream();
    var events = EventTestData.GetAllEvents();

    _mockHttpMessageHandler
      .WhenCreateStreamMessageRequest()
      .Respond(
        HttpStatusCode.OK,
        "text/event-stream",
        eventStream
      );

    var request = new StreamMessageRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [
        new(MessageRole.User, [new TextContent("Hello!")]),
      ]
    );

    var result = Client.CreateMessageAsync(request);

    var actualEvents = await result.ToListAsync();

    actualEvents.Should().BeEquivalentTo(events);
  }

  [Fact]
  public async Task CreateMessageAsync_WhenCalledMessageIsStreamedAndToolProvide_ItShouldReturnToolCall()
  {
    var eventStream = EventTestData.GetEventStream();

    _mockHttpMessageHandler
      .WhenCreateStreamMessageRequest()
      .Respond(
        HttpStatusCode.OK,
        "text/event-stream",
        eventStream
      );

    var getWeather = (string location, string unit) => $"The weather in {location} is 72°{unit}";

    var request = new StreamMessageRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [
        new(MessageRole.User, [new TextContent("Hello!")]),
      ],
      tools: [
        Tool.CreateFromFunction("get_weather", "Gets the weather for a location", getWeather)
      ]
    );

    var result = Client.CreateMessageAsync(request);
    var msgCompleteEvent = await result
      .Where(e => e.Type is EventType.MessageComplete)
      .FirstAsync();

    msgCompleteEvent.Data.Should().BeOfType<MessageCompleteEventData>();

    var toolCall = msgCompleteEvent.Data.As<MessageCompleteEventData>().Message.ToolCall;
    var toolCallResult = await toolCall!.InvokeAsync<string>();

    toolCallResult.IsSuccess.Should().BeTrue();
    toolCallResult.Value.Should().Be(getWeather("San Francisco, CA", "fahrenheit"));
  }

  [Fact]
  public async Task CreateMessageAsync_WhenCalledMessageIsStreamAndRequestFails_ItShouldReturnErrorEvent()
  {
    _mockHttpMessageHandler
      .WhenCreateStreamMessageRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""messages: roles must alternate between user and assistant, but found multiple user roles in a row""
            }
          }"
      );

    var request = new StreamMessageRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [
        new(MessageRole.User, [new TextContent("Hello!")]),
        new(MessageRole.User, [new TextContent("Hello!")])
      ]
    );

    var result = Client.CreateMessageAsync(request);
    var events = await result.ToListAsync();

    events.Should().HaveCount(1);
    events[0].Type.Should().Be(EventType.Error);
    events[0].Data.Should().BeOfType<ErrorEventData>();
    events[0].Data.Should().BeEquivalentTo(new ErrorEventData(
      new InvalidRequestError(
        "messages: roles must alternate between user and assistant, but found multiple user roles in a row"
      )
    ));
  }

  [Fact]
  public async Task CreateMessageAsync_WhenCalledMessageIsStreamedRequestFailsAndCanNotDeserializeError_ItShouldReturnUnknownErrorEvent()
  {
    _mockHttpMessageHandler
      .WhenCreateStreamMessageRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"null"
      );

    var request = new StreamMessageRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [
        new(MessageRole.User, [new TextContent("Hello!")]),
        new(MessageRole.User, [new TextContent("Hello!")])
      ]
    );

    var result = Client.CreateMessageAsync(request);
    var events = await result.ToListAsync();

    events.Should().HaveCount(1);
    events[0].Type.Should().Be(EventType.Error);
    events[0].Data.Should().BeOfType<ErrorEventData>();
    events[0].Data.Should().BeEquivalentTo(new ErrorEventData(new ApiError()));
  }

  [Fact]
  public async Task CreateMessageAsync_WhenCalledAndMessageCreatedWithDocumentContent_ItShouldReturnMessage()
  {
    _mockHttpMessageHandler
      .WhenCreateMessageRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""content"": [
              {
                ""text"": ""It is a PDF"",
                ""type"": ""text""
              }
            ],
            ""id"": ""msg_013Zva2CMHLNnXjNJJKqJ2EF"",
            ""model"": ""claude-3-5-sonnet-20240620"",
            ""role"": ""assistant"",
            ""stop_reason"": ""end_turn"",
            ""stop_sequence"": null,
            ""type"": ""message"",
            ""usage"": {
              ""input_tokens"": 10,
              ""output_tokens"": 25
            }
          }"
      );

    var request = new MessageRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [
        new(MessageRole.User, [new TextContent("What is this?")]),
        new(MessageRole.User, [new DocumentContent("application/pdf", "data")])
      ]
    );

    var result = await Client.CreateMessageAsync(request);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<MessageResponse>();

    var message = result.Value;
    message.Id.Should().Be("msg_013Zva2CMHLNnXjNJJKqJ2EF");
    message.Model.Should().Be("claude-3-5-sonnet-20240620");
    message.Role.Should().Be("assistant");
    message.StopReason.Should().Be("end_turn");
    message.StopSequence.Should().BeNull();
    message.Type.Should().Be("message");
    message.Usage.InputTokens.Should().Be(10);
    message.Usage.OutputTokens.Should().Be(25);
    message.Content.Should().HaveCount(1);
    message.ToolCall.Should().BeNull();

    var textContent = message.Content[0];
    textContent.Should().BeOfType<TextContent>();
    textContent.As<TextContent>().Text.Should().Be("It is a PDF");
    textContent.As<TextContent>().Type.Should().Be("text");
  }

  [Fact]
  public async Task CountMessageTokensAsync_WhenCalled_ItShouldReturnCountTokensResponse()
  {
    _mockHttpMessageHandler
      .WhenCountMessageTokensRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""input_tokens"": 10
          }"
      );

    var request = new CountMessageTokensRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [
        new(MessageRole.User, [new TextContent("Hello!")]),
      ]
    );

    var result = await Client.CountMessageTokensAsync(request);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<TokenCountResponse>();
    result.Value.InputTokens.Should().Be(10);
  }

  [Fact]
  public async Task CountMessageTokensAsync_WhenCalledAndErrorReturned_ItShouldHandleError()
  {
    _mockHttpMessageHandler
      .WhenCountMessageTokensRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""messages: roles must alternate between user and assistant, but found multiple user roles in a row""
            }
          }"
      );

    var request = new CountMessageTokensRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [
        new(MessageRole.User, [new TextContent("Hello!")]),
        new(MessageRole.User, [new TextContent("Hello!")])
      ]
    );

    var result = await Client.CountMessageTokensAsync(request);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }

  [Fact]
  public async Task CountMessageTokensAsync_WhenCalledRequestFailsAndCanNotDeserializeError_ItShouldReturnUnknownError()
  {
    _mockHttpMessageHandler
      .WhenCountMessageTokensRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"null"
      );

    var request = new CountMessageTokensRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [
        new(MessageRole.User, [new TextContent("Hello!")]),
        new(MessageRole.User, [new TextContent("Hello!")])
      ]
    );

    var result = await Client.CountMessageTokensAsync(request);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<ApiError>();
  }

  [Fact]
  public async Task CountMessageTokensAsync_WhenCalledAndResponseCanNotBeDeserialized_ItShouldReturnEmptyResponse()
  {
    _mockHttpMessageHandler
      .WhenCountMessageTokensRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"null"
      );

    var request = new CountMessageTokensRequest(
      model: AnthropicModels.Claude35Sonnet,
      messages: [
        new(MessageRole.User, [new TextContent("Hello!")]),
      ]
    );

    var result = await Client.CountMessageTokensAsync(request);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<TokenCountResponse>();
    result.Value.InputTokens.Should().Be(0);
  }

  [Fact]
  public async Task ListModelsAsync_WhenCalledWithPagingRequestUsingDefaultValues_ItShouldReturnListOfModels()
  {
    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""type"": ""model"",
                ""id"": ""claude-3-5-sonnet-20241022"",
                ""display_name"": ""Claude 3.5 Sonnet (New)"",
                ""created_at"": ""2024-10-22T00:00:00Z""
              }
            ],
            ""has_more"": true,
            ""first_id"": ""first_id"",
            ""last_id"": ""last_id""
          }"
      );

    var result = await Client.ListModelsAsync();

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<Page<AnthropicModel>>();
    result.Value.HasMore.Should().BeTrue();
    result.Value.FirstId.Should().Be("first_id");
    result.Value.LastId.Should().Be("last_id");
    result.Value.Data.Should().BeEquivalentTo(new AnthropicModel[]
    {
      new()
      {
        Type = "model",
        Id = "claude-3-5-sonnet-20241022",
        DisplayName = "Claude 3.5 Sonnet (New)",
        CreatedAt = DateTimeOffset.Parse("2024-10-22T00:00:00Z")
      }
    });
  }

  [Fact]
  public async Task ListModelsAsync_WhenCalledWithPagingRequestUsingCustomValues_ItShouldReturnListOfModels()
  {
    var pagingRequest = new PagingRequest(afterId: "next_id", limit: 10);

    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .WithQueryString(new Dictionary<string, string>
      {
        { "after_id", pagingRequest.AfterId },
        { "limit", pagingRequest.Limit.ToString() },
      })
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""type"": ""model"",
                ""id"": ""claude-3-5-sonnet-20241022"",
                ""display_name"": ""Claude 3.5 Sonnet (New)"",
                ""created_at"": ""2024-10-22T00:00:00Z""
              }
            ],
            ""has_more"": true,
            ""first_id"": ""first_id"",
            ""last_id"": ""last_id""
          }"
      );

    var result = await Client.ListModelsAsync(pagingRequest);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<Page<AnthropicModel>>();
    result.Value.HasMore.Should().BeTrue();
    result.Value.FirstId.Should().Be("first_id");
    result.Value.LastId.Should().Be("last_id");
    result.Value.Data.Should().BeEquivalentTo(new AnthropicModel[]
    {
      new()
      {
        Type = "model",
        Id = "claude-3-5-sonnet-20241022",
        DisplayName = "Claude 3.5 Sonnet (New)",
        CreatedAt = DateTimeOffset.Parse("2024-10-22T00:00:00Z")
      }
    });
  }

  [Fact]
  public async Task ListModelsAsync_WhenCalledAndNoModelsReturned_ItShouldReturnEmptyList()
  {
    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [],
            ""has_more"": false,
            ""first_id"": null,
            ""last_id"": null
          }"
      );

    var result = await Client.ListModelsAsync();

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<Page<AnthropicModel>>();
    result.Value.HasMore.Should().BeFalse();
    result.Value.FirstId.Should().BeNull();
    result.Value.LastId.Should().BeNull();
    result.Value.Data.Should().BeEmpty();
  }

  [Fact]
  public async Task ListModelsAsync_WhenCalledAndErrorReturned_ItShouldHandleError()
  {
    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""messages: roles must alternate between user and assistant, but found multiple user roles in a row""
            }
          }"
      );

    var result = await Client.ListModelsAsync();

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }

  [Fact]
  public async Task ListModelsAsync_WhenCalledRequestFailsAndCanNotDeserializeError_ItShouldReturnUnknownError()
  {
    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"null"
      );

    var result = await Client.ListModelsAsync();

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<ApiError>();
  }

  [Fact]
  public async Task ListModelAsync_WhenCalledRequestSucceedsAndCanNotDeserializeResponse_ItShouldReturnEmptyPage()
  {
    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"null"
      );

    var result = await Client.ListModelsAsync();

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<Page<AnthropicModel>>();
    result.Value.HasMore.Should().BeFalse();
    result.Value.FirstId.Should().BeEmpty();
    result.Value.LastId.Should().BeEmpty();
    result.Value.Data.Should().BeEmpty();
  }

  [Fact]
  public async Task ListAllModelsAsync_WhenCalled_ItShouldReturnAllModels()
  {
    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .WithExactQueryString(new Dictionary<string, string>()
      {
        { "limit", "20" },
      })
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""type"": ""model"",
                ""id"": ""claude-3-5-sonnet-20241022"",
                ""display_name"": ""Claude 3.5 Sonnet (New)"",
                ""created_at"": ""2024-10-22T00:00:00Z""
              }
            ],
            ""has_more"": true,
            ""first_id"": ""1"",
            ""last_id"": ""1""
          }"
      );

    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .WithExactQueryString(new Dictionary<string, string>()
      {
        { "after_id", "1" },
        { "limit", "20" },
      })
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""type"": ""model"",
                ""id"": ""claude-3-5-sonnet-20241023"",
                ""display_name"": ""Claude 3.5 Sonnet (New)"",
                ""created_at"": ""2024-10-23T00:00:00Z""
              }
            ],
            ""has_more"": false,
            ""first_id"": ""2"",
            ""last_id"": ""2""
          }"
      );

    var pageResponses = Client.ListAllModelsAsync();
    var collectedPages = new List<Page<AnthropicModel>>();

    await foreach (var response in pageResponses)
    {
      response.IsSuccess.Should().BeTrue();
      response.Value.Should().BeOfType<Page<AnthropicModel>>();
      collectedPages.Add(response.Value);
    }

    collectedPages.Should().HaveCount(2);
    collectedPages.Should().BeEquivalentTo(new Page<AnthropicModel>[]
    {
      new()
      {
        HasMore = true,
        FirstId = "1",
        LastId = "1",
        Data = [
          new()
          {
            Type = "model",
            Id = "claude-3-5-sonnet-20241022",
            DisplayName = "Claude 3.5 Sonnet (New)",
            CreatedAt = DateTimeOffset.Parse("2024-10-22T00:00:00Z")
          }
        ]
      },
      new()
      {
        HasMore = false,
        FirstId = "2",
        LastId = "2",
        Data = [
          new()
          {
            Type = "model",
            Id = "claude-3-5-sonnet-20241023",
            DisplayName = "Claude 3.5 Sonnet (New)",
            CreatedAt = DateTimeOffset.Parse("2024-10-23T00:00:00Z")
          }
        ]
      }
    });
  }

  [Fact]
  public async Task ListAllModelsAsync_WhenCalledAndErrorReturned_ItShouldHandleError()
  {
    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""messages: roles must alternate between user and assistant, but found multiple user roles in a row""
            }
          }"
      );

    var responses = Client.ListAllModelsAsync();
    var count = 0;

    await foreach (var page in responses)
    {
      count++;
      page.IsSuccess.Should().BeFalse();
      page.Error.Should().BeOfType<AnthropicError>();
      page.Error.Error.Should().BeOfType<InvalidRequestError>();
    }

    count.Should().Be(1);
  }

  [Fact]
  public async Task ListAllModelsAsync_WhenCalledRequestFailsAndCanNotDeserializeError_ItShouldReturnUnknownError()
  {
    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"null"
      );

    var responses = Client.ListAllModelsAsync();
    var count = 0;

    await foreach (var page in responses)
    {
      count++;
      page.IsSuccess.Should().BeFalse();
      page.Error.Should().BeOfType<AnthropicError>();
      page.Error.Error.Should().BeOfType<ApiError>();
    }

    count.Should().Be(1);
  }

  [Fact]
  public async Task ListAllModelsAsync_WhenFirstPageSucceedsAndSecondPageFails_ItShouldReturnFirstPageAndError()
  {
    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .WithExactQueryString(new Dictionary<string, string>
      {
        { "limit", "20" },
      })
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""type"": ""model"",
                ""id"": ""claude-3-5-sonnet-20241022"",
                ""display_name"": ""Claude 3.5 Sonnet (New)"",
                ""created_at"": ""2024-10-22T00:00:00Z""
              }
            ],
            ""has_more"": true,
            ""first_id"": ""1"",
            ""last_id"": ""1""
          }"
      );

    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .WithExactQueryString(new Dictionary<string, string>
      {
        { "after_id", "1" },
        { "limit", "20" },
      })
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""messages: roles must alternate between user and assistant, but found multiple user roles in a row""
            }
          }"
      );

    var responses = Client.ListAllModelsAsync();
    var count = 0;

    await foreach (var page in responses)
    {
      count++;

      if (count == 1)
      {
        page.IsSuccess.Should().BeTrue();
        page.Value.Should().BeOfType<Page<AnthropicModel>>();
      }
      else
      {
        page.IsSuccess.Should().BeFalse();
        page.Error.Should().BeOfType<AnthropicError>();
        page.Error.Error.Should().BeOfType<InvalidRequestError>();
      }
    }

    count.Should().Be(2);
  }

  [Fact]
  public async Task ListAllModelsAsync_WhenFirstPageSucceedsButResponseCanNotBeDeserialized_ItShouldReturnEmptyPage()
  {
    _mockHttpMessageHandler
      .WhenListModelsRequest()
      .WithExactQueryString(new Dictionary<string, string>
      {
        { "limit", "20" },
      })
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"null"
      );

    var responses = Client.ListAllModelsAsync();
    var count = 0;

    await foreach (var page in responses)
    {
      count++;
      page.IsSuccess.Should().BeTrue();
      page.Value.Should().BeOfType<Page<AnthropicModel>>();
      page.Value.Data.Should().BeEmpty();
    }

    count.Should().Be(1);
  }

  [Fact]
  public async Task GetModelAsync_WhenCalled_ItShouldReturnModel()
  {
    var modelId = "claude-3-5-sonnet-20241022";

    _mockHttpMessageHandler
      .WhenGetModelRequest(modelId)
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""type"": ""model"",
            ""id"": ""claude-3-5-sonnet-20241022"",
            ""display_name"": ""Claude 3.5 Sonnet (New)"",
            ""created_at"": ""2024-10-22T00:00:00Z""
          }"
      );

    var result = await Client.GetModelAsync(modelId);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<AnthropicModel>();
    result.Value.Type.Should().Be("model");
    result.Value.Id.Should().Be("claude-3-5-sonnet-20241022");
    result.Value.DisplayName.Should().Be("Claude 3.5 Sonnet (New)");
    result.Value.CreatedAt.Should().Be(DateTimeOffset.Parse("2024-10-22T00:00:00Z"));
  }

  [Fact]
  public async Task GetModelAsync_WhenCalledAndErrorReturned_ItShouldHandleError()
  {
    var modelId = "claude-3-5-sonnet-20241022";

    _mockHttpMessageHandler
      .WhenGetModelRequest(modelId)
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""messages: roles must alternate between user and assistant, but found multiple user roles in a row""
            }
          }"
      );

    var result = await Client.GetModelAsync(modelId);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }

  [Fact]
  public async Task GetModelAsync_WhenCalledRequestFailsAndCanNotDeserializeError_ItShouldReturnUnknownError()
  {
    var modelId = "claude-3-5-sonnet-20241022";

    _mockHttpMessageHandler
      .WhenGetModelRequest(modelId)
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"null"
      );

    var result = await Client.GetModelAsync(modelId);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<ApiError>();
  }

  [Fact]
  public async Task GetModelAsync_WhenCalledAndCanNotDeserializeModel_ItShouldReturnEmptyModel()
  {
    var modelId = "claude-3-5-sonnet-20241022";

    _mockHttpMessageHandler
      .WhenGetModelRequest(modelId)
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"null"
      );

    var result = await Client.GetModelAsync(modelId);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<AnthropicModel>();
  }

  [Fact]
  public async Task CreateMessageBatchAsync_WhenCalled_ItShouldReturnBatch()
  {
    _mockHttpMessageHandler
      .WhenCreateMessageBatchRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""id"": ""msgbatch_013Zva2CMHLNnXjNJJKqJ2EF"",
            ""type"": ""message_batch"",
            ""processing_status"": ""in_progress"",
            ""request_counts"": {
              ""processing"": 100,
              ""succeeded"": 50,
              ""errored"": 30,
              ""canceled"": 10,
              ""expired"": 10
            },
            ""ended_at"": ""2024-08-20T18:37:24.100435Z"",
            ""created_at"": ""2024-08-20T18:37:24.100435Z"",
            ""expires_at"": ""2024-08-20T18:37:24.100435Z"",
            ""archived_at"": ""2024-08-20T18:37:24.100435Z"",
            ""cancel_initiated_at"": ""2024-08-20T18:37:24.100435Z"",
            ""results_url"": ""https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results""
          }"
      );

    var request = new MessageBatchRequest([new("custom_id", new())]);

    var result = await Client.CreateMessageBatchAsync(request);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<MessageBatchResponse>();
    result.Value.Id.Should().Be("msgbatch_013Zva2CMHLNnXjNJJKqJ2EF");
    result.Value.Type.Should().Be("message_batch");
    result.Value.ProcessingStatus.Should().Be("in_progress");
    result.Value.RequestCounts.Should().BeEquivalentTo(new MessageBatchRequestCounts
    {
      Processing = 100,
      Succeeded = 50,
      Errored = 30,
      Canceled = 10,
      Expired = 10
    });

    result.Value.EndedAt.Should().Be(DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"));
    result.Value.CreatedAt.Should().Be(DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"));
    result.Value.ExpiresAt.Should().Be(DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"));
    result.Value.ArchivedAt.Should().Be(DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"));
    result.Value.CancelInitiatedAt.Should().Be(DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"));
    result.Value.ResultsUrl.Should().Be("https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results");
  }

  [Fact]
  public async Task CreateMessageBatchAsync_WhenCalledAndErrorReturned_ItShouldHandleError()
  {
    _mockHttpMessageHandler
      .WhenCreateMessageBatchRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""messages: roles must alternate between user and assistant, but found multiple user roles in a row""
            }
          }"
      );

    var request = new MessageBatchRequest([new("custom_id", new())]);

    var result = await Client.CreateMessageBatchAsync(request);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }

  [Fact]
  public async Task CreateMessageBatchAsync_WhenCalledRequestFailsAndErrorCanNotBeDeserialized_ItShouldReturnUnknownError()
  {
    _mockHttpMessageHandler
      .WhenCreateMessageBatchRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"null"
      );

    var request = new MessageBatchRequest([new("custom_id", new())]);

    var result = await Client.CreateMessageBatchAsync(request);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<ApiError>();
  }

  [Fact]
  public async Task CreateMessageBatchAsync_WhenCalledRequestSucceedsAndCanNotDeserializeResponse_ItShouldReturnEmptyResponse()
  {
    _mockHttpMessageHandler
      .WhenCreateMessageBatchRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"null"
      );

    var request = new MessageBatchRequest([new("custom_id", new())]);

    var result = await Client.CreateMessageBatchAsync(request);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<MessageBatchResponse>();
    result.Value.Should().BeEquivalentTo(new MessageBatchResponse());
  }

  [Fact]
  public async Task GetMessageBatchAsync_WhenCalled_ItShouldReturnBatch()
  {
    var batchId = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenGetMessageBatchRequest(batchId)
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""id"": ""msgbatch_013Zva2CMHLNnXjNJJKqJ2EF"",
            ""type"": ""message_batch"",
            ""processing_status"": ""in_progress"",
            ""request_counts"": {
              ""processing"": 100,
              ""succeeded"": 50,
              ""errored"": 30,
              ""canceled"": 10,
              ""expired"": 10
            },
            ""ended_at"": ""2024-08-20T18:37:24.100435Z"",
            ""created_at"": ""2024-08-20T18:37:24.100435Z"",
            ""expires_at"": ""2024-08-20T18:37:24.100435Z"",
            ""archived_at"": ""2024-08-20T18:37:24.100435Z"",
            ""cancel_initiated_at"": ""2024-08-20T18:37:24.100435Z"",
            ""results_url"": ""https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results""
          }"
      );

    var result = await Client.GetMessageBatchAsync(batchId);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeEquivalentTo(new MessageBatchResponse()
    {
      Id = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF",
      Type = "message_batch",
      ProcessingStatus = "in_progress",
      RequestCounts = new MessageBatchRequestCounts
      {
        Processing = 100,
        Succeeded = 50,
        Errored = 30,
        Canceled = 10,
        Expired = 10
      },
      EndedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      CreatedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      ExpiresAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      ArchivedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      CancelInitiatedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      ResultsUrl = "https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results"
    });
  }

  [Fact]
  public async Task GetMessageBatchAsync_WhenCalledAndErrorReturned_ItShouldHandleError()
  {
    var batchId = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenGetMessageBatchRequest(batchId)
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""messages: roles must alternate between user and assistant, but found multiple user roles in a row""
            }
          }"
      );

    var result = await Client.GetMessageBatchAsync(batchId);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }

  [Fact]
  public async Task GetMessageBatchAsync_WhenCalledRequestFailsAndErrorCanNotBeDeserialized_ItShouldReturnUnknownError()
  {
    var batchId = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenGetMessageBatchRequest(batchId)
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"null"
      );

    var result = await Client.GetMessageBatchAsync(batchId);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<ApiError>();
  }

  [Fact]
  public async Task GetMessageBatchAsync_WhenCalledAndCanNotDeserializeResponse_ItShouldReturnEmptyResponse()
  {
    var batchId = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenGetMessageBatchRequest(batchId)
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"null"
      );

    var result = await Client.GetMessageBatchAsync(batchId);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<MessageBatchResponse>();
  }

  [Fact]
  public async Task GetMessageBatchResultsAsync_WhenCalledAndSuccessful_ItShouldReturnAllBatchResults()
  {
    var batchId = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF";
    var batchResultsPath = TestFileHelper.GetTestFilePath("batch_results.jsonl");
    var batchResultsText = await File.ReadAllTextAsync(batchResultsPath);
    var batchResults = batchResultsText.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
    var expectedResults = batchResults.Select(Deserialize<MessageBatchResultItem>);

    _mockHttpMessageHandler
      .WhenGetMessageBatchResultsRequest(batchId)
      .Respond(
        HttpStatusCode.OK,
        "application/x-jsonl",
        batchResultsText
      );

    var result = await Client.GetMessageBatchResultsAsync(batchId);

    result.IsSuccess.Should().BeTrue();

    var actualResults = await result.Value.ToListAsync();

    actualResults.Should().BeEquivalentTo(expectedResults);
  }

  [Fact]
  public async Task GetMessageBatchResultsAsync_WhenCalledSuccessfulAndResultCanNotBeDeserialized_ItShouldReturnEmptyResults()
  {
    var batchId = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF";
    var expectedResults = new List<MessageBatchResultItem>()
    {
      new(),
    };

    _mockHttpMessageHandler
      .WhenGetMessageBatchResultsRequest(batchId)
      .Respond(
        HttpStatusCode.OK,
        "application/x-jsonl",
        "null"
      );

    var result = await Client.GetMessageBatchResultsAsync(batchId);

    result.IsSuccess.Should().BeTrue();

    var actualResults = await result.Value.ToListAsync();

    actualResults.Should().BeEquivalentTo(expectedResults);
  }

  [Fact]
  public async Task GetMessageBatchResultsAsync_WhenCalledAndRequestFails_ItShouldReturnError()
  {
    var batchId = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenGetMessageBatchResultsRequest(batchId)
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""messages: roles must alternate between user and assistant, but found multiple user roles in a row""
            }
          }"
      );

    var result = await Client.GetMessageBatchResultsAsync(batchId);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }

  [Fact]
  public async Task GetMessageBatchResultsAsync_WhenCalledRequestFailsAndCanNotDeserializeError_ItShouldReturnUnknownError()
  {
    var batchId = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenGetMessageBatchResultsRequest(batchId)
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"null"
      );

    var result = await Client.GetMessageBatchResultsAsync(batchId);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<ApiError>();
  }

  [Fact]
  public async Task ListMessageBatchesAsync_WhenCalledAndSuccessful_ItShouldReturnPageOfBatches()
  {
    _mockHttpMessageHandler
      .WhenListMessageBatchesRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""id"": ""msgbatch_013Zva2CMHLNnXjNJJKqJ2EF"",
                ""type"": ""message_batch"",
                ""processing_status"": ""in_progress"",
                ""request_counts"": {
                  ""processing"": 100,
                  ""succeeded"": 50,
                  ""errored"": 30,
                  ""canceled"": 10,
                  ""expired"": 10
                },
                ""ended_at"": ""2024-08-20T18:37:24.100435Z"",
                ""created_at"": ""2024-08-20T18:37:24.100435Z"",
                ""expires_at"": ""2024-08-20T18:37:24.100435Z"",
                ""archived_at"": ""2024-08-20T18:37:24.100435Z"",
                ""cancel_initiated_at"": ""2024-08-20T18:37:24.100435Z"",
                ""results_url"": ""https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results""
              }
            ],
            ""has_more"": true,
            ""first_id"": ""1"",
            ""last_id"": ""1""
          }"
      );

    var result = await Client.ListMessageBatchesAsync();

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<Page<MessageBatchResponse>>();
    result.Value.HasMore.Should().BeTrue();
    result.Value.FirstId.Should().Be("1");
    result.Value.LastId.Should().Be("1");
    result.Value.Data.Should().BeEquivalentTo(new MessageBatchResponse[]
    {
      new()
      {
        Id = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF",
        Type = "message_batch",
        ProcessingStatus = "in_progress",
        RequestCounts = new MessageBatchRequestCounts
        {
          Processing = 100,
          Succeeded = 50,
          Errored = 30,
          Canceled = 10,
          Expired = 10
        },
        EndedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
        CreatedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
        ExpiresAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
        ArchivedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
        CancelInitiatedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
        ResultsUrl = "https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results"
      }
    });
  }

  [Fact]
  public async Task ListMessageBatchesAsync_WhenCalledWithPagingRequestAndSuccessful_ItShouldReturnPageOfBatches()
  {
    var pagingRequest = new PagingRequest(afterId: "next_id", limit: 10);

    _mockHttpMessageHandler
      .WhenListMessageBatchesRequest()
      .WithQueryString(new Dictionary<string, string>
      {
        { "after_id", pagingRequest.AfterId },
        { "limit", pagingRequest.Limit.ToString() },
      })
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""id"": ""msgbatch_013Zva2CMHLNnXjNJJKqJ2EF"",
                ""type"": ""message_batch"",
                ""processing_status"": ""in_progress"",
                ""request_counts"": {
                  ""processing"": 100,
                  ""succeeded"": 50,
                  ""errored"": 30,
                  ""canceled"": 10,
                  ""expired"": 10
                },
                ""ended_at"": ""2024-08-20T18:37:24.100435Z"",
                ""created_at"": ""2024-08-20T18:37:24.100435Z"",
                ""expires_at"": ""2024-08-20T18:37:24.100435Z"",
                ""archived_at"": ""2024-08-20T18:37:24.100435Z"",
                ""cancel_initiated_at"": ""2024-08-20T18:37:24.100435Z"",
                ""results_url"": ""https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results""
              }
            ],
            ""has_more"": true,
            ""first_id"": ""1"",
            ""last_id"": ""1""
          }"
      );

    var result = await Client.ListMessageBatchesAsync(pagingRequest);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<Page<MessageBatchResponse>>();
    result.Value.HasMore.Should().BeTrue();
    result.Value.FirstId.Should().Be("1");
    result.Value.LastId.Should().Be("1");
    result.Value.Data.Should().BeEquivalentTo(new MessageBatchResponse[]
    {
      new()
      {
        Id = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF",
        Type = "message_batch",
        ProcessingStatus = "in_progress",
        RequestCounts = new MessageBatchRequestCounts
        {
          Processing = 100,
          Succeeded = 50,
          Errored = 30,
          Canceled = 10,
          Expired = 10
        },
        EndedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
        CreatedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
        ExpiresAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
        ArchivedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
        CancelInitiatedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
        ResultsUrl = "https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results"
      }
    });
  }

  [Fact]
  public async Task ListMessageBatchesAsync_WhenCalledAndNoBatchesReturned_ItShouldReturnEmptyList()
  {
    _mockHttpMessageHandler
      .WhenListMessageBatchesRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [],
            ""has_more"": false,
            ""first_id"": null,
            ""last_id"": null
          }"
      );

    var result = await Client.ListMessageBatchesAsync();

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<Page<MessageBatchResponse>>();
    result.Value.HasMore.Should().BeFalse();
    result.Value.FirstId.Should().BeNull();
    result.Value.LastId.Should().BeNull();
    result.Value.Data.Should().BeEmpty();
  }

  [Fact]
  public async Task ListMessageBatchesAsync_WhenCalledAndErrorReturned_ItShouldHandleError()
  {
    _mockHttpMessageHandler
      .WhenListMessageBatchesRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""messages: roles must alternate between user and assistant, but found multiple user roles in a row""
            }
          }"
      );

    var result = await Client.ListMessageBatchesAsync();

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }

  [Fact]
  public async Task ListMessageBatchesAsync_WhenCalledRequestFailsAndCanNotDeserializeError_ItShouldReturnUnknownError()
  {
    _mockHttpMessageHandler
      .WhenListMessageBatchesRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"null"
      );

    var result = await Client.ListMessageBatchesAsync();

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<ApiError>();
  }

  [Fact]
  public async Task ListMessageBatchesAsync_WhenCalledRequestSucceedsAndCanNotDeserializeResponse_ItShouldReturnEmptyPage()
  {
    _mockHttpMessageHandler
      .WhenListMessageBatchesRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"null"
      );

    var result = await Client.ListMessageBatchesAsync();

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<Page<MessageBatchResponse>>();
    result.Value.HasMore.Should().BeFalse();
    result.Value.FirstId.Should().BeEmpty();
    result.Value.LastId.Should().BeEmpty();
    result.Value.Data.Should().BeEmpty();
  }

  [Fact]
  public async Task ListAllMessageBatchesAsync_WhenCalled_ItShouldReturnAllBatches()
  {
    _mockHttpMessageHandler
      .WhenListMessageBatchesRequest()
      .WithExactQueryString(new Dictionary<string, string>()
      {
        { "limit", "20" },
      })
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""id"": ""msgbatch_013Zva2CMHLNnXjNJJKqJ2EF"",
                ""type"": ""message_batch"",
                ""processing_status"": ""in_progress"",
                ""request_counts"": {
                  ""processing"": 100,
                  ""succeeded"": 50,
                  ""errored"": 30,
                  ""canceled"": 10,
                  ""expired"": 10
                },
                ""ended_at"": ""2024-08-20T18:37:24.100435Z"",
                ""created_at"": ""2024-08-20T18:37:24.100435Z"",
                ""expires_at"": ""2024-08-20T18:37:24.100435Z"",
                ""archived_at"": ""2024-08-20T18:37:24.100435Z"",
                ""cancel_initiated_at"": ""2024-08-20T18:37:24.100435Z"",
                ""results_url"": ""https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results""
              }
            ],
            ""has_more"": true,
            ""first_id"": ""1"",
            ""last_id"": ""1""
          }"
      );

    _mockHttpMessageHandler
      .WhenListMessageBatchesRequest()
      .WithExactQueryString(new Dictionary<string, string>()
      {
        { "after_id", "1" },
        { "limit", "20" },
      })
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""id"": ""msgbatch_013Zva2CMHLNnXjNJJKqJ2EF"",
                ""type"": ""message_batch"",
                ""processing_status"": ""in_progress"",
                ""request_counts"": {
                  ""processing"": 100,
                  ""succeeded"": 50,
                  ""errored"": 30,
                  ""canceled"": 10,
                  ""expired"": 10
                },
                ""ended_at"": ""2024-08-20T18:37:24.100435Z"",
                ""created_at"": ""2024-08-20T18:37:24.100435Z"",
                ""expires_at"": ""2024-08-20T18:37:24.100435Z"",
                ""archived_at"": ""2024-08-20T18:37:24.100435Z"",
                ""cancel_initiated_at"": ""2024-08-20T18:37:24.100435Z"",
                ""results_url"": ""https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results""
              }
            ],
            ""has_more"": false,
            ""first_id"": ""2"",
            ""last_id"": ""2""
          }"
      );

    var pageResponses = Client.ListAllMessageBatchesAsync();
    var collectedPages = new List<Page<MessageBatchResponse>>();

    await foreach (var response in pageResponses)
    {
      response.IsSuccess.Should().BeTrue();
      response.Value.Should().BeOfType<Page<MessageBatchResponse>>();
      collectedPages.Add(response.Value);
    }

    var expectedMessageBatchResponse = new MessageBatchResponse()
    {
      Id = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF",
      Type = "message_batch",
      ProcessingStatus = "in_progress",
      RequestCounts = new MessageBatchRequestCounts
      {
        Processing = 100,
        Succeeded = 50,
        Errored = 30,
        Canceled = 10,
        Expired = 10
      },
      EndedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      CreatedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      ExpiresAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      ArchivedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      CancelInitiatedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      ResultsUrl = "https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results"
    };

    collectedPages.Should().HaveCount(2);
    collectedPages.Should().BeEquivalentTo(new List<Page<MessageBatchResponse>>()
    {
      new()
      {
        Data = [expectedMessageBatchResponse],
        FirstId = "1",
        LastId = "1",
        HasMore = true
      },
      new()
      {
        Data = [expectedMessageBatchResponse],
        FirstId = "2",
        LastId = "2",
        HasMore = false
      }
    });
  }

  [Fact]
  public async Task CancelMessageBatchAsync_WhenCalled_ItShouldReturnBatch()
  {
    var batchId = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenCancelMessageBatchRequest(batchId)
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""id"": ""msgbatch_013Zva2CMHLNnXjNJJKqJ2EF"",
            ""type"": ""message_batch"",
            ""processing_status"": ""in_progress"",
            ""request_counts"": {
              ""processing"": 100,
              ""succeeded"": 50,
              ""errored"": 30,
              ""canceled"": 10,
              ""expired"": 10
            },
            ""ended_at"": ""2024-08-20T18:37:24.100435Z"",
            ""created_at"": ""2024-08-20T18:37:24.100435Z"",
            ""expires_at"": ""2024-08-20T18:37:24.100435Z"",
            ""archived_at"": ""2024-08-20T18:37:24.100435Z"",
            ""cancel_initiated_at"": ""2024-08-20T18:37:24.100435Z"",
            ""results_url"": ""https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results""
          }"
      );

    var result = await Client.CancelMessageBatchAsync(batchId);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeEquivalentTo(new MessageBatchResponse()
    {
      Id = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF",
      Type = "message_batch",
      ProcessingStatus = "in_progress",
      RequestCounts = new MessageBatchRequestCounts
      {
        Processing = 100,
        Succeeded = 50,
        Errored = 30,
        Canceled = 10,
        Expired = 10
      },
      EndedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      CreatedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      ExpiresAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      ArchivedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      CancelInitiatedAt = DateTimeOffset.Parse("2024-08-20T18:37:24.100435Z"),
      ResultsUrl = "https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results"
    });
  }

  [Fact]
  public async Task CancelMessageBatchAsync_WhenCalledAndFails_ItShouldReturnError()
  {
    var batchId = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenCancelMessageBatchRequest(batchId)
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""batch: batch not found""
            }
          }"
      );

    var result = await Client.CancelMessageBatchAsync(batchId);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }

  [Fact]
  public async Task DeleteMessageBatchAsync_WhenCalled_ItShouldReturnDeletionResponse()
  {
    var batchId = "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenDeleteMessageBatchRequest(batchId)
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""id"": ""msgbatch_013Zva2CMHLNnXjNJJKqJ2EF"",
            ""type"": ""message_batch_deleted""
          }"
      );

    var result = await Client.DeleteMessageBatchAsync(batchId);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<MessageBatchDeleteResponse>();
    result.Value.Id.Should().Be(batchId);
    result.Value.Type.Should().Be("message_batch_deleted");
  }

  [Fact]
  public async Task CreateFileAsync_WhenCalled_ItShouldReturnFile()
  {
    _mockHttpMessageHandler
      .WhenCreateFileRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
          ""created_at"": ""2023-11-07T05:31:56Z"",
          ""downloadable"": false,
          ""filename"": ""example.txt"",
          ""id"": ""file_013Zva2CMHLNnXjNJJKqJ2EF"",
          ""mime_type"": ""text/plain"",
          ""size_bytes"": 1234,
          ""type"": ""file""
        }"
      );

    var fileContent = new MemoryStream(Encoding.UTF8.GetBytes("Example file content"));
    var request = new CreateFileRequest(fileContent, "example.txt", "text/plain");

    var result = await Client.CreateFileAsync(request);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeEquivalentTo(new AnthropicFile()
    {
      CreatedAt = DateTimeOffset.Parse("2023-11-07T05:31:56Z"),
      Downloadable = false,
      Name = "example.txt",
      Id = "file_013Zva2CMHLNnXjNJJKqJ2EF",
      MimeType = "text/plain",
      Size = 1234,
      Type = "file"
    });
  }

  [Fact]
  public async Task CreateFileAsync_WhenCalledAndRequestFails_ItShouldReturnError()
  {
    _mockHttpMessageHandler
      .WhenCreateFileRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""file: file size exceeds limit""
            }
          }"
      );

    var fileContent = new MemoryStream(Encoding.UTF8.GetBytes("Example file content"));
    var request = new CreateFileRequest(fileContent, "example.txt", "text/plain");

    var result = await Client.CreateFileAsync(request);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }

  [Fact]
  public async Task ListFilesAsync_WhenCalled_ItShouldReturnPageOfFiles()
  {
    _mockHttpMessageHandler
      .WhenListFilesRequest()
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""created_at"": ""2023-11-07T05:31:56Z"",
                ""downloadable"": false,
                ""filename"": ""example.txt"",
                ""id"": ""file_013Zva2CMHLNnXjNJJKqJ2EF"",
                ""mime_type"": ""text/plain"",
                ""size_bytes"": 1234,
                ""type"": ""file""
              }
            ],
            ""has_more"": true,
            ""first_id"": ""1"",
            ""last_id"": ""1""
          }"
      );

    var result = await Client.ListFilesAsync();

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<Page<AnthropicFile>>();
    result.Value.HasMore.Should().BeTrue();
    result.Value.FirstId.Should().Be("1");
    result.Value.LastId.Should().Be("1");
    result.Value.Data.Should().BeEquivalentTo(new AnthropicFile[]
    {
      new()
      {
        CreatedAt = DateTimeOffset.Parse("2023-11-07T05:31:56Z"),
        Downloadable = false,
        Name = "example.txt",
        Id = "file_013Zva2CMHLNnXjNJJKqJ2EF",
        MimeType = "text/plain",
        Size = 1234,
        Type = "file"
      }
    });
  }

  [Fact]
  public async Task ListFilesAsync_WhenCalledAndRequestFails_ItShouldReturnError()
  {
    _mockHttpMessageHandler
      .WhenListFilesRequest()
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""files: file not found""
            }
          }"
      );

    var result = await Client.ListFilesAsync();

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }

  [Fact]
  public async Task ListFilesAsync_WhenCalledWithPagingRequest_ItShouldReturnPageOfFiles()
  {
    var pagingRequest = new PagingRequest(afterId: "next_id", limit: 10);

    _mockHttpMessageHandler
      .WhenListFilesRequest()
      .WithQueryString(new Dictionary<string, string>
      {
        { "after_id", pagingRequest.AfterId },
        { "limit", pagingRequest.Limit.ToString() },
      })
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""created_at"": ""2023-11-07T05:31:56Z"",
                ""downloadable"": false,
                ""filename"": ""example.txt"",
                ""id"": ""file_013Zva2CMHLNnXjNJJKqJ2EF"",
                ""mime_type"": ""text/plain"",
                ""size_bytes"": 1234,
                ""type"": ""file""
              }
            ],
            ""has_more"": true,
            ""first_id"": ""1"",
            ""last_id"": ""1""
          }"
      );

    var result = await Client.ListFilesAsync(pagingRequest);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<Page<AnthropicFile>>();
    result.Value.HasMore.Should().BeTrue();
    result.Value.FirstId.Should().Be("1");
    result.Value.LastId.Should().Be("1");
    result.Value.Data.Should().BeEquivalentTo(new AnthropicFile[]
    {
      new()
      {
        CreatedAt = DateTimeOffset.Parse("2023-11-07T05:31:56Z"),
        Downloadable = false,
        Name = "example.txt",
        Id = "file_013Zva2CMHLNnXjNJJKqJ2EF",
        MimeType = "text/plain",
        Size = 1234,
        Type = "file"
      }
    });
  }

  [Fact]
  public async Task ListAllFilesAsync_WhenCalled_ItShouldReturnAllFiles()
  {
    _mockHttpMessageHandler
      .WhenListFilesRequest()
      .WithExactQueryString(new Dictionary<string, string>()
      {
        { "limit", "20" },
      })
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""created_at"": ""2023-11-07T05:31:56Z"",
                ""downloadable"": false,
                ""filename"": ""example.txt"",
                ""id"": ""file_013Zva2CMHLNnXjNJJKqJ2EF"",
                ""mime_type"": ""text/plain"",
                ""size_bytes"": 1234,
                ""type"": ""file""
              }
            ],
            ""has_more"": true,
            ""first_id"": ""1"",
            ""last_id"": ""1""
          }"
      );

    _mockHttpMessageHandler
      .WhenListFilesRequest()
      .WithExactQueryString(new Dictionary<string, string>()
      {
        { "after_id", "1" },
        { "limit", "20" },
      })
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
            ""data"": [
              {
                ""created_at"": ""2023-11-07T05:31:56Z"",
                ""downloadable"": false,
                ""filename"": ""example.txt"",
                ""id"": ""file_013Zva2CMHLNnXjNJJKqJ2EF"",
                ""mime_type"": ""text/plain"",
                ""size_bytes"": 1234,
                ""type"": ""file""
              }
            ],
            ""has_more"": false,
            ""first_id"": ""2"",
            ""last_id"": ""2""
          }"
      );

    var pageResponses = Client.ListAllFilesAsync();
    var collectedPages = new List<Page<AnthropicFile>>();

    await foreach (var response in pageResponses)
    {
      response.IsSuccess.Should().BeTrue();
      response.Value.Should().BeOfType<Page<AnthropicFile>>();
      collectedPages.Add(response.Value);
    }

    var expectedFile = new AnthropicFile()
    {
      CreatedAt = DateTimeOffset.Parse("2023-11-07T05:31:56Z"),
      Downloadable = false,
      Name = "example.txt",
      Id = "file_013Zva2CMHLNnXjNJJKqJ2EF",
      MimeType = "text/plain",
      Size = 1234,
      Type = "file"
    };

    collectedPages.Should().HaveCount(2);
    collectedPages.Should().BeEquivalentTo(new List<Page<AnthropicFile>>()
    {
      new()
      {
        Data = [expectedFile],
        FirstId = "1",
        LastId = "1",
        HasMore = true
      },
      new()
      {
        Data = [expectedFile],
        FirstId = "2",
        LastId = "2",
        HasMore = false
      }
    });
  }

  [Fact]
  public async Task GetFileInfoAsync_WhenCalled_ItShouldReturnFile()
  {
    var fileId = "file_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenGetFileRequest(fileId)
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
          ""created_at"": ""2023-11-07T05:31:56Z"",
          ""downloadable"": false,
          ""filename"": ""example.txt"",
          ""id"": ""file_013Zva2CMHLNnXjNJJKqJ2EF"",
          ""mime_type"": ""text/plain"",
          ""size_bytes"": 1234,
          ""type"": ""file""
        }"
      );

    var result = await Client.GetFileInfoAsync(fileId);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeEquivalentTo(new AnthropicFile()
    {
      CreatedAt = DateTimeOffset.Parse("2023-11-07T05:31:56Z"),
      Downloadable = false,
      Name = "example.txt",
      Id = "file_013Zva2CMHLNnXjNJJKqJ2EF",
      MimeType = "text/plain",
      Size = 1234,
      Type = "file"
    });
  }

  [Fact]
  public async Task GetFileInfoAsync_WhenCalledAndRequestFails_ItShouldReturnError()
  {
    var fileId = "file_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenGetFileRequest(fileId)
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""file: file not found""
            }
          }"
      );

    var result = await Client.GetFileInfoAsync(fileId);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }

  [Fact]
  public async Task GetFileAsync_WhenCalled_ItShouldReturnFileContent()
  {
    var fileId = "file_013Zva2CMHLNnXjNJJKqJ2EF";
    var fileContent = new MemoryStream(Encoding.UTF8.GetBytes("Example file content"));

    _mockHttpMessageHandler
      .WhenGetFileContentRequest(fileId)
      .Respond(
        HttpStatusCode.OK,
        "application/octet-stream",
        fileContent
      );

    var result = await Client.GetFileAsync(fileId);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeAssignableTo<Stream>();

    using var streamReader = new StreamReader(result.Value);
    var content = await streamReader.ReadToEndAsync();
    content.Should().Be("Example file content");
  }

  [Fact]
  public async Task GetFileAsync_WhenCalledAndRequestFails_ItShouldReturnError()
  {
    var fileId = "file_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenGetFileContentRequest(fileId)
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""file: file not found""
            }
          }"
      );

    var result = await Client.GetFileAsync(fileId);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }

  [Fact]
  public async Task GetFileAsync_WhenCalledAndCanNotDeserializeResponse_ItShouldReturnError()
  {
    var fileId = "file_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenGetFileContentRequest(fileId)
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"null"
      );

    var result = await Client.GetFileAsync(fileId);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<ApiError>();
  }

  [Fact]
  public async Task DeleteFileAsync_WhenCalled_ItShouldReturnDeletionResponse()
  {
    var fileId = "file_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenDeleteFileRequest(fileId)
      .Respond(
        HttpStatusCode.OK,
        "application/json",
        @"{
          ""id"": ""file_013Zva2CMHLNnXjNJJKqJ2EF"",
          ""type"": ""file_deleted""
        }"
      );

    var result = await Client.DeleteFileAsync(fileId);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().BeOfType<AnthropicFileDeleteResponse>();
    result.Value.Id.Should().Be(fileId);
    result.Value.Type.Should().Be("file_deleted");
  }

  [Fact]
  public async Task DeleteFileAsync_WhenCalledAndRequestFails_ItShouldReturnError()
  {
    var fileId = "file_013Zva2CMHLNnXjNJJKqJ2EF";

    _mockHttpMessageHandler
      .WhenDeleteFileRequest(fileId)
      .Respond(
        HttpStatusCode.BadRequest,
        "application/json",
        @"{
            ""type"": ""error"",
            ""error"": {
              ""type"": ""invalid_request_error"",
              ""message"": ""file: file not found""
            }
          }"
      );

    var result = await Client.DeleteFileAsync(fileId);

    result.IsSuccess.Should().BeFalse();
    result.Error.Should().BeOfType<AnthropicError>();
    result.Error.Error.Should().BeOfType<InvalidRequestError>();
  }
}