@anthropic-ai/sdk 0.33.1 → 0.34.0-alpha.0

package/src/internal/utils/base64.ts

@@ -0,0 +1,40 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { AnthropicError } from '../../error';
+
+// @ts-ignore
+declare const Buffer: typeof import('node:buffer').Buffer;
+
+export const toBase64 = (data: string | Uint8Array | null | undefined): string => {
+  if (!data) return '';
+
+  if (typeof data === 'string') {
+    data = new TextEncoder().encode(data);
+  }
+
+  if (typeof Buffer !== 'undefined') {
+    return Buffer.from(data).toString('base64');
+  }
+
+  if (typeof btoa !== 'undefined') {
+    return btoa(String.fromCharCode.apply(null, data as any));
+  }
+
+  throw new AnthropicError('Cannot generate base64 string; Expected `Buffer` or `btoa` to be defined');
+};
+
+export const fromBase64 = (str: string): Uint8Array => {
+  if (typeof Buffer !== 'undefined') {
+    return new Uint8Array(Buffer.from(str, 'base64'));
+  }
+
+  if (typeof atob !== 'undefined') {
+    return new Uint8Array(
+      atob(str)
+        .split('')
+        .map((c) => c.charCodeAt(0)),
+    );
+  }
+
+  throw new AnthropicError('Cannot decode base64 string; Expected `Buffer` or `atob` to be defined');
+};

package/src/internal/utils/env.ts

@@ -0,0 +1,20 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+declare const Deno: any;
+
+/**
+ * Read an environment variable.
+ *
+ * Trims beginning and trailing whitespace.
+ *
+ * Will return undefined if the environment variable doesn't exist or cannot be accessed.
+ */
+export const readEnv = (env: string): string | undefined => {
+  if (typeof process !== 'undefined') {
+    return process.env?.[env]?.trim() ?? undefined;
+  }
+  if (typeof Deno !== 'undefined') {
+    return Deno.env?.get?.(env)?.trim();
+  }
+  return undefined;
+};

package/src/internal/utils/log.ts

@@ -0,0 +1,9 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { readEnv } from './env';
+
+export function debug(action: string, ...args: any[]) {
+  if (readEnv('DEBUG') === 'true') {
+    console.log(`Anthropic:DEBUG:${action}`, ...args);
+  }
+}

package/src/internal/utils/sleep.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

package/src/internal/utils/uuid.ts

@@ -0,0 +1,13 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { crypto } from '../polyfill/crypto.node';
+
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+export function uuid4() {
+  if (crypto.randomUUID) return crypto.randomUUID();
+  return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) =>
+    (+c ^ (crypto.getRandomValues(new Uint8Array(1))[0]! & (15 >> (+c / 4)))).toString(16),
+  );
+}

package/src/internal/utils/values.ts

@@ -0,0 +1,94 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { AnthropicError } from '../../error';
+
+// https://url.spec.whatwg.org/#url-scheme-string
+const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+
+export const isAbsoluteURL = (url: string): boolean => {
+  return startsWithSchemeRegexp.test(url);
+};
+
+/** Returns an object if the given value isn't an object, otherwise returns as-is */
+export function maybeObj(x: unknown): object {
+  if (typeof x !== 'object') {
+    return {};
+  }
+
+  return x ?? {};
+}
+
+// https://stackoverflow.com/a/34491287
+export function isEmptyObj(obj: Object | null | undefined): boolean {
+  if (!obj) return true;
+  for (const _k in obj) return false;
+  return true;
+}
+
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+export function hasOwn(obj: Object, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+export function isObj(obj: unknown): obj is Record<string, unknown> {
+  return obj != null && typeof obj === 'object' && !Array.isArray(obj);
+}
+
+export const ensurePresent = <T>(value: T | null | undefined): T => {
+  if (value == null) {
+    throw new AnthropicError(`Expected a value to be given but received ${value} instead.`);
+  }
+
+  return value;
+};
+
+export const validatePositiveInteger = (name: string, n: unknown): number => {
+  if (typeof n !== 'number' || !Number.isInteger(n)) {
+    throw new AnthropicError(`${name} must be an integer`);
+  }
+  if (n < 0) {
+    throw new AnthropicError(`${name} must be a positive integer`);
+  }
+  return n;
+};
+
+export const coerceInteger = (value: unknown): number => {
+  if (typeof value === 'number') return Math.round(value);
+  if (typeof value === 'string') return parseInt(value, 10);
+
+  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 AnthropicError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+
+export const coerceBoolean = (value: unknown): boolean => {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') return value === 'true';
+  return Boolean(value);
+};
+
+export const maybeCoerceInteger = (value: unknown): number | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return coerceInteger(value);
+};
+
+export const maybeCoerceFloat = (value: unknown): number | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return coerceFloat(value);
+};
+
+export const maybeCoerceBoolean = (value: unknown): boolean | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return coerceBoolean(value);
+};

package/src/internal/utils.ts

@@ -0,0 +1,8 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './utils/values';
+export * from './utils/base64';
+export * from './utils/env';
+export * from './utils/log';
+export * from './utils/uuid';
+export * from './utils/sleep';

package/src/lib/MessageStream.ts

@@ -1,5 +1,4 @@
-import * as Core from "../core.js";
-import { AnthropicError, APIUserAbortError } from "../error.js";
+import { AnthropicError, APIUserAbortError } from '../error';
 import {
   type ContentBlock,
   Messages,
@@ -9,10 +8,11 @@ import {
   type MessageCreateParams,
   type MessageCreateParamsBase,
   type TextBlock,
-} from "../resources/messages.js";
-import { type ReadableStream } from "../_shims/index.js";
-import { Stream } from "../streaming.js";
-import { partialParse } from "../_vendor/partial-json-parser/parser.js";
+} from '../resources/messages';
+import { Stream } from '../streaming';
+import { partialParse } from '../_vendor/partial-json-parser/parser';
+import { RequestOptions } from '../internal/request-options';
+import { type ReadableStream } from '../internal/shim-types';
 
 export interface MessageStreamEvents {
   connect: () => void;
@@ -91,7 +91,7 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
   static createMessage(
     messages: Messages,
     params: MessageCreateParamsBase,
-    options?: Core.RequestOptions,
+    options?: RequestOptions,
   ): MessageStream {
     const runner = new MessageStream();
     for (const message of params.messages) {
@@ -128,7 +128,7 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
   protected async _createMessage(
     messages: Messages,
     params: MessageCreateParams,
-    options?: Core.RequestOptions,
+    options?: RequestOptions,
   ): Promise<void> {
     const signal = options?.signal;
     if (signal) {
@@ -416,7 +416,7 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
 
   protected async _fromReadableStream(
     readableStream: ReadableStream,
-    options?: Core.RequestOptions,
+    options?: RequestOptions,
   ): Promise<void> {
     const signal = options?.signal;
     if (signal) {

package/src/pagination.ts

@@ -1,6 +1,116 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { AbstractPage, Response, APIClient, FinalRequestOptions, PageInfo } from "./core.js";
+import type { Anthropic } from './client';
+import { AnthropicError } from './error';
+import { FinalRequestOptions } from './internal/request-options';
+import { defaultParseResponse, type WithRequestID } from './internal/parse';
+import { APIPromise } from './api-promise';
+import { type APIResponseProps } from './internal/parse';
+import { maybeObj } from './internal/utils/values';
+
+export type PageRequestOptions = Pick<FinalRequestOptions, 'query' | 'headers' | 'body' | 'path' | 'method'>;
+
+export abstract class AbstractPage<Item> implements AsyncIterable<Item> {
+  #client: Anthropic;
+  protected options: FinalRequestOptions;
+
+  protected response: Response;
+  protected body: unknown;
+
+  constructor(client: Anthropic, response: Response, body: unknown, options: FinalRequestOptions) {
+    this.#client = client;
+    this.options = options;
+    this.response = response;
+    this.body = body;
+  }
+
+  abstract nextPageRequestOptions(): PageRequestOptions | null;
+
+  abstract getPaginatedItems(): Item[];
+
+  hasNextPage(): boolean {
+    const items = this.getPaginatedItems();
+    if (!items.length) return false;
+    return this.nextPageRequestOptions() != null;
+  }
+
+  async getNextPage(): Promise<this> {
+    const nextOptions = this.nextPageRequestOptions();
+    if (!nextOptions) {
+      throw new AnthropicError(
+        'No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.',
+      );
+    }
+
+    return await this.#client.requestAPIList(this.constructor as any, nextOptions);
+  }
+
+  async *iterPages(): AsyncGenerator<this> {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let page: this = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+
+  async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+}
+
+/**
+ * This subclass of Promise will resolve to an instantiated Page once the request completes.
+ *
+ * It also implements AsyncIterable to allow auto-paginating iteration on an unawaited list call, eg:
+ *
+ *    for await (const item of client.items.list()) {
+ *      console.log(item)
+ *    }
+ */
+export class PagePromise<
+    PageClass extends AbstractPage<Item>,
+    Item = ReturnType<PageClass['getPaginatedItems']>[number],
+  >
+  extends APIPromise<PageClass>
+  implements AsyncIterable<Item>
+{
+  constructor(
+    client: Anthropic,
+    request: Promise<APIResponseProps>,
+    Page: new (...args: ConstructorParameters<typeof AbstractPage>) => PageClass,
+  ) {
+    super(
+      request,
+      async (props) =>
+        new Page(
+          client,
+          props.response,
+          await defaultParseResponse(props),
+          props.options,
+        ) as WithRequestID<PageClass>,
+    );
+  }
+
+  /**
+   * Allow auto-paginating iteration on an unawaited list call, eg:
+   *
+   *    for await (const item of client.items.list()) {
+   *      console.log(item)
+   *    }
+   */
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+}
 
 export interface PageResponse<Item> {
   data: Array<Item>;
@@ -32,7 +142,7 @@ export class Page<Item> extends AbstractPage<Item> implements PageResponse<Item>
 
   last_id: string | null;
 
-  constructor(client: APIClient, response: Response, body: PageResponse<Item>, options: FinalRequestOptions) {
+  constructor(client: Anthropic, response: Response, body: PageResponse<Item>, options: FinalRequestOptions) {
     super(client, response, body, options);
 
     this.data = body.data || [];
@@ -45,27 +155,19 @@ export class Page<Item> extends AbstractPage<Item> implements PageResponse<Item>
     return this.data ?? [];
   }
 
-  // @deprecated Please use `nextPageInfo()` instead
-  nextPageParams(): Partial<PageParams> | null {
-    const info = this.nextPageInfo();
-    if (!info) return null;
-    if ('params' in info) return info.params;
-    const params = Object.fromEntries(info.url.searchParams);
-    if (!Object.keys(params).length) return null;
-    return params;
-  }
-
-  nextPageInfo(): PageInfo | null {
+  nextPageRequestOptions(): PageRequestOptions | null {
     if ((this.options.query as Record<string, unknown>)?.['before_id']) {
       // in reverse
-      const firstId = this.first_id;
-      if (!firstId) {
+      const first_id = this.first_id;
+      if (!first_id) {
         return null;
       }
 
       return {
-        params: {
-          before_id: firstId,
+        ...this.options,
+        query: {
+          ...maybeObj(this.options.query),
+          before_id: first_id,
         },
       };
     }
@@ -76,7 +178,9 @@ export class Page<Item> extends AbstractPage<Item> implements PageResponse<Item>
     }
 
     return {
-      params: {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
         after_id: cursor,
       },
     };

package/src/resource.ts

@@ -1,11 +1,11 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import * as Core from "./core.js";
+import { BaseAnthropic } from './client';
 
 export class APIResource {
-  protected _client: Core.APIClient;
+  protected _client: BaseAnthropic;
 
-  constructor(client: Core.APIClient) {
+  constructor(client: BaseAnthropic) {
     this._client = client;
   }
 }

package/src/resources/beta/beta.ts

@@ -1,9 +1,9 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from "../../resource.js";
-import * as ModelsAPI from "./models.js";
-import { BetaModelInfo, BetaModelInfosPage, ModelListParams, Models } from "./models.js";
-import * as MessagesAPI from "./messages/messages.js";
+import { APIResource } from '../../resource';
+import * as ModelsAPI from './models';
+import { BetaModelInfo, BetaModelInfosPage, ModelListParams, Models } from './models';
+import * as MessagesAPI from './messages/messages';
 import {
   BetaBase64PDFBlock,
   BetaBase64PDFSource,
@@ -45,7 +45,7 @@ import {
   MessageCreateParamsNonStreaming,
   MessageCreateParamsStreaming,
   Messages,
-} from "./messages/messages.js";
+} from './messages/messages';
 
 export class Beta extends APIResource {
   models: ModelsAPI.Models = new ModelsAPI.Models(this._client);
@@ -132,7 +132,6 @@ export interface BetaRateLimitError {
 }
 
 Beta.Models = Models;
-Beta.BetaModelInfosPage = BetaModelInfosPage;
 Beta.Messages = Messages;
 
 export declare namespace Beta {
@@ -154,7 +153,7 @@ export declare namespace Beta {
   export {
     Models as Models,
     type BetaModelInfo as BetaModelInfo,
-    BetaModelInfosPage as BetaModelInfosPage,
+    type BetaModelInfosPage as BetaModelInfosPage,
     type ModelListParams as ModelListParams,
   };
 

package/src/resources/beta/index.ts

@@ -14,8 +14,7 @@ export {
   type BetaOverloadedError,
   type BetaPermissionError,
   type BetaRateLimitError,
-} from "./beta.js";
-export { BetaModelInfosPage, Models, type BetaModelInfo, type ModelListParams } from "./models.js";
+} from './beta';
 export {
   Messages,
   type BetaBase64PDFBlock,
@@ -57,4 +56,5 @@ export {
   type MessageCreateParamsNonStreaming,
   type MessageCreateParamsStreaming,
   type MessageCountTokensParams,
-} from "./messages/index.js";
+} from './messages/index';
+export { Models, type BetaModelInfo, type ModelListParams, type BetaModelInfosPage } from './models';