@anthropic-ai/sdk 0.4.4 → 0.5.1

package/src/error.ts

@@ -0,0 +1,115 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import { castToError, Headers } from './core';
+
+export class APIError extends Error {
+  readonly status: number | undefined;
+  readonly headers: Headers | undefined;
+  readonly error: Object | undefined;
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    super(message || (error as any)?.message || 'Unknown error occurred.');
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+  }
+
+  static generate(
+    status: number | undefined,
+    errorResponse: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    if (!status) {
+      return new APIConnectionError({ 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 APIConnectionError extends APIError {
+  override readonly status: undefined = undefined;
+
+  constructor({ message, cause }: { message?: string; 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() {
+    super({ message: 'Request timed out.' });
+  }
+}
+
+export class BadRequestError extends APIError {
+  override readonly status: 400 = 400;
+}
+
+export class AuthenticationError extends APIError {
+  override readonly status: 401 = 401;
+}
+
+export class PermissionDeniedError extends APIError {
+  override readonly status: 403 = 403;
+}
+
+export class NotFoundError extends APIError {
+  override readonly status: 404 = 404;
+}
+
+export class ConflictError extends APIError {
+  override readonly status: 409 = 409;
+}
+
+export class UnprocessableEntityError extends APIError {
+  override readonly status: 422 = 422;
+}
+
+export class RateLimitError extends APIError {
+  override readonly status: 429 = 429;
+}
+
+export class InternalServerError extends APIError {}

package/src/index.ts

@@ -0,0 +1,200 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import * as qs from 'qs';
+import * as Core from './core';
+import * as API from './resources/index';
+import * as Errors from './error';
+import type { Agent } from '@anthropic-ai/sdk/_shims/agent';
+import * as Uploads from './uploads';
+
+type Config = {
+  /**
+   * Defaults to process.env["ANTHROPIC_API_KEY"]. Set it to null if you want to send unauthenticated requests.
+   */
+  apiKey?: string | null;
+
+  /**
+   * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
+   */
+  baseURL?: string;
+
+  /**
+   * The maximum amount of time (in milliseconds) that the client should wait for a response
+   * from the server before timing out a single request.
+   *
+   * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
+   * much longer than this timeout before the promise succeeds or fails.
+   */
+  timeout?: number;
+
+  /**
+   * An HTTP agent used to manage HTTP(S) connections.
+   *
+   * If not provided, an agent will be constructed by default in the Node.js environment,
+   * otherwise no agent is used.
+   */
+  httpAgent?: Agent;
+
+  /**
+   * The maximum number of times that the client will retry a request in case of a
+   * temporary failure, like a network error or a 5XX error from the server.
+   *
+   * @default 2
+   */
+  maxRetries?: number;
+
+  /**
+   * Default headers to include with every request to the API.
+   *
+   * These can be removed in individual requests by explicitly setting the
+   * header to `undefined` or `null` in request options.
+   */
+  defaultHeaders?: Core.Headers;
+
+  /**
+   * Default query parameters to include with every request to the API.
+   *
+   * These can be removed in individual requests by explicitly setting the
+   * param to `undefined` in request options.
+   */
+  defaultQuery?: Core.DefaultQuery;
+
+  authToken?: string | null;
+};
+
+/** Instantiate the API Client. */
+export class Anthropic extends Core.APIClient {
+  apiKey: string | null;
+  authToken?: string | null;
+
+  private _options: Config;
+
+  constructor(config?: Config) {
+    const options: Config = {
+      apiKey: typeof process === 'undefined' ? '' : process.env['ANTHROPIC_API_KEY'] || '',
+      baseURL: 'https://api.anthropic.com',
+      ...config,
+    };
+
+    super({
+      baseURL: options.baseURL!,
+      timeout: options.timeout,
+      httpAgent: options.httpAgent,
+      maxRetries: options.maxRetries,
+    });
+    this.apiKey = options.apiKey || null;
+    this._options = options;
+
+    this.authToken = config?.authToken || process.env['ANTHROPIC_AUTH_TOKEN'] || null;
+  }
+
+  completions: API.Completions = new API.Completions(this);
+
+  protected override defaultQuery(): Core.DefaultQuery | undefined {
+    return this._options.defaultQuery;
+  }
+
+  protected override defaultHeaders(): Core.Headers {
+    return {
+      ...super.defaultHeaders(),
+      'anthropic-version': '2023-06-01',
+      ...this._options.defaultHeaders,
+    };
+  }
+
+  protected override validateHeaders(headers: Core.Headers, customHeaders: Core.Headers) {
+    if (this.apiKey && headers['X-Api-Key']) {
+      return;
+    }
+    if (customHeaders['X-Api-Key'] === null) {
+      return;
+    }
+
+    if (this.authToken && headers['Authorization']) {
+      return;
+    }
+    if (customHeaders['Authorization'] === null) {
+      return;
+    }
+
+    throw new Error(
+      'Could not resolve authentication method. Expected either apiKey or authToken to be set. Or for one of the "X-Api-Key" or "Authorization" headers to be explicitly omitted',
+    );
+  }
+
+  protected override authHeaders(): Core.Headers {
+    const apiKeyHeader = this.apiKeyHeader();
+    if (apiKeyHeader != null && !Core.isEmptyObj(apiKeyHeader)) {
+      return apiKeyHeader;
+    }
+    const authTokenBearer = this.authTokenBearer();
+    if (authTokenBearer != null && !Core.isEmptyObj(authTokenBearer)) {
+      return authTokenBearer;
+    }
+    return {};
+  }
+
+  protected apiKeyHeader(): Core.Headers {
+    if (this.apiKey == null) {
+      return {};
+    }
+    return { 'X-Api-Key': this.apiKey };
+  }
+
+  protected authTokenBearer(): Core.Headers {
+    if (this.authToken == null) {
+      return {};
+    }
+    return { Authorization: `Bearer ${this.authToken}` };
+  }
+
+  protected override qsOptions(): qs.IStringifyOptions {
+    return { arrayFormat: 'comma' };
+  }
+
+  static HUMAN_PROMPT = '\n\nHuman:';
+  static AI_PROMPT = '\n\nAssistant:';
+
+  static APIError = Errors.APIError;
+  static APIConnectionError = Errors.APIConnectionError;
+  static APIConnectionTimeoutError = Errors.APIConnectionTimeoutError;
+  static NotFoundError = Errors.NotFoundError;
+  static ConflictError = Errors.ConflictError;
+  static RateLimitError = Errors.RateLimitError;
+  static BadRequestError = Errors.BadRequestError;
+  static AuthenticationError = Errors.AuthenticationError;
+  static InternalServerError = Errors.InternalServerError;
+  static PermissionDeniedError = Errors.PermissionDeniedError;
+  static UnprocessableEntityError = Errors.UnprocessableEntityError;
+}
+
+export const { HUMAN_PROMPT, AI_PROMPT } = Anthropic;
+
+export const {
+  APIError,
+  APIConnectionError,
+  APIConnectionTimeoutError,
+  NotFoundError,
+  ConflictError,
+  RateLimitError,
+  BadRequestError,
+  AuthenticationError,
+  InternalServerError,
+  PermissionDeniedError,
+  UnprocessableEntityError,
+} = Errors;
+
+export import toFile = Uploads.toFile;
+export import fileFromPath = Uploads.fileFromPath;
+
+export namespace Anthropic {
+  // Helper functions
+  export import toFile = Uploads.toFile;
+  export import fileFromPath = Uploads.fileFromPath;
+
+  export import Completions = API.Completions;
+  export import Completion = API.Completion;
+  export import CompletionCreateParams = API.CompletionCreateParams;
+}
+
+export default Anthropic;

package/src/resource.ts

@@ -0,0 +1,24 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import type { Anthropic } from './index';
+
+export class APIResource {
+  protected client: Anthropic;
+  constructor(client: Anthropic) {
+    this.client = client;
+
+    this.get = client.get.bind(client);
+    this.post = client.post.bind(client);
+    this.patch = client.patch.bind(client);
+    this.put = client.put.bind(client);
+    this.delete = client.delete.bind(client);
+    this.getAPIList = client.getAPIList.bind(client);
+  }
+
+  protected get: Anthropic['get'];
+  protected post: Anthropic['post'];
+  protected patch: Anthropic['patch'];
+  protected put: Anthropic['put'];
+  protected delete: Anthropic['delete'];
+  protected getAPIList: Anthropic['getAPIList'];
+}

package/src/resources/completions.ts

@@ -0,0 +1,344 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import * as Core from '@anthropic-ai/sdk/core';
+import { APIResource } from '@anthropic-ai/sdk/resource';
+import * as API from './';
+import { Stream } from '@anthropic-ai/sdk/streaming';
+
+export class Completions extends APIResource {
+  /**
+   * Create a completion
+   */
+  create(
+    body: CompletionCreateParams.CompletionRequestNonStreaming,
+    options?: Core.RequestOptions,
+  ): Promise<Core.APIResponse<Completion>>;
+  create(
+    body: CompletionCreateParams.CompletionRequestStreaming,
+    options?: Core.RequestOptions,
+  ): Promise<Core.APIResponse<Stream<Completion>>>;
+  create(
+    body: CompletionCreateParams,
+    options?: Core.RequestOptions,
+  ): Promise<Core.APIResponse<Completion | Stream<Completion>>> {
+    return this.post('/v1/complete', { body, timeout: 600000, ...options, stream: body.stream ?? false });
+  }
+}
+
+export interface Completion {
+  /**
+   * The resulting completion up to and excluding the stop sequences.
+   */
+  completion: string;
+
+  /**
+   * The model that performed the completion.
+   */
+  model: string;
+
+  /**
+   * The reason that we stopped sampling.
+   *
+   * This may be one the following values:
+   *
+   * - `"stop_sequence"`: we reached a stop sequence — either provided by you via the
+   *   `stop_sequences` parameter, or a stop sequence built into the model
+   * - `"max_tokens"`: we exceeded `max_tokens_to_sample` or the model's maximum
+   */
+  stop_reason: string;
+}
+
+export type CompletionCreateParams =
+  | CompletionCreateParams.CompletionRequestNonStreaming
+  | CompletionCreateParams.CompletionRequestStreaming;
+
+export namespace CompletionCreateParams {
+  export interface CompletionRequestNonStreaming {
+    /**
+     * The maximum number of tokens to generate before stopping.
+     *
+     * Note that our models may stop _before_ reaching this maximum. This parameter
+     * only specifies the absolute maximum number of tokens to generate.
+     */
+    max_tokens_to_sample: number;
+
+    /**
+     * The model that will complete your prompt.
+     *
+     * As we improve Claude, we develop new versions of it that you can query. This
+     * controls which version of Claude answers your request. Right now we are offering
+     * two model families: Claude and Claude Instant.
+     *
+     * Specifiying any of the following models will automatically switch to you the
+     * newest compatible models as they are released:
+     *
+     * - `"claude-1"`: Our largest model, ideal for a wide range of more complex tasks.
+     * - `"claude-1-100k"`: An enhanced version of `claude-1` with a 100,000 token
+     *   (roughly 75,000 word) context window. Ideal for summarizing, analyzing, and
+     *   querying long documents and conversations for nuanced understanding of complex
+     *   topics and relationships across very long spans of text.
+     * - `"claude-instant-1"`: A smaller model with far lower latency, sampling at
+     *   roughly 40 words/sec! Its output quality is somewhat lower than the latest
+     *   `claude-1` model, particularly for complex tasks. However, it is much less
+     *   expensive and blazing fast. We believe that this model provides more than
+     *   adequate performance on a range of tasks including text classification,
+     *   summarization, and lightweight chat applications, as well as search result
+     *   summarization.
+     * - `"claude-instant-1-100k"`: An enhanced version of `claude-instant-1` with a
+     *   100,000 token context window that retains its performance. Well-suited for
+     *   high throughput use cases needing both speed and additional context, allowing
+     *   deeper understanding from extended conversations and documents.
+     *
+     * You can also select specific sub-versions of the above models:
+     *
+     * - `"claude-1.3"`: Compared to `claude-1.2`, it's more robust against red-team
+     *   inputs, better at precise instruction-following, better at code, and better
+     *   and non-English dialogue and writing.
+     * - `"claude-1.3-100k"`: An enhanced version of `claude-1.3` with a 100,000 token
+     *   (roughly 75,000 word) context window.
+     * - `"claude-1.2"`: An improved version of `claude-1`. It is slightly improved at
+     *   general helpfulness, instruction following, coding, and other tasks. It is
+     *   also considerably better with non-English languages. This model also has the
+     *   ability to role play (in harmless ways) more consistently, and it defaults to
+     *   writing somewhat longer and more thorough responses.
+     * - `"claude-1.0"`: An earlier version of `claude-1`.
+     * - `"claude-instant-1.1"`: Our latest version of `claude-instant-1`. It is better
+     *   than `claude-instant-1.0` at a wide variety of tasks including writing,
+     *   coding, and instruction following. It performs better on academic benchmarks,
+     *   including math, reading comprehension, and coding tests. It is also more
+     *   robust against red-teaming inputs.
+     * - `"claude-instant-1.1-100k"`: An enhanced version of `claude-instant-1.1` with
+     *   a 100,000 token context window that retains its lightning fast 40 word/sec
+     *   performance.
+     * - `"claude-instant-1.0"`: An earlier version of `claude-instant-1`.
+     */
+    model: string;
+
+    /**
+     * The prompt that you want Claude to complete.
+     *
+     * For proper response generation you will need to format your prompt as follows:
+     *
+     * ```javascript
+     * const userQuestion = r"Why is the sky blue?";
+     * const prompt = `\n\nHuman: ${userQuestion}\n\nAssistant:`;
+     * ```
+     *
+     * See our [comments on prompts](https://console.anthropic.com/docs/prompt-design)
+     * for more context.
+     */
+    prompt: string;
+
+    /**
+     * An object describing metadata about the request.
+     */
+    metadata?: CompletionCreateParams.CompletionRequestNonStreaming.Metadata;
+
+    /**
+     * Sequences that will cause the model to stop generating completion text.
+     *
+     * Our models stop on `"\n\nHuman:"`, and may include additional built-in stop
+     * sequences in the future. By providing the stop_sequences parameter, you may
+     * include additional strings that will cause the model to stop generating.
+     */
+    stop_sequences?: Array<string>;
+
+    /**
+     * Whether to incrementally stream the response using server-sent events.
+     *
+     * See
+     * [this guide to SSE events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
+     * for details.
+     */
+    stream?: false;
+
+    /**
+     * Amount of randomness injected into the response.
+     *
+     * Defaults to 1. Ranges from 0 to 1. Use temp closer to 0 for analytical /
+     * multiple choice, and closer to 1 for creative and generative tasks.
+     */
+    temperature?: number;
+
+    /**
+     * Only sample from the top K options for each subsequent token.
+     *
+     * Used to remove "long tail" low probability responses.
+     * [Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
+     */
+    top_k?: number;
+
+    /**
+     * Use nucleus sampling.
+     *
+     * In nucleus sampling, we compute the cumulative distribution over all the options
+     * for each subsequent token in decreasing probability order and cut it off once it
+     * reaches a particular probability specified by `top_p`. You should either alter
+     * `temperature` or `top_p`, but not both.
+     */
+    top_p?: number;
+  }
+
+  export namespace CompletionRequestNonStreaming {
+    /**
+     * An object describing metadata about the request.
+     */
+    export interface Metadata {
+      /**
+       * An external identifier for the user who is associated with the request.
+       *
+       * This should be a uuid, hash value, or other opaque identifier. Anthropic may use
+       * this id to help detect abuse. Do not include any identifying information such as
+       * name, email address, or phone number.
+       */
+      user_id?: string;
+    }
+  }
+
+  export interface CompletionRequestStreaming {
+    /**
+     * The maximum number of tokens to generate before stopping.
+     *
+     * Note that our models may stop _before_ reaching this maximum. This parameter
+     * only specifies the absolute maximum number of tokens to generate.
+     */
+    max_tokens_to_sample: number;
+
+    /**
+     * The model that will complete your prompt.
+     *
+     * As we improve Claude, we develop new versions of it that you can query. This
+     * controls which version of Claude answers your request. Right now we are offering
+     * two model families: Claude and Claude Instant.
+     *
+     * Specifiying any of the following models will automatically switch to you the
+     * newest compatible models as they are released:
+     *
+     * - `"claude-1"`: Our largest model, ideal for a wide range of more complex tasks.
+     * - `"claude-1-100k"`: An enhanced version of `claude-1` with a 100,000 token
+     *   (roughly 75,000 word) context window. Ideal for summarizing, analyzing, and
+     *   querying long documents and conversations for nuanced understanding of complex
+     *   topics and relationships across very long spans of text.
+     * - `"claude-instant-1"`: A smaller model with far lower latency, sampling at
+     *   roughly 40 words/sec! Its output quality is somewhat lower than the latest
+     *   `claude-1` model, particularly for complex tasks. However, it is much less
+     *   expensive and blazing fast. We believe that this model provides more than
+     *   adequate performance on a range of tasks including text classification,
+     *   summarization, and lightweight chat applications, as well as search result
+     *   summarization.
+     * - `"claude-instant-1-100k"`: An enhanced version of `claude-instant-1` with a
+     *   100,000 token context window that retains its performance. Well-suited for
+     *   high throughput use cases needing both speed and additional context, allowing
+     *   deeper understanding from extended conversations and documents.
+     *
+     * You can also select specific sub-versions of the above models:
+     *
+     * - `"claude-1.3"`: Compared to `claude-1.2`, it's more robust against red-team
+     *   inputs, better at precise instruction-following, better at code, and better
+     *   and non-English dialogue and writing.
+     * - `"claude-1.3-100k"`: An enhanced version of `claude-1.3` with a 100,000 token
+     *   (roughly 75,000 word) context window.
+     * - `"claude-1.2"`: An improved version of `claude-1`. It is slightly improved at
+     *   general helpfulness, instruction following, coding, and other tasks. It is
+     *   also considerably better with non-English languages. This model also has the
+     *   ability to role play (in harmless ways) more consistently, and it defaults to
+     *   writing somewhat longer and more thorough responses.
+     * - `"claude-1.0"`: An earlier version of `claude-1`.
+     * - `"claude-instant-1.1"`: Our latest version of `claude-instant-1`. It is better
+     *   than `claude-instant-1.0` at a wide variety of tasks including writing,
+     *   coding, and instruction following. It performs better on academic benchmarks,
+     *   including math, reading comprehension, and coding tests. It is also more
+     *   robust against red-teaming inputs.
+     * - `"claude-instant-1.1-100k"`: An enhanced version of `claude-instant-1.1` with
+     *   a 100,000 token context window that retains its lightning fast 40 word/sec
+     *   performance.
+     * - `"claude-instant-1.0"`: An earlier version of `claude-instant-1`.
+     */
+    model: string;
+
+    /**
+     * The prompt that you want Claude to complete.
+     *
+     * For proper response generation you will need to format your prompt as follows:
+     *
+     * ```javascript
+     * const userQuestion = r"Why is the sky blue?";
+     * const prompt = `\n\nHuman: ${userQuestion}\n\nAssistant:`;
+     * ```
+     *
+     * See our [comments on prompts](https://console.anthropic.com/docs/prompt-design)
+     * for more context.
+     */
+    prompt: string;
+
+    /**
+     * Whether to incrementally stream the response using server-sent events.
+     *
+     * See
+     * [this guide to SSE events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
+     * for details.
+     */
+    stream: true;
+
+    /**
+     * An object describing metadata about the request.
+     */
+    metadata?: CompletionCreateParams.CompletionRequestStreaming.Metadata;
+
+    /**
+     * Sequences that will cause the model to stop generating completion text.
+     *
+     * Our models stop on `"\n\nHuman:"`, and may include additional built-in stop
+     * sequences in the future. By providing the stop_sequences parameter, you may
+     * include additional strings that will cause the model to stop generating.
+     */
+    stop_sequences?: Array<string>;
+
+    /**
+     * Amount of randomness injected into the response.
+     *
+     * Defaults to 1. Ranges from 0 to 1. Use temp closer to 0 for analytical /
+     * multiple choice, and closer to 1 for creative and generative tasks.
+     */
+    temperature?: number;
+
+    /**
+     * Only sample from the top K options for each subsequent token.
+     *
+     * Used to remove "long tail" low probability responses.
+     * [Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
+     */
+    top_k?: number;
+
+    /**
+     * Use nucleus sampling.
+     *
+     * In nucleus sampling, we compute the cumulative distribution over all the options
+     * for each subsequent token in decreasing probability order and cut it off once it
+     * reaches a particular probability specified by `top_p`. You should either alter
+     * `temperature` or `top_p`, but not both.
+     */
+    top_p?: number;
+  }
+
+  export namespace CompletionRequestStreaming {
+    /**
+     * An object describing metadata about the request.
+     */
+    export interface Metadata {
+      /**
+       * An external identifier for the user who is associated with the request.
+       *
+       * This should be a uuid, hash value, or other opaque identifier. Anthropic may use
+       * this id to help detect abuse. Do not include any identifying information such as
+       * name, email address, or phone number.
+       */
+      user_id?: string;
+    }
+  }
+}
+
+export namespace Completions {
+  export import Completion = API.Completion;
+  export import CompletionCreateParams = API.CompletionCreateParams;
+}

package/src/resources/index.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless.
+
+export { Completion, CompletionCreateParams, Completions } from './completions';

package/src/resources/top-level.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless.
+
+export {};