@anthropic-ai/sdk 0.6.1 → 0.6.7

package/src/_shims/web-types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+export type Agent = any;
+
+declare const _fetch: typeof fetch;
+export { _fetch as fetch };
+
+type _Request = Request;
+export { _Request as Request };
+
+type _RequestInfo = RequestInfo;
+export { type _RequestInfo as RequestInfo };
+
+type _RequestInit = RequestInit;
+export { type _RequestInit as RequestInit };
+
+type _Response = Response;
+export { _Response as Response };
+
+type _ResponseInit = ResponseInit;
+export { type _ResponseInit as ResponseInit };
+
+type _ResponseType = ResponseType;
+export { type _ResponseType as ResponseType };
+
+type _BodyInit = BodyInit;
+export { type _BodyInit as BodyInit };
+
+type _Headers = Headers;
+export { _Headers as Headers };
+
+type _HeadersInit = HeadersInit;
+export { type _HeadersInit as HeadersInit };
+
+type EndingType = 'native' | 'transparent';
+
+export interface BlobPropertyBag {
+  endings?: EndingType;
+  type?: string;
+}
+
+export interface FilePropertyBag extends BlobPropertyBag {
+  lastModified?: number;
+}
+
+export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
+
+type _FormData = FormData;
+declare const _FormData: typeof FormData;
+export { _FormData as FormData };
+
+type _File = File;
+declare const _File: typeof File;
+export { _File as File };
+
+type _Blob = Blob;
+declare const _Blob: typeof Blob;
+export { _Blob as Blob };
+
+export declare class Readable {
+  readable: boolean;
+  readonly readableEnded: boolean;
+  readonly readableFlowing: boolean | null;
+  readonly readableHighWaterMark: number;
+  readonly readableLength: number;
+  readonly readableObjectMode: boolean;
+  destroyed: boolean;
+  read(size?: number): any;
+  pause(): this;
+  resume(): this;
+  isPaused(): boolean;
+  destroy(error?: Error): this;
+  [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+}
+
+export declare class FsReadStream extends Readable {
+  path: {}; // node type is string | Buffer
+}
+
+type _ReadableStream<R = any> = ReadableStream<R>;
+declare const _ReadableStream: typeof ReadableStream;
+export { _ReadableStream as ReadableStream };

package/src/_shims/web-types.js

@@ -0,0 +1,3 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */

package/src/_shims/web-types.mjs

@@ -0,0 +1,3 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */

package/src/core.ts

@@ -1,15 +1,23 @@
 import { VERSION } from './version';
 import { Stream } from './streaming';
-import { APIError, APIConnectionError, APIConnectionTimeoutError, APIUserAbortError } from './error';
-import type { Readable } from './_shims/node-readable';
-import { getDefaultAgent, type Agent } from './_shims/agent';
 import {
+  AnthropicError,
+  APIError,
+  APIConnectionError,
+  APIConnectionTimeoutError,
+  APIUserAbortError,
+} from './error';
+import {
+  kind as shimsKind,
+  type Readable,
+  getDefaultAgent,
+  type Agent,
   fetch,
-  isPolyfilled as fetchIsPolyfilled,
   type RequestInfo,
   type RequestInit,
   type Response,
-} from './_shims/fetch.js';
+  type HeadersInit,
+} from './_shims/index';
 export { type Response };
 import { isMultipartBody } from './uploads';
 export {
@@ -34,9 +42,11 @@ type APIResponseProps = {
 async function defaultParseResponse<T>(props: APIResponseProps): Promise<T> {
   const { response } = props;
   if (props.options.stream) {
+    debug('response', response.status, response.url, response.headers, response.body);
+
     // Note: there is an invariant here that isn't represented in the type system
     // that if you set `stream: true` the response type must also be `Stream<T>`
-    return new Stream(response, props.controller) as any;
+    return Stream.fromSSEResponse(response, props.controller) as any;
   }
 
   const contentType = response.headers.get('content-type');
@@ -51,7 +61,7 @@ async function defaultParseResponse<T>(props: APIResponseProps): Promise<T> {
   // TODO handle blob, arraybuffer, other content types, etc.
   const text = await response.text();
   debug('response', response.status, response.url, response.headers, text);
-  return text as T;
+  return text as any as T;
 }
 
 /**
@@ -83,6 +93,12 @@ export class APIPromise<T> extends Promise<T> {
    *
    * If you want to parse the response body but still get the `Response`
    * instance, you can use {@link withResponse()}.
+   *
+   * 👋 Getting the wrong TypeScript type for `Response`?
+   * Try setting `"moduleResolution": "NodeNext"` if you can,
+   * or add one of these imports before your first `import … from '@anthropic-ai/sdk'`:
+   * - `import '@anthropic-ai/sdk/shims/node'` (if you're running on Node)
+   * - `import '@anthropic-ai/sdk/shims/web'` (otherwise)
    */
   asResponse(): Promise<Response> {
     return this.responsePromise.then((p) => p.response);
@@ -92,6 +108,13 @@ export class APIPromise<T> extends Promise<T> {
    *
    * If you just want to get the raw `Response` instance without parsing it,
    * you can use {@link asResponse()}.
+   *
+   *
+   * 👋 Getting the wrong TypeScript type for `Response`?
+   * Try setting `"moduleResolution": "NodeNext"` if you can,
+   * or add one of these imports before your first `import … from '@anthropic-ai/sdk'`:
+   * - `import '@anthropic-ai/sdk/shims/node'` (if you're running on Node)
+   * - `import '@anthropic-ai/sdk/shims/web'` (otherwise)
    */
   async withResponse(): Promise<{ data: T; response: Response }> {
     const [data, response] = await Promise.all([this.parse(), this.asResponse()]);
@@ -153,7 +176,7 @@ export abstract class APIClient {
     this.fetch = overridenFetch ?? fetch;
   }
 
-  protected authHeaders(): Headers {
+  protected authHeaders(opts: FinalRequestOptions): Headers {
     return {};
   }
 
@@ -165,13 +188,13 @@ export abstract class APIClient {
    *    Authorization: 'Bearer 123',
    *  }
    */
-  protected defaultHeaders(): Headers {
+  protected defaultHeaders(opts: FinalRequestOptions): Headers {
     return {
       Accept: 'application/json',
       'Content-Type': 'application/json',
       'User-Agent': this.getUserAgent(),
       ...getPlatformHeaders(),
-      ...this.authHeaders(),
+      ...this.authHeaders(opts),
     };
   }
 
@@ -272,11 +295,11 @@ export abstract class APIClient {
 
     const reqHeaders: Record<string, string> = {
       ...(contentLength && { 'Content-Length': contentLength }),
-      ...this.defaultHeaders(),
+      ...this.defaultHeaders(options),
       ...headers,
     };
     // let builtin fetch set the Content-Type for multipart bodies
-    if (isMultipartBody(options.body) && !fetchIsPolyfilled) {
+    if (isMultipartBody(options.body) && shimsKind !== 'node') {
       delete reqHeaders['Content-Type'];
     }
 
@@ -304,7 +327,19 @@ export abstract class APIClient {
    * This is useful for cases where you want to add certain headers based off of
    * the request properties, e.g. `method` or `url`.
    */
-  protected async prepareRequest(request: RequestInit, { url }: { url: string }): Promise<void> {}
+  protected async prepareRequest(
+    request: RequestInit,
+    { url, options }: { url: string; options: FinalRequestOptions },
+  ): Promise<void> {}
+
+  protected parseHeaders(headers: HeadersInit | null | undefined): Record<string, string> {
+    return (
+      !headers ? {}
+      : Symbol.iterator in headers ?
+        Object.fromEntries(Array.from(headers as Iterable<string[]>).map((header) => [...header]))
+      : { ...headers }
+    );
+  }
 
   protected makeStatusError(
     status: number | undefined,
@@ -333,7 +368,7 @@ export abstract class APIClient {
 
     const { req, url, timeout } = this.buildRequest(options);
 
-    await this.prepareRequest(req, { url });
+    await this.prepareRequest(req, { url, options });
 
     debug('request', url, options, req.headers);
 
@@ -364,7 +399,7 @@ export abstract class APIClient {
         return this.retryRequest(options, retriesRemaining, responseHeaders);
       }
 
-      const errText = await response.text().catch(() => 'Unknown');
+      const errText = await response.text().catch((e) => castToError(e).message);
       const errJSON = safeJSON(errText);
       const errMessage = errJSON ? undefined : errText;
 
@@ -385,7 +420,7 @@ export abstract class APIClient {
     return new PagePromise<PageClass, Item>(this, request, Page);
   }
 
-  buildURL<Req>(path: string, query: Req | undefined): string {
+  buildURL<Req extends Record<string, unknown>>(path: string, query: Req | null | undefined): string {
     const url =
       isAbsoluteURL(path) ?
         new URL(path)
@@ -413,7 +448,7 @@ export abstract class APIClient {
         if (value === null) {
           return `${encodeURIComponent(key)}=`;
         }
-        throw new Error(
+        throw new AnthropicError(
           `Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`,
         );
       })
@@ -431,11 +466,14 @@ export abstract class APIClient {
 
     const timeout = setTimeout(() => controller.abort(), ms);
 
-    return this.getRequestClient()
-      .fetch(url, { signal: controller.signal as any, ...options })
-      .finally(() => {
-        clearTimeout(timeout);
-      });
+    return (
+      this.getRequestClient()
+        // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
+        .fetch.call(undefined, url, { signal: controller.signal as any, ...options })
+        .finally(() => {
+          clearTimeout(timeout);
+        })
+    );
   }
 
   protected getRequestClient(): RequestClient {
@@ -450,6 +488,9 @@ export abstract class APIClient {
     if (shouldRetryHeader === 'true') return true;
     if (shouldRetryHeader === 'false') return false;
 
+    // Retry on request timeouts.
+    if (response.status === 408) return true;
+
     // Retry on lock timeouts.
     if (response.status === 409) return true;
 
@@ -470,32 +511,37 @@ export abstract class APIClient {
     retriesRemaining -= 1;
 
     // About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
-    //
-    // TODO: we may want to handle the case where the header is using the http-date syntax: "Retry-After: <http-date>".
-    // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After#syntax for details.
-    const retryAfter = parseInt(responseHeaders?.['retry-after'] || '');
+    let timeoutMillis: number | undefined;
+    const retryAfterHeader = responseHeaders?.['retry-after'];
+    if (retryAfterHeader) {
+      const timeoutSeconds = parseInt(retryAfterHeader);
+      if (!Number.isNaN(timeoutSeconds)) {
+        timeoutMillis = timeoutSeconds * 1000;
+      } else {
+        timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
+      }
+    }
 
-    const maxRetries = options.maxRetries ?? this.maxRetries;
-    const timeout = this.calculateRetryTimeoutSeconds(retriesRemaining, retryAfter, maxRetries) * 1000;
-    await sleep(timeout);
+    // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
+    // just do what it says, but otherwise calculate a default
+    if (
+      !timeoutMillis ||
+      !Number.isInteger(timeoutMillis) ||
+      timeoutMillis <= 0 ||
+      timeoutMillis > 60 * 1000
+    ) {
+      const maxRetries = options.maxRetries ?? this.maxRetries;
+      timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
+    }
+    await sleep(timeoutMillis);
 
     return this.makeRequest(options, retriesRemaining);
   }
 
-  private calculateRetryTimeoutSeconds(
-    retriesRemaining: number,
-    retryAfter: number,
-    maxRetries: number,
-  ): number {
+  private calculateDefaultRetryTimeoutMillis(retriesRemaining: number, maxRetries: number): number {
     const initialRetryDelay = 0.5;
     const maxRetryDelay = 2;
 
-    // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
-    // just do what it says.
-    if (Number.isInteger(retryAfter) && retryAfter <= 60) {
-      return retryAfter;
-    }
-
     const numRetries = maxRetries - retriesRemaining;
 
     // Apply exponential backoff, but not more than the max.
@@ -504,7 +550,7 @@ export abstract class APIClient {
     // Apply some jitter, plus-or-minus half a second.
     const jitter = Math.random() - 0.5;
 
-    return sleepSeconds + jitter;
+    return (sleepSeconds + jitter) * 1000;
   }
 
   private getUserAgent(): string {
@@ -563,10 +609,10 @@ export abstract class AbstractPage<Item> implements AsyncIterable<Item> {
     return this.nextPageInfo() != null;
   }
 
-  async getNextPage(): Promise<AbstractPage<Item>> {
+  async getNextPage(): Promise<this> {
     const nextInfo = this.nextPageInfo();
     if (!nextInfo) {
-      throw new Error(
+      throw new AnthropicError(
         'No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.',
       );
     }
@@ -576,7 +622,7 @@ export abstract class AbstractPage<Item> implements AsyncIterable<Item> {
     } else if ('url' in nextInfo) {
       const params = [...Object.entries(nextOptions.query || {}), ...nextInfo.url.searchParams.entries()];
       for (const [key, value] of params) {
-        nextInfo.url.searchParams.set(key, value);
+        nextInfo.url.searchParams.set(key, value as any);
       }
       nextOptions.query = undefined;
       nextOptions.path = nextInfo.url.toString();
@@ -702,7 +748,7 @@ const requestOptionsKeys: KeysEnum<RequestOptions> = {
   idempotencyKey: true,
 };
 
-export const isRequestOptions = (obj: unknown): obj is RequestOptions => {
+export const isRequestOptions = (obj: unknown): obj is RequestOptions<Record<string, unknown> | Readable> => {
   return (
     typeof obj === 'object' &&
     obj !== null &&
@@ -888,14 +934,14 @@ const isAbsoluteURL = (url: string): boolean => {
   return startsWithSchemeRegexp.test(url);
 };
 
-const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
 const validatePositiveInteger = (name: string, n: unknown): number => {
   if (typeof n !== 'number' || !Number.isInteger(n)) {
-    throw new Error(`${name} must be an integer`);
+    throw new AnthropicError(`${name} must be an integer`);
   }
   if (n < 0) {
-    throw new Error(`${name} must be a positive integer`);
+    throw new AnthropicError(`${name} must be a positive integer`);
   }
   return n;
 };
@@ -906,7 +952,7 @@ export const castToError = (err: any): Error => {
 };
 
 export const ensurePresent = <T>(value: T | null | undefined): T => {
-  if (value == null) throw new Error(`Expected a value to be given but received ${value} instead.`);
+  if (value == null) throw new AnthropicError(`Expected a value to be given but received ${value} instead.`);
   return value;
 };
 
@@ -929,14 +975,14 @@ export const coerceInteger = (value: unknown): number => {
   if (typeof value === 'number') return Math.round(value);
   if (typeof value === 'string') return parseInt(value, 10);
 
-  throw new Error(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+  throw new AnthropicError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
 };
 
 export const coerceFloat = (value: unknown): number => {
   if (typeof value === 'number') return value;
   if (typeof value === 'string') return parseFloat(value);
 
-  throw new Error(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+  throw new AnthropicError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
 };
 
 export const coerceBoolean = (value: unknown): boolean => {
@@ -1015,16 +1061,33 @@ export const isHeadersProtocol = (headers: any): headers is HeadersProtocol => {
   return typeof headers?.get === 'function';
 };
 
-export const getHeader = (headers: HeadersLike, key: string): string | null | undefined => {
-  const lowerKey = key.toLowerCase();
-  if (isHeadersProtocol(headers)) return headers.get(key) || headers.get(lowerKey);
-  const value = headers[key] || headers[lowerKey];
-  if (Array.isArray(value)) {
-    if (value.length <= 1) return value[0];
-    console.warn(`Received ${value.length} entries for the ${key} header, using the first entry.`);
-    return value[0];
+export const getRequiredHeader = (headers: HeadersLike, header: string): string => {
+  const lowerCasedHeader = header.toLowerCase();
+  if (isHeadersProtocol(headers)) {
+    // to deal with the case where the header looks like Stainless-Event-Id
+    const intercapsHeader =
+      header[0]?.toUpperCase() +
+      header.substring(1).replace(/([^\w])(\w)/g, (_m, g1, g2) => g1 + g2.toUpperCase());
+    for (const key of [header, lowerCasedHeader, header.toUpperCase(), intercapsHeader]) {
+      const value = headers.get(key);
+      if (value) {
+        return value;
+      }
+    }
   }
-  return value;
+
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lowerCasedHeader) {
+      if (Array.isArray(value)) {
+        if (value.length <= 1) return value[0];
+        console.warn(`Received ${value.length} entries for the ${header} header, using the first entry.`);
+        return value[0];
+      }
+      return value;
+    }
+  }
+
+  throw new Error(`Could not find ${header} header`);
 };
 
 /**
@@ -1040,5 +1103,5 @@ export const toBase64 = (str: string | null | undefined): string => {
     return btoa(str);
   }
 
-  throw new Error('Cannot generate b64 string; Expected `Buffer` or `btoa` to be defined');
+  throw new AnthropicError('Cannot generate b64 string; Expected `Buffer` or `btoa` to be defined');
 };

package/src/error.ts

@@ -2,7 +2,9 @@
 
 import { castToError, Headers } from './core';
 
-export class APIError extends Error {
+export class AnthropicError extends Error {}
+
+export class APIError extends AnthropicError {
   readonly status: number | undefined;
   readonly headers: Headers | undefined;
   readonly error: Object | undefined;
@@ -13,20 +15,30 @@ export class APIError extends Error {
     message: string | undefined,
     headers: Headers | undefined,
   ) {
-    super(APIError.makeMessage(error, message));
+    super(`${APIError.makeMessage(status, error, message)}`);
     this.status = status;
     this.headers = headers;
     this.error = error;
   }
 
-  private static makeMessage(error: any, message: string | undefined) {
-    return (
+  private static makeMessage(status: number | undefined, error: any, message: string | undefined) {
+    const msg =
       error?.message ?
         typeof error.message === 'string' ? error.message
         : JSON.stringify(error.message)
       : error ? JSON.stringify(error)
-      : message || 'Unknown error occurred'
-    );
+      : message;
+
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return '(no status code or body)';
   }
 
   static generate(
@@ -97,8 +109,8 @@ export class APIConnectionError extends APIError {
 }
 
 export class APIConnectionTimeoutError extends APIConnectionError {
-  constructor() {
-    super({ message: 'Request timed out.' });
+  constructor({ message }: { message?: string } = {}) {
+    super({ message: message ?? 'Request timed out.' });
   }
 }
 

package/src/index.ts

@@ -1,17 +1,22 @@
 // File generated from our OpenAPI spec by Stainless.
 
 import * as Core from './core';
-import * as API from './resources/index';
 import * as Errors from './error';
-import type { Agent } from './_shims/agent';
+import { type Agent } from './_shims/index';
 import * as Uploads from './uploads';
+import * as API from "./pic-ai/sdk/resources/index";
 
 export interface ClientOptions {
   /**
-   * Defaults to process.env["ANTHROPIC_API_KEY"]. Set it to null if you want to send unauthenticated requests.
+   * Defaults to process.env['ANTHROPIC_API_KEY'].
    */
   apiKey?: string | null;
 
+  /**
+   * Defaults to process.env['ANTHROPIC_AUTH_TOKEN'].
+   */
+  authToken?: string | null;
+
   /**
    * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
    */
@@ -65,21 +70,20 @@ export interface ClientOptions {
    * param to `undefined` in request options.
    */
   defaultQuery?: Core.DefaultQuery;
-
-  authToken?: string | null;
 }
 
 /** API Client for interfacing with the Anthropic API. */
 export class Anthropic extends Core.APIClient {
   apiKey: string | null;
-  authToken?: string | null;
+  authToken: string | null;
 
   private _options: ClientOptions;
 
   /**
    * API Client for interfacing with the Anthropic API.
    *
-   * @param {string | null} [opts.apiKey=process.env['ANTHROPIC_API_KEY']] - The API Key to send to the API.
+   * @param {string | null} [opts.apiKey==process.env['ANTHROPIC_API_KEY'] ?? null]
+   * @param {string | null} [opts.authToken==process.env['ANTHROPIC_AUTH_TOKEN'] ?? null]
    * @param {string} [opts.baseURL] - Override the default base URL for the API.
    * @param {number} [opts.timeout=10 minutes] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
    * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
@@ -87,20 +91,17 @@ export class Anthropic extends Core.APIClient {
    * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
    * @param {Core.Headers} opts.defaultHeaders - Default headers to include with every request to the API.
    * @param {Core.DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
-   * @param {string | null} [opts.authToken]
    */
   constructor({
     apiKey = Core.readEnv('ANTHROPIC_API_KEY') ?? null,
     authToken = Core.readEnv('ANTHROPIC_AUTH_TOKEN') ?? null,
     ...opts
   }: ClientOptions = {}) {
-    undefined;
-
     const options: ClientOptions = {
       apiKey,
       authToken,
-      baseURL: `https://api.anthropic.com`,
       ...opts,
+      baseURL: opts.baseURL ?? `https://api.anthropic.com`,
     };
 
     super({
@@ -122,9 +123,9 @@ export class Anthropic extends Core.APIClient {
     return this._options.defaultQuery;
   }
 
-  protected override defaultHeaders(): Core.Headers {
+  protected override defaultHeaders(opts: Core.FinalRequestOptions): Core.Headers {
     return {
-      ...super.defaultHeaders(),
+      ...super.defaultHeaders(opts),
       'anthropic-version': '2023-06-01',
       ...this._options.defaultHeaders,
     };
@@ -150,26 +151,28 @@ export class Anthropic extends Core.APIClient {
     );
   }
 
-  protected override authHeaders(): Core.Headers {
-    const apiKeyHeader = this.apiKeyHeader();
-    if (apiKeyHeader != null && !Core.isEmptyObj(apiKeyHeader)) {
-      return apiKeyHeader;
+  protected override authHeaders(opts: Core.FinalRequestOptions): Core.Headers {
+    const apiKeyAuth = this.apiKeyAuth(opts);
+    const bearerAuth = this.bearerAuth(opts);
+
+    if (apiKeyAuth != null && !Core.isEmptyObj(apiKeyAuth)) {
+      return apiKeyAuth;
     }
-    const authTokenBearer = this.authTokenBearer();
-    if (authTokenBearer != null && !Core.isEmptyObj(authTokenBearer)) {
-      return authTokenBearer;
+
+    if (bearerAuth != null && !Core.isEmptyObj(bearerAuth)) {
+      return bearerAuth;
     }
     return {};
   }
 
-  protected apiKeyHeader(): Core.Headers {
+  protected apiKeyAuth(opts: Core.FinalRequestOptions): Core.Headers {
     if (this.apiKey == null) {
       return {};
     }
     return { 'X-Api-Key': this.apiKey };
   }
 
-  protected authTokenBearer(): Core.Headers {
+  protected bearerAuth(opts: Core.FinalRequestOptions): Core.Headers {
     if (this.authToken == null) {
       return {};
     }
@@ -180,6 +183,7 @@ export class Anthropic extends Core.APIClient {
   static HUMAN_PROMPT = '\n\nHuman:';
   static AI_PROMPT = '\n\nAssistant:';
 
+  static AnthropicError = Errors.AnthropicError;
   static APIError = Errors.APIError;
   static APIConnectionError = Errors.APIConnectionError;
   static APIConnectionTimeoutError = Errors.APIConnectionTimeoutError;
@@ -197,6 +201,7 @@ export class Anthropic extends Core.APIClient {
 export const { HUMAN_PROMPT, AI_PROMPT } = Anthropic;
 
 export const {
+  AnthropicError,
   APIError,
   APIConnectionError,
   APIConnectionTimeoutError,