Simplify exception throwing

src/AssemblyAI.IntegrationTests/LemurTests.cs

@@ -1,3 +1,4 @@
+using System.Net;
 using AssemblyAI.Core;
 using AssemblyAI.Lemur;
 
@@ -82,17 +83,18 @@ public async Task Should_Generate_Task()
     }
 
     [Test]
-    [Ignore("Ignore until fixed")]
+    //[Ignore("Ignore until fixed")]
     public void Should_Fail_To_Generate_Summary()
     {
         var client = new AssemblyAIClient(ApiKey);
-        var ex = Assert.ThrowsAsync<BadRequestError>(async () => await client.Lemur.SummaryAsync(new LemurSummaryParams
+        var ex = Assert.ThrowsAsync<HttpOperationException>(async () => await client.Lemur.SummaryAsync(new LemurSummaryParams
         {
             FinalModel = LemurModel.Basic,
             TranscriptIds = ["bad-id"],
             AnswerFormat = "one sentence"
         }).ConfigureAwait(false));
 
+        Assert.That(ex.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
         Assert.That(ex.Message, Is.EqualTo("each transcript source id must be valid"));
     }
 

src/AssemblyAI/Core/AssemblyAIException.cs

@@ -0,0 +1,23 @@
+using System;
+
+#nullable enable
+
+namespace AssemblyAI.Core;
+
+/// <summary>
+/// Base exception class for all exceptions thrown by the SDK.
+/// </summary>
+public class AssemblyAIException : Exception
+{
+    public AssemblyAIException()
+    {
+    }
+
+    public AssemblyAIException(string message) : base(message)
+    {
+    }
+
+    public AssemblyAIException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+}

src/AssemblyAI/Core/AssemblyAIClientApiException.cs → src/AssemblyAI/Core/HttpOperationException.cs

@@ -1,3 +1,4 @@
+using System.Net;
 using AssemblyAI.Core;
 
 #nullable enable
@@ -7,16 +8,16 @@ namespace AssemblyAI.Core;
 /// <summary>
 /// This exception type will be thrown for any non-2XX API responses.
 /// </summary>
-public class AssemblyAIClientApiException(string message, int statusCode, object body)
-    : AssemblyAIClientException(message)
+public class HttpOperationException(string message, HttpStatusCode statusCode, string responseContent)
+    : AssemblyAIException(message)
 {
     /// <summary>
     /// The error code of the response that triggered the exception.
     /// </summary>
-    public int StatusCode { get; } = statusCode;
+    public HttpStatusCode StatusCode { get; } = statusCode;
 
     /// <summary>
     /// The body of the response that triggered the exception.
     /// </summary>
-    public object Body { get; } = body;
+    public string ResponseContent { get; } = responseContent;
 }

src/AssemblyAI/Core/RawClient.cs

@@ -1,5 +1,7 @@
+using System.Net;
 using System.Net.Http;
 using System.Text;
+using System.Text.Json;
 
 namespace AssemblyAI.Core;
 
@@ -32,21 +34,25 @@ public async Task<ApiResponse> MakeRequestAsync(BaseApiRequest request)
         {
             request.Headers.Add("Content-Type", request.ContentType);
         }
+
         // Add global headers to the request
         foreach (var header in _headers)
         {
             httpRequest.Headers.Add(header.Key, header.Value);
         }
+
         // Add global headers to the request from supplier
         foreach (var header in headerSuppliers)
         {
             httpRequest.Headers.Add(header.Key, header.Value.Invoke());
         }
+
         // Add request headers to the request
         foreach (var header in request.Headers)
         {
             httpRequest.Headers.Add(header.Key, header.Value);
         }
+
         // Add the request body to the request
         if (request is JsonApiRequest jsonRequest)
         {
@@ -63,10 +69,43 @@ public async Task<ApiResponse> MakeRequestAsync(BaseApiRequest request)
         {
             httpRequest.Content = new StreamContent(streamRequest.Body);
         }
+
         // Send the request
-        var httpClient = request.Options?.HttpClient ?? Options.HttpClient;
+        var httpClient = request.Options?.HttpClient ?? Options.HttpClient
+            ?? throw new Exception("No HttpClient provided in request or client options");
         var response = await httpClient.SendAsync(httpRequest);
-        return new ApiResponse { StatusCode = (int)response.StatusCode, Raw = response };
+        var apiResponse = new ApiResponse { StatusCode = response.StatusCode, Raw = response };
+        if (response.IsSuccessStatusCode) return apiResponse;
+
+        var responseContentString = await response.Content.ReadAsStringAsync();
+        if (string.IsNullOrEmpty(responseContentString))
+        {
+            throw new HttpOperationException(
+                $"Error with status code {response.StatusCode}", 
+                response.StatusCode, 
+                responseContentString
+            ); 
+        }
+
+        try
+        {
+            var error = JsonUtils.Deserialize<AssemblyAI.Error>(responseContentString);
+            throw new HttpOperationException(
+                error.Error_, 
+                response.StatusCode, 
+                responseContentString
+            );
+        }
+        catch (JsonException)
+        {
+        }
+
+        // use response content as error message if error object cannot be deserialized
+        throw new HttpOperationException(
+            responseContentString, 
+            response.StatusCode, 
+            responseContentString
+        );
     }
 
     public record BaseApiRequest
@@ -107,7 +146,7 @@ public record JsonApiRequest : BaseApiRequest
     /// </summary>
     public record ApiResponse
     {
-        public required int StatusCode { get; init; }
+        public required HttpStatusCode StatusCode { get; init; }
 
         public required HttpResponseMessage Raw { get; init; }
     }
@@ -140,10 +179,11 @@ private string BuildUrl(BaseApiRequest request)
                 {
                     current += $"{queryItem.Key}={queryItem.Value}&";
                 }
+
                 return current;
             }
         );
         url = url.Substring(0, url.Length - 1);
         return url;
     }
-}
+}

src/AssemblyAI/Files/FilesClient.cs

@@ -33,46 +33,6 @@ public async Task<UploadedFile> UploadAsync(Stream request, RequestOptions? opti
             }
         );
         var responseBody = await response.Raw.Content.ReadAsStringAsync();
-        if (response.StatusCode is >= 200 and < 400)
-        {
-            try
-            {
-                return JsonUtils.Deserialize<UploadedFile>(responseBody)!;
-            }
-            catch (JsonException e)
-            {
-                throw new AssemblyAIClientException("Failed to deserialize response", e);
-            }
-        }
-
-        try
-        {
-            switch (response.StatusCode)
-            {
-                case 400:
-                    throw new BadRequestError(JsonUtils.Deserialize<Error>(responseBody));
-                case 401:
-                    throw new UnauthorizedError(JsonUtils.Deserialize<Error>(responseBody));
-                case 404:
-                    throw new NotFoundError(JsonUtils.Deserialize<Error>(responseBody));
-                case 429:
-                    throw new TooManyRequestsError(JsonUtils.Deserialize<Error>(responseBody));
-                case 500:
-                    throw new InternalServerError(JsonUtils.Deserialize<Error>(responseBody));
-                case 503:
-                    throw new ServiceUnavailableError(JsonUtils.Deserialize<object>(responseBody));
-                case 504:
-                    throw new GatewayTimeoutError(JsonUtils.Deserialize<object>(responseBody));
-            }
-        }
-        catch (JsonException)
-        {
-            // unable to map error response, throwing generic error
-        }
-        throw new AssemblyAIClientApiException(
-            $"Error with status code {response.StatusCode}",
-            response.StatusCode,
-            JsonUtils.Deserialize<object>(responseBody)
-        );
+        return JsonUtils.Deserialize<UploadedFile>(responseBody)!;
     }
 }