FM / core

/opt/canhelp/node_modules/@anthropic-ai/sdk/src/core/

/opt/canhelp/node_modules/@anthropic-ai/sdk/src/core

Name	Size	Mode	Actions
api-promise.ts	3662	0644	edit dl rm
error.ts	4105	0644	edit dl rm
pagination.ts	7303	0644	edit dl rm
README.md	100	0644	edit dl rm
resource.ts	277	0644	edit dl rm
streaming.ts	9682	0644	edit dl rm
uploads.ts	119	0644	edit dl rm

Edit: /opt/canhelp/node_modules/@anthropic-ai/sdk/src/core/error.ts (4105B)

// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

import { castToError } from '../internal/errors';

export class AnthropicError extends Error {}

export class APIError<
  TStatus extends number | undefined = number | undefined,
  THeaders extends Headers | undefined = Headers | undefined,
  TError extends Object | undefined = Object | undefined,
> extends AnthropicError {
  /** HTTP status for the response that caused the error */
  readonly status: TStatus;
  /** HTTP headers for the response that caused the error */
  readonly headers: THeaders;
  /** JSON body of the response that caused the error */
  readonly error: TError;

readonly requestID: string | null | undefined;

constructor(status: TStatus, error: TError, message: string | undefined, headers: THeaders) {
    super(`${APIError.makeMessage(status, error, message)}`);
    this.status = status;
    this.headers = headers;
    this.requestID = headers?.get('request-id');
    this.error = error;
  }

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;

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(
    status: number | undefined,
    errorResponse: Object | undefined,
    message: string | undefined,
    headers: Headers | undefined,
  ): APIError {
    if (!status || !headers) {
      return new APIConnectionError({ message, cause: castToError(errorResponse) });
    }

const error = errorResponse as Record<string, any>;

if (status === 400) {
      return new BadRequestError(status, error, message, headers);
    }

if (status === 401) {
      return new AuthenticationError(status, error, message, headers);
    }

if (status === 403) {
      return new PermissionDeniedError(status, error, message, headers);
    }

if (status === 404) {
      return new NotFoundError(status, error, message, headers);
    }

if (status === 409) {
      return new ConflictError(status, error, message, headers);
    }

if (status === 422) {
      return new UnprocessableEntityError(status, error, message, headers);
    }

if (status === 429) {
      return new RateLimitError(status, error, message, headers);
    }

if (status >= 500) {
      return new InternalServerError(status, error, message, headers);
    }

return new APIError(status, error, message, headers);
  }
}

export class APIUserAbortError extends APIError<undefined, undefined, undefined> {
  constructor({ message }: { message?: string } = {}) {
    super(undefined, undefined, message || 'Request was aborted.', undefined);
  }
}

export class APIConnectionError extends APIError<undefined, undefined, undefined> {
  constructor({ message, cause }: { message?: string | undefined; cause?: Error | undefined }) {
    super(undefined, undefined, message || 'Connection error.', undefined);
    // in some environments the 'cause' property is already declared
    // @ts-ignore
    if (cause) this.cause = cause;
  }
}

export class APIConnectionTimeoutError extends APIConnectionError {
  constructor({ message }: { message?: string } = {}) {
    super({ message: message ?? 'Request timed out.' });
  }
}