@s2-dev/streamstore 0.3.9 → 0.3.14

package/src/funcs/streamAppend.ts

@@ -10,6 +10,7 @@ import { safeParse } from "../lib/schemas.js";
 import { RequestOptions } from "../lib/sdks.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
+import * as components from "../models/components/index.js";
 import { APIError } from "../models/errors/apierror.js";
 import {
   ConnectionError,
@@ -36,9 +37,10 @@ export async function streamAppend(
   options?: RequestOptions,
 ): Promise<
   Result<
-    operations.AppendResponse,
-    | errors.ErrorResponse
+    components.AppendOutput,
     | errors.ErrorResponse
+    | errors.RetryableError
+    | errors.RetryableError
     | APIError
     | SDKValidationError
     | UnexpectedClientError
@@ -115,7 +117,7 @@ export async function streamAppend(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "404", "4XX", "500", "5XX"],
+    errorCodes: ["400", "401", "404", "499", "4XX", "500", "503", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });
@@ -129,9 +131,10 @@ export async function streamAppend(
   };
 
   const [result] = await M.match<
-    operations.AppendResponse,
-    | errors.ErrorResponse
+    components.AppendOutput,
     | errors.ErrorResponse
+    | errors.RetryableError
+    | errors.RetryableError
     | APIError
     | SDKValidationError
     | UnexpectedClientError
@@ -140,14 +143,13 @@ export async function streamAppend(
     | RequestTimeoutError
     | ConnectionError
   >(
-    M.json(200, operations.AppendResponse$inboundSchema, {
-      key: "AppendOutput",
-    }),
+    M.json(200, components.AppendOutput$inboundSchema),
     M.jsonErr([400, 401, 404], errors.ErrorResponse$inboundSchema),
-    M.jsonErr(500, errors.ErrorResponse$inboundSchema),
+    M.jsonErr(499, errors.RetryableError$inboundSchema),
+    M.jsonErr([500, 503, 504], errors.RetryableError$inboundSchema),
     M.fail("4XX"),
     M.fail("5XX"),
-  )(response, req, { extraFields: responseFields });
+  )(response, { extraFields: responseFields });
   if (!result.ok) {
     return result;
   }

package/src/funcs/streamCheckTail.ts

@@ -10,6 +10,7 @@ import { safeParse } from "../lib/schemas.js";
 import { RequestOptions } from "../lib/sdks.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
+import * as components from "../models/components/index.js";
 import { APIError } from "../models/errors/apierror.js";
 import {
   ConnectionError,
@@ -36,9 +37,10 @@ export async function streamCheckTail(
   options?: RequestOptions,
 ): Promise<
   Result<
-    operations.CheckTailResponse,
-    | errors.ErrorResponse
+    components.CheckTailResponse,
     | errors.ErrorResponse
+    | errors.RetryableError
+    | errors.RetryableError
     | APIError
     | SDKValidationError
     | UnexpectedClientError
@@ -110,7 +112,7 @@ export async function streamCheckTail(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "404", "4XX", "500", "5XX"],
+    errorCodes: ["400", "401", "404", "499", "4XX", "500", "503", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });
@@ -124,9 +126,10 @@ export async function streamCheckTail(
   };
 
   const [result] = await M.match<
-    operations.CheckTailResponse,
-    | errors.ErrorResponse
+    components.CheckTailResponse,
     | errors.ErrorResponse
+    | errors.RetryableError
+    | errors.RetryableError
     | APIError
     | SDKValidationError
     | UnexpectedClientError
@@ -135,14 +138,13 @@ export async function streamCheckTail(
     | RequestTimeoutError
     | ConnectionError
   >(
-    M.json(200, operations.CheckTailResponse$inboundSchema, {
-      key: "CheckTailResponse",
-    }),
+    M.json(200, components.CheckTailResponse$inboundSchema),
     M.jsonErr([400, 401, 404], errors.ErrorResponse$inboundSchema),
-    M.jsonErr(500, errors.ErrorResponse$inboundSchema),
+    M.jsonErr(499, errors.RetryableError$inboundSchema),
+    M.jsonErr([500, 503, 504], errors.RetryableError$inboundSchema),
     M.fail("4XX"),
     M.fail("5XX"),
-  )(response, req, { extraFields: responseFields });
+  )(response, { extraFields: responseFields });
   if (!result.ok) {
     return result;
   }

package/src/funcs/streamRead.ts

@@ -43,7 +43,8 @@ export async function streamRead(
   Result<
     operations.ReadResponse,
     | errors.ErrorResponse
-    | errors.ErrorResponse
+    | errors.RetryableError
+    | errors.RetryableError
     | APIError
     | SDKValidationError
     | UnexpectedClientError
@@ -126,7 +127,7 @@ export async function streamRead(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["400", "401", "404", "4XX", "500", "5XX"],
+    errorCodes: ["400", "401", "404", "499", "4XX", "500", "503", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });
@@ -142,7 +143,8 @@ export async function streamRead(
   const [result] = await M.match<
     operations.ReadResponse,
     | errors.ErrorResponse
-    | errors.ErrorResponse
+    | errors.RetryableError
+    | errors.RetryableError
     | APIError
     | SDKValidationError
     | UnexpectedClientError
@@ -151,13 +153,14 @@ export async function streamRead(
     | RequestTimeoutError
     | ConnectionError
   >(
-    M.json(200, operations.ReadResponse$inboundSchema, { key: "Output" }),
-    M.sse(200, operations.ReadResponse$inboundSchema, { key: "ReadResponse" }),
+    M.json(200, operations.ReadResponse$inboundSchema),
+    M.sse(200, operations.ReadResponse$inboundSchema),
     M.jsonErr([400, 401, 404], errors.ErrorResponse$inboundSchema),
-    M.jsonErr(500, errors.ErrorResponse$inboundSchema),
+    M.jsonErr(499, errors.RetryableError$inboundSchema),
+    M.jsonErr([500, 503, 504], errors.RetryableError$inboundSchema),
     M.fail("4XX"),
     M.fail("5XX"),
-  )(response, req, { extraFields: responseFields });
+  )(response, { extraFields: responseFields });
   if (!result.ok) {
     return result;
   }

package/src/index.extras.ts

@@ -14,7 +14,7 @@ import {
     StreamConfig,
     StreamInfo,
 } from "./models/components";
-import { ErrorResponse, NotFoundError } from "./models/errors";
+import { NotFoundError, RetryableError } from "./models/errors";
 import {
     GetBasinConfigRequest,
     ListBasinsRequest,
@@ -37,6 +37,7 @@ import { v4 as uuidv4 } from "uuid";
 import { basinDeleteStream } from "./funcs/basinDeleteStream";
 import { EventStream } from "./lib/event-streams";
 import { ClientKind, S2Cloud, S2Endpoints } from "./endpoints";
+import { HTTPClient } from "./lib/http";
 
 export type ReadRequest = Omit<ReadRequestInner, "stream">;
 export type AppendRequest = Omit<AppendRequestInner, "stream">;
@@ -64,19 +65,39 @@ export * from "./endpoints";
 
 export type S2ClientConfig = {
     authToken?: string;
+    userAgent?: string;
     requestTimeout?: number;
     endpoints?: S2Endpoints;
+    appedRetryPolicy?: AppendRetryPolicy;
+    maxRetries?: number;
+    initialBackoffMs?: number;
+    maxBackoffMs?: number;
+    httpClient?: HTTPClient;
 };
 
+export enum AppendRetryPolicy {
+    All,
+    NoSideEffects,
+}
+
 const defaultS2ClientConfig: S2ClientConfig = {
     requestTimeout: 3000,
     endpoints: S2Endpoints.forCloud(S2Cloud.Aws),
+    appedRetryPolicy: AppendRetryPolicy.All,
+    httpClient: new HTTPClient({
+        fetcher: async (request) => fetch(request),
+    }),
 };
 
+
 export class S2Client {
     private config: S2ClientConfig;
-    private _account?: S2Account;
+    private _account?: S2Account;    
+
     get account(): S2Account {
+        // this.httpClient.addHook("beforeRequest", (request) => {
+        //     if (this.config.userAgent) request.headers.set("User-Agent", this.config.userAgent);
+        // });
         return (this._account ??= new S2Account(this.config));
     }
 
@@ -96,9 +117,16 @@ class S2Account {
     private readonly accountURLSuffx = "/v1alpha";
 
     constructor(config: S2ClientConfig) {
+        if (config.userAgent !== undefined) {
+            config.httpClient?.addHook("beforeRequest", (request) => {
+                request.headers.set("user-agent", config.userAgent ?? "s2-sdk-typescript");
+                console.log(request)
+            });
+        }
         this._account = new InnerAccount({
             ...(config.authToken !== undefined && { bearerAuth: config.authToken }),
-            ...(config.requestTimeout !== undefined && { timeoutMs: config.requestTimeout })
+            ...(config.requestTimeout !== undefined && { timeoutMs: config.requestTimeout }),
+            ...(config.httpClient !== undefined && { httpClient: config.httpClient }),
         });
         this.config = config;
     }
@@ -106,7 +134,7 @@ class S2Account {
     get URL(): string | undefined {
         if (!this.config.endpoints) return undefined;
         return `https://${ClientKind.toAuthority({ kind: "Account" }, this.config.endpoints)}${this.accountURLSuffx}`;
-    }
+    }    
 
     basin(basinName: string): S2Basin {
         return new S2Basin(basinName, this.config);
@@ -116,15 +144,23 @@ class S2Account {
         request?: ListBasinsRequest
     ): Promise<PageIterator<ListBasinsResponse, { cursor: string }>> {
         const url = this.URL;
-        return this._account.listBasins(request ?? {}, url ? { serverURL: url } : {});
+        return retryWithExponentialBackoff(
+            () => this._account.listBasins(request ?? {}, url ? { serverURL: url } : {}),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 
     async getBasinConfig(basin: string): Promise<BasinConfig | undefined> {
         const _request: GetBasinConfigRequest = { basin };
         const url = this.URL;
-        return (await this._account.getBasinConfig(_request
-            , url ? { serverURL: url } : {}
-        )).basinConfig;
+        return retryWithExponentialBackoff(
+            () => this._account.getBasinConfig(_request, url ? { serverURL: url } : {}),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 
     async createBasin(basin: string, request?: CreateBasinRequest): Promise<BasinInfo | undefined> {
@@ -134,14 +170,22 @@ class S2Account {
             createBasinRequest: request ?? {},
         };
         const url = this.URL;
-        return (await this._account.createBasin(_request,
-            url ? { serverURL: url } : {}
-        )).basinInfo;
+        return retryWithExponentialBackoff(
+            () => this._account.createBasin(_request, url ? { serverURL: url } : {}),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 
-    async deleteBasin(basin: string, if_exists?: boolean): Promise<void | undefined> {
+    async deleteBasin(basin: string, if_exists?: boolean): Promise<void> {
         const url = this.URL;
-        const response = await accountDeleteBasin(this._account, { basin }, url ? { serverURL: url } : {});
+        const response = await retryWithExponentialBackoff(
+            () => accountDeleteBasin(this._account, { basin }, url ? { serverURL: url } : {}),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
         if (if_exists && response.error instanceof NotFoundError) return;
         if (response.error) throw new Error(response.error.message);
         return;
@@ -150,9 +194,12 @@ class S2Account {
     async reconfigureBasin(basin: string, config: BasinConfig): Promise<BasinConfig | undefined> {
         const url = this.URL;
         const _request: ReconfigureBasinRequest = { basin, basinConfig: config };
-        return (await this._account.reconfigureBasin(_request
-            , url ? { serverURL: url } : {}
-        )).basinConfig;
+        return retryWithExponentialBackoff(
+            () => this._account.reconfigureBasin(_request, url ? { serverURL: url } : {}),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 }
 
@@ -162,13 +209,18 @@ class S2Basin {
     private basinName: string;
     private config: S2ClientConfig;
     private clientKind: ClientKind;
-    private readonly basinURLSuffx = "/v1alpha";
+    private readonly basinURLSuffx = "/v1alpha";    
 
     private get URL(): string {
         return `https://${ClientKind.toAuthority(this.clientKind, this.config.endpoints ?? S2Endpoints.forCloud(S2Cloud.Aws))}${this.basinURLSuffx}`;
     }
 
     constructor(basinName: string, config: S2ClientConfig) {
+        if (config.userAgent !== undefined) {
+            config.httpClient?.addHook("beforeRequest", (request) => {
+                request.headers.set("user-agent", config.userAgent ?? "s2-sdk-typescript");
+            });
+        }
         this._basin = new InnerBasin({
             ...(config.authToken !== undefined && { bearerAuth: config.authToken }),
             ...(config.requestTimeout !== undefined && { timeoutMs: config.requestTimeout })
@@ -185,13 +237,21 @@ class S2Basin {
     async listStreams(
         request: ListStreamsRequest
     ): Promise<PageIterator<ListStreamsResponse, { cursor: string }>> {
-        return this._basin.listStreams(request, { serverURL: this.URL });
+        return retryWithExponentialBackoff(
+            () => this._basin.listStreams(request, { serverURL: this.URL }),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 
     async getStreamConfig(stream: string): Promise<StreamConfig | undefined> {
-        return (
-            await this._basin.getStreamConfig({ stream }, { serverURL: this.URL })
-        ).streamConfig;
+        return retryWithExponentialBackoff(
+            () => this._basin.getStreamConfig({ stream }, { serverURL: this.URL }),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 
     async createStream(stream: string, request?: CreateStreamRequest): Promise<StreamInfo | undefined> {
@@ -200,27 +260,33 @@ class S2Basin {
             s2RequestToken: genS2RequestToken(),
             createStreamRequest: request ?? {},
         };
-        return (
-            await this._basin.createStream(_request, { serverURL: this.URL })
-        ).streamInfo;
+        return retryWithExponentialBackoff(
+            () => this._basin.createStream(_request, { serverURL: this.URL }),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 
     async deleteStream(stream: string, if_exists?: boolean): Promise<void | undefined> {
-        const response = await basinDeleteStream(this._basin, { stream }, {
-            serverURL: this.URL,
-        });
+        const response = await retryWithExponentialBackoff(
+            () => basinDeleteStream(this._basin, { stream }, { serverURL: this.URL }),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
         if (if_exists && response instanceof NotFoundError) return;
         if (response.error) throw new Error(response.error.message);
         return;
     }
 
-    async reconfigureStream(stream: string, config: StreamConfig): Promise<StreamConfig | undefined> {
-        return (
-            await this._basin.reconfigureStream(
-                { stream, streamConfig: config },
-                { serverURL: this.URL }
-            )
-        ).streamConfig;
+    async reconfigureStream(stream: string, config: StreamConfig): Promise<StreamConfig> {
+        return retryWithExponentialBackoff(
+            () => this._basin.reconfigureStream({ stream, streamConfig: config }, { serverURL: this.URL }),
+            this.config.maxRetries,
+            this.config.initialBackoffMs,
+            this.config.maxBackoffMs
+        );
     }
 }
 
@@ -239,35 +305,55 @@ class Stream {
         this.config = config;
         this.clientKind = { kind: "Basin" as const, basin: basinName };
         this.streamName = streamName;
+        if (config.userAgent !== undefined) {
+            config.httpClient?.addHook("beforeRequest", (request) => {
+                request.headers.set("user-agent", config.userAgent ?? "s2-sdk-typescript");
+            });
+        }
         this._stream = new InnerStream({
             ...(config.authToken !== undefined && { bearerAuth: config.authToken }),
             ...(config.requestTimeout !== undefined && { timeoutMs: config.requestTimeout })
         });
     }
 
-    async checkTail(): Promise<CheckTailResponse | undefined> {
+    async checkTail(): Promise<CheckTailResponse> {
         return (
             await this._stream.checkTail({ stream: this.streamName }, { serverURL: this.basinURL })
-        ).checkTailResponse;
+        );
     }
 
-    async append(request: AppendRequest): Promise<AppendOutput | undefined> {
-        return (
-            await this._stream.append({ ...request, stream: this.streamName }, { serverURL: this.basinURL })
-        ).appendOutput;
+    async append(request: AppendRequest): Promise<AppendOutput> {
+        switch (this.config.appedRetryPolicy) {
+            case AppendRetryPolicy.All:
+            case undefined:
+                return retryWithExponentialBackoff(
+                    () => this._stream.append({ ...request, stream: this.streamName }, { serverURL: this.basinURL }),
+                    this.config.maxRetries,
+                    this.config.initialBackoffMs,
+                    this.config.maxBackoffMs
+                );
+            case AppendRetryPolicy.NoSideEffects:
+                return (
+                    await this._stream.append({ ...request, stream: this.streamName }, {
+                        serverURL: this.basinURL,
+                    })
+                );
+            default:
+                throw new Error("Invalid AppendRetryPolicy");
+        }
     }
 
-    async read(request: ReadRequest): Promise<Output | undefined> {
+    async read(request: ReadRequest): Promise<Output> {
         return (
-            await this._stream.read({ ...request, stream: this.streamName }, { serverURL: this.basinURL })
-        ).output;
+            await this._stream.read({ ...request, stream: this.streamName }, { serverURL: this.basinURL }) as Output
+        );
     }
 
     async *readStream(request: ReadRequest): AsyncGenerator<ReadResponse, void, undefined> {
         let currentRequest: ReadRequest = { ...request };
-        let backoffMs = 100;
+        let initialBackoffMs = this.config.initialBackoffMs ?? 100;
         const maxBackoffMs = 5000;
-        const maxRetries = 5;
+        const maxRetries = this.config.maxRetries ?? 5;
         let retryCount = 0;
 
         while (true) {
@@ -281,7 +367,7 @@ class Stream {
                         acceptHeaderOverride: ReadAcceptEnum.textEventStream
                     }
                 );
-                stream = response.readResponse;
+                stream = response as EventStream<ReadResponse>;
                 if (!stream) return;
 
                 for await (const event of stream) {
@@ -310,13 +396,16 @@ class Stream {
                 }
                 return;
             } catch (error) {
-                if (error instanceof ErrorResponse || error instanceof NotFoundError) return;
-                if (retryCount >= maxRetries) {
+                if (error instanceof RetryableError) {
+                    if (retryCount >= maxRetries) {
+                        throw error;
+                    }
+                    retryCount++;
+                    await new Promise(resolve => setTimeout(resolve, initialBackoffMs));
+                    initialBackoffMs = Math.min(initialBackoffMs * 2, maxBackoffMs);
+                } else {
                     throw error;
                 }
-                retryCount++;
-                await new Promise(resolve => setTimeout(resolve, backoffMs));
-                backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
             }
         }
     }
@@ -336,4 +425,33 @@ function meteredBatchSize(batch: SequencedRecordBatch): number {
 
 export function genS2RequestToken(): string {
     return uuidv4().replace(/-/g, "");
-}
+}
+
+async function retryWithExponentialBackoff<T>(
+    operation: () => Promise<T>,
+    maxAttempts: number = 5,
+    initialBackoffMs: number = 100,
+    maxBackoffMs: number = 5000
+): Promise<T> {
+    let attempt = 0;
+
+    while (attempt < maxAttempts) {
+        try {
+            return await operation();
+        } catch (error) {
+            if (error instanceof RetryableError) {
+                attempt++;
+                if (attempt >= maxAttempts) throw error;
+
+                const jitter = Math.random() * 0.3 + 0.85;
+                const delayMs = Math.min(initialBackoffMs * Math.pow(2, attempt) * jitter, maxBackoffMs);
+
+                await new Promise(resolve => setTimeout(resolve, delayMs));
+            } else {
+                throw error;
+            }
+        }
+    }
+
+    throw new Error("Max retry attempts reached");
+}

package/src/lib/config.ts

@@ -54,7 +54,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "0.3.9",
+  sdkVersion: "0.3.14",
   genVersion: "2.506.0",
-  userAgent: "speakeasy-sdk/typescript 0.3.9 2.506.0 1.0.0 @s2-dev/streamstore",
+  userAgent:
+    "speakeasy-sdk/typescript 0.3.14 2.506.0 1.0.0 @s2-dev/streamstore",
 } as const;

package/src/lib/matchers.ts

@@ -160,7 +160,6 @@ export type MatchedError<Matchers> = Matchers extends Matcher<any, infer E>[]
   : never;
 export type MatchFunc<T, E> = (
   response: Response,
-  request: Request,
   options?: { resultKey?: string; extraFields?: Record<string, unknown> },
 ) => Promise<[result: Result<T, E>, raw: unknown]>;
 
@@ -169,7 +168,6 @@ export function match<T, E>(
 ): MatchFunc<T, E | APIError | SDKValidationError> {
   return async function matchFunc(
     response: Response,
-    request: Request,
     options?: { resultKey?: string; extraFields?: Record<string, unknown> },
   ): Promise<
     [result: Result<T, E | APIError | SDKValidationError>, raw: unknown]
@@ -191,14 +189,15 @@ export function match<T, E>(
     }
 
     if (!matcher) {
-      await discardResponseBody(response);
+      const responseBody = await response.text();
       return [{
         ok: false,
-        error: new APIError("Unexpected API response status or content-type", {
+        error: new APIError(
+          "Unexpected API response status or content-type",
           response,
-          request,
-        }),
-      }, raw];
+          responseBody,
+        ),
+      }, responseBody];
     }
 
     const encoding = matcher.enc;
@@ -224,7 +223,7 @@ export function match<T, E>(
         raw = await discardResponseBody(response);
         break;
       case "fail":
-        raw = await discardResponseBody(response);
+        raw = await response.text();
         break;
       default:
         encoding satisfies never;
@@ -234,7 +233,11 @@ export function match<T, E>(
     if (matcher.enc === "fail") {
       return [{
         ok: false,
-        error: new APIError("API error occurred", { response, request }),
+        error: new APIError(
+          "API error occurred",
+          response,
+          typeof raw === "string" ? raw : "",
+        ),
       }, raw];
     }
 
@@ -253,11 +256,14 @@ export function match<T, E>(
         ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
         [resultKey]: raw,
       };
-    } else {
+    } else if (matcher.hdrs) {
       data = {
         ...options?.extraFields,
         ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
+        ...(isPlainObject(raw) ? raw : null),
       };
+    } else {
+      data = raw;
     }
 
     if ("err" in matcher) {

package/src/models/components/index.ts

@@ -14,7 +14,6 @@ export * from "./createbasinrequest.js";
 export * from "./createstreamrequest.js";
 export * from "./formatoption.js";
 export * from "./header.js";
-export * from "./httpmetadata.js";
 export * from "./listbasinsresponse.js";
 export * from "./liststreamsresponse.js";
 export * from "./output.js";

package/src/models/errors/apierror.ts

@@ -3,19 +3,25 @@
  */
 
 export class APIError extends Error {
+  public readonly statusCode: number;
+  public readonly contentType: string;
+
   constructor(
     message: string,
-    public readonly httpMeta: {
-      response: Response;
-      request: Request;
-    },
+    public readonly rawResponse: Response,
+    public readonly body: string = "",
   ) {
+    const statusCode = rawResponse.status;
+    const contentType = rawResponse.headers.get("content-type") || "";
+    const bodyString = body.length > 0 ? `\n${body}` : "";
+
     super(
-      `${message}: Status ${httpMeta.response.status} Content-Type ${
-        httpMeta.response.headers.get("content-type") || ""
-      }`,
+      `${message}: Status ${statusCode} Content-Type ${contentType} Body ${bodyString}`,
     );
 
+    this.statusCode = statusCode;
+    this.contentType = contentType;
+
     this.name = "APIError";
   }
 }