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

package/src/lib/MessageStream.ts

@@ -1,4 +1,5 @@
-import { AnthropicError, APIUserAbortError } from '../error';
+import * as Core from "../core.js";
+import { AnthropicError, APIUserAbortError } from "../error.js";
 import {
   type ContentBlock,
   Messages,
@@ -8,11 +9,10 @@ import {
   type MessageCreateParams,
   type MessageCreateParamsBase,
   type TextBlock,
-} 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';
+} from "../resources/messages.js";
+import { type ReadableStream, type Response } from "../_shims/index.js";
+import { Stream } from "../streaming.js";
+import { partialParse } from "../_vendor/partial-json-parser/parser.js";
 
 export interface MessageStreamEvents {
   connect: () => void;
@@ -41,8 +41,8 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
 
   controller: AbortController = new AbortController();
 
-  #connectedPromise: Promise<void>;
-  #resolveConnectedPromise: () => void = () => {};
+  #connectedPromise: Promise<Response | null>;
+  #resolveConnectedPromise: (response: Response | null) => void = () => {};
   #rejectConnectedPromise: (error: AnthropicError) => void = () => {};
 
   #endPromise: Promise<void>;
@@ -55,9 +55,10 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
   #errored = false;
   #aborted = false;
   #catchingPromiseCreated = false;
+  #request_id: string | null | undefined;
 
   constructor() {
-    this.#connectedPromise = new Promise<void>((resolve, reject) => {
+    this.#connectedPromise = new Promise<Response | null>((resolve, reject) => {
       this.#resolveConnectedPromise = resolve;
       this.#rejectConnectedPromise = reject;
     });
@@ -75,6 +76,37 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
     this.#endPromise.catch(() => {});
   }
 
+  get request_id(): string | null | undefined {
+    return this.#request_id;
+  }
+
+  /**
+   * Returns the `MessageStream` data, the raw `Response` instance and the ID of the request,
+   * returned vie the `request-id` header which is useful for debugging requests and resporting
+   * issues to Anthropic.
+   *
+   * This is the same as the `APIPromise.withResponse()` method.
+   *
+   * This method will raise an error if you created the stream using `MessageStream.fromReadableStream`
+   * as no `Response` is available.
+   */
+  async withResponse(): Promise<{
+    data: MessageStream;
+    response: Response;
+    request_id: string | null | undefined;
+  }> {
+    const response = await this.#connectedPromise;
+    if (!response) {
+      throw new Error('Could not resolve a `Response` object');
+    }
+
+    return {
+      data: this,
+      response,
+      request_id: response.headers.get('request-id'),
+    };
+  }
+
   /**
    * Intended for use on the frontend, consuming a stream produced with
    * `.toReadableStream()` on the backend.
@@ -91,7 +123,7 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
   static createMessage(
     messages: Messages,
     params: MessageCreateParamsBase,
-    options?: RequestOptions,
+    options?: Core.RequestOptions,
   ): MessageStream {
     const runner = new MessageStream();
     for (const message of params.messages) {
@@ -128,7 +160,7 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
   protected async _createMessage(
     messages: Messages,
     params: MessageCreateParams,
-    options?: RequestOptions,
+    options?: Core.RequestOptions,
   ): Promise<void> {
     const signal = options?.signal;
     if (signal) {
@@ -136,11 +168,10 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
       signal.addEventListener('abort', () => this.controller.abort());
     }
     this.#beginRequest();
-    const stream = await messages.create(
-      { ...params, stream: true },
-      { ...options, signal: this.controller.signal },
-    );
-    this._connected();
+    const { response, data: stream } = await messages
+      .create({ ...params, stream: true }, { ...options, signal: this.controller.signal })
+      .withResponse();
+    this._connected(response);
     for await (const event of stream) {
       this.#addStreamEvent(event);
     }
@@ -150,9 +181,10 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
     this.#endRequest();
   }
 
-  protected _connected() {
+  protected _connected(response: Response | null) {
     if (this.ended) return;
-    this.#resolveConnectedPromise();
+    this.#request_id = response?.headers.get('request-id');
+    this.#resolveConnectedPromise(response);
     this._emit('connect');
   }
 
@@ -416,7 +448,7 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
 
   protected async _fromReadableStream(
     readableStream: ReadableStream,
-    options?: RequestOptions,
+    options?: Core.RequestOptions,
   ): Promise<void> {
     const signal = options?.signal;
     if (signal) {
@@ -424,7 +456,7 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
       signal.addEventListener('abort', () => this.controller.abort());
     }
     this.#beginRequest();
-    this._connected();
+    this._connected(null);
     const stream = Stream.fromReadableStream<MessageStreamEvent>(readableStream, this.controller);
     for await (const event of stream) {
       this.#addStreamEvent(event);

package/src/pagination.ts

@@ -1,116 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-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;
-    }
-  }
-}
+import { AbstractPage, Response, APIClient, FinalRequestOptions, PageInfo } from "./core.js";
 
 export interface PageResponse<Item> {
   data: Array<Item>;
@@ -142,7 +32,7 @@ export class Page<Item> extends AbstractPage<Item> implements PageResponse<Item>
 
   last_id: string | null;
 
-  constructor(client: Anthropic, response: Response, body: PageResponse<Item>, options: FinalRequestOptions) {
+  constructor(client: APIClient, response: Response, body: PageResponse<Item>, options: FinalRequestOptions) {
     super(client, response, body, options);
 
     this.data = body.data || [];
@@ -155,19 +45,27 @@ export class Page<Item> extends AbstractPage<Item> implements PageResponse<Item>
     return this.data ?? [];
   }
 
-  nextPageRequestOptions(): PageRequestOptions | null {
+  // @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 {
     if ((this.options.query as Record<string, unknown>)?.['before_id']) {
       // in reverse
-      const first_id = this.first_id;
-      if (!first_id) {
+      const firstId = this.first_id;
+      if (!firstId) {
         return null;
       }
 
       return {
-        ...this.options,
-        query: {
-          ...maybeObj(this.options.query),
-          before_id: first_id,
+        params: {
+          before_id: firstId,
         },
       };
     }
@@ -178,9 +76,7 @@ export class Page<Item> extends AbstractPage<Item> implements PageResponse<Item>
     }
 
     return {
-      ...this.options,
-      query: {
-        ...maybeObj(this.options.query),
+      params: {
         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 { BaseAnthropic } from './client';
+import * as Core from "./core.js";
 
 export class APIResource {
-  protected _client: BaseAnthropic;
+  protected _client: Core.APIClient;
 
-  constructor(client: BaseAnthropic) {
+  constructor(client: Core.APIClient) {
     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';
-import * as ModelsAPI from './models';
-import { BetaModelInfo, BetaModelInfosPage, ModelListParams, Models } from './models';
-import * as MessagesAPI from './messages/messages';
+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 {
   BetaBase64PDFBlock,
   BetaBase64PDFSource,
@@ -45,7 +45,7 @@ import {
   MessageCreateParamsNonStreaming,
   MessageCreateParamsStreaming,
   Messages,
-} from './messages/messages';
+} from "./messages/messages.js";
 
 export class Beta extends APIResource {
   models: ModelsAPI.Models = new ModelsAPI.Models(this._client);
@@ -132,6 +132,7 @@ export interface BetaRateLimitError {
 }
 
 Beta.Models = Models;
+Beta.BetaModelInfosPage = BetaModelInfosPage;
 Beta.Messages = Messages;
 
 export declare namespace Beta {
@@ -153,7 +154,7 @@ export declare namespace Beta {
   export {
     Models as Models,
     type BetaModelInfo as BetaModelInfo,
-    type BetaModelInfosPage as BetaModelInfosPage,
+    BetaModelInfosPage as BetaModelInfosPage,
     type ModelListParams as ModelListParams,
   };
 

package/src/resources/beta/index.ts

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

package/src/resources/beta/messages/batches.ts

@@ -1,13 +1,13 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../../resource';
-import * as BetaAPI from '../beta';
-import * as BetaMessagesAPI from './messages';
-import { APIPromise } from '../../../api-promise';
-import { Page, type PageParams, PagePromise } from '../../../pagination';
-import { RequestOptions } from '../../../internal/request-options';
-import { JSONLDecoder } from '../../../internal/decoders/jsonl';
-import { AnthropicError } from '../../../error';
+import { APIResource } from "../../../resource.js";
+import { isRequestOptions } from "../../../core.js";
+import * as Core from "../../../core.js";
+import * as BetaAPI from "../beta.js";
+import * as BetaMessagesAPI from "./messages.js";
+import { Page, type PageParams } from "../../../pagination.js";
+import { JSONLDecoder } from "../../../internal/decoders/jsonl.js";
+import { AnthropicError } from "../../../error.js";
 
 export class Batches extends APIResource {
   /**
@@ -17,7 +17,7 @@ export class Batches extends APIResource {
    * once. Once a Message Batch is created, it begins processing immediately. Batches
    * can take up to 24 hours to complete.
    */
-  create(params: BatchCreateParams, options?: RequestOptions): APIPromise<BetaMessageBatch> {
+  create(params: BatchCreateParams, options?: Core.RequestOptions): Core.APIPromise<BetaMessageBatch> {
     const { betas, ...body } = params;
     return this._client.post('/v1/messages/batches?beta=true', {
       body,
@@ -35,12 +35,21 @@ export class Batches extends APIResource {
    * `results_url` field in the response.
    */
   retrieve(
-    messageBatchID: string,
-    params: BatchRetrieveParams | null | undefined = {},
-    options?: RequestOptions,
-  ): APIPromise<BetaMessageBatch> {
-    const { betas } = params ?? {};
-    return this._client.get(`/v1/messages/batches/${messageBatchID}?beta=true`, {
+    messageBatchId: string,
+    params?: BatchRetrieveParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<BetaMessageBatch>;
+  retrieve(messageBatchId: string, options?: Core.RequestOptions): Core.APIPromise<BetaMessageBatch>;
+  retrieve(
+    messageBatchId: string,
+    params: BatchRetrieveParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<BetaMessageBatch> {
+    if (isRequestOptions(params)) {
+      return this.retrieve(messageBatchId, {}, params);
+    }
+    const { betas } = params;
+    return this._client.get(`/v1/messages/batches/${messageBatchId}?beta=true`, {
       ...options,
       headers: {
         'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString(),
@@ -54,11 +63,19 @@ export class Batches extends APIResource {
    * returned first.
    */
   list(
-    params: BatchListParams | null | undefined = {},
-    options?: RequestOptions,
-  ): PagePromise<BetaMessageBatchesPage, BetaMessageBatch> {
-    const { betas, ...query } = params ?? {};
-    return this._client.getAPIList('/v1/messages/batches?beta=true', Page<BetaMessageBatch>, {
+    params?: BatchListParams,
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<BetaMessageBatchesPage, BetaMessageBatch>;
+  list(options?: Core.RequestOptions): Core.PagePromise<BetaMessageBatchesPage, BetaMessageBatch>;
+  list(
+    params: BatchListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<BetaMessageBatchesPage, BetaMessageBatch> {
+    if (isRequestOptions(params)) {
+      return this.list({}, params);
+    }
+    const { betas, ...query } = params;
+    return this._client.getAPIList('/v1/messages/batches?beta=true', BetaMessageBatchesPage, {
       query,
       ...options,
       headers: {
@@ -74,12 +91,21 @@ export class Batches extends APIResource {
    * `results_url` field in the response.
    */
   delete(
-    messageBatchID: string,
-    params: BatchDeleteParams | null | undefined = {},
-    options?: RequestOptions,
-  ): APIPromise<BetaDeletedMessageBatch> {
-    const { betas } = params ?? {};
-    return this._client.delete(`/v1/messages/batches/${messageBatchID}?beta=true`, {
+    messageBatchId: string,
+    params?: BatchDeleteParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<BetaDeletedMessageBatch>;
+  delete(messageBatchId: string, options?: Core.RequestOptions): Core.APIPromise<BetaDeletedMessageBatch>;
+  delete(
+    messageBatchId: string,
+    params: BatchDeleteParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<BetaDeletedMessageBatch> {
+    if (isRequestOptions(params)) {
+      return this.delete(messageBatchId, {}, params);
+    }
+    const { betas } = params;
+    return this._client.delete(`/v1/messages/batches/${messageBatchId}?beta=true`, {
       ...options,
       headers: {
         'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString(),
@@ -100,12 +126,21 @@ export class Batches extends APIResource {
    * non-interruptible.
    */
   cancel(
-    messageBatchID: string,
-    params: BatchCancelParams | null | undefined = {},
-    options?: RequestOptions,
-  ): APIPromise<BetaMessageBatch> {
-    const { betas } = params ?? {};
-    return this._client.post(`/v1/messages/batches/${messageBatchID}/cancel?beta=true`, {
+    messageBatchId: string,
+    params?: BatchCancelParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<BetaMessageBatch>;
+  cancel(messageBatchId: string, options?: Core.RequestOptions): Core.APIPromise<BetaMessageBatch>;
+  cancel(
+    messageBatchId: string,
+    params: BatchCancelParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<BetaMessageBatch> {
+    if (isRequestOptions(params)) {
+      return this.cancel(messageBatchId, {}, params);
+    }
+    const { betas } = params;
+    return this._client.post(`/v1/messages/batches/${messageBatchId}/cancel?beta=true`, {
       ...options,
       headers: {
         'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString(),
@@ -122,23 +157,37 @@ export class Batches extends APIResource {
    * requests. Use the `custom_id` field to match results to requests.
    */
   async results(
-    messageBatchID: string,
-    params: BatchResultsParams | null | undefined = {},
-    options?: RequestOptions,
+    messageBatchId: string,
+    params?: BatchResultsParams,
+    options?: Core.RequestOptions,
+  ): Promise<JSONLDecoder<BetaMessageBatchIndividualResponse>>;
+  async results(
+    messageBatchId: string,
+    options?: Core.RequestOptions,
+  ): Promise<JSONLDecoder<BetaMessageBatchIndividualResponse>>;
+  async results(
+    messageBatchId: string,
+    params: BatchResultsParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
   ): Promise<JSONLDecoder<BetaMessageBatchIndividualResponse>> {
-    const batch = await this.retrieve(messageBatchID);
+    if (isRequestOptions(params)) {
+      return this.results(messageBatchId, {}, params);
+    }
+
+    const batch = await this.retrieve(messageBatchId);
     if (!batch.results_url) {
       throw new AnthropicError(
         `No batch \`results_url\`; Has it finished processing? ${batch.processing_status} - ${batch.id}`,
       );
     }
 
-    const { betas } = params ?? {};
+    const { betas } = params;
     return this._client
       .get(batch.results_url, {
         ...options,
         headers: {
           'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString(),
+          Accept: 'application/binary',
           ...options?.headers,
         },
         __binaryResponse: true,
@@ -147,7 +196,7 @@ export class Batches extends APIResource {
   }
 }
 
-export type BetaMessageBatchesPage = Page<BetaMessageBatch>;
+export class BetaMessageBatchesPage extends Page<BetaMessageBatch> {}
 
 export interface BetaDeletedMessageBatch {
   /**
@@ -390,6 +439,8 @@ export interface BatchResultsParams {
   betas?: Array<BetaAPI.AnthropicBeta>;
 }
 
+Batches.BetaMessageBatchesPage = BetaMessageBatchesPage;
+
 export declare namespace Batches {
   export {
     type BetaDeletedMessageBatch as BetaDeletedMessageBatch,
@@ -401,7 +452,7 @@ export declare namespace Batches {
     type BetaMessageBatchRequestCounts as BetaMessageBatchRequestCounts,
     type BetaMessageBatchResult as BetaMessageBatchResult,
     type BetaMessageBatchSucceededResult as BetaMessageBatchSucceededResult,
-    type BetaMessageBatchesPage as BetaMessageBatchesPage,
+    BetaMessageBatchesPage as BetaMessageBatchesPage,
     type BatchCreateParams as BatchCreateParams,
     type BatchRetrieveParams as BatchRetrieveParams,
     type BatchListParams as BatchListParams,

package/src/resources/beta/messages/index.ts

@@ -1,6 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 export {
+  BetaMessageBatchesPage,
   Batches,
   type BetaDeletedMessageBatch,
   type BetaMessageBatch,
@@ -17,8 +18,7 @@ export {
   type BatchDeleteParams,
   type BatchCancelParams,
   type BatchResultsParams,
-  type BetaMessageBatchesPage,
-} from './batches';
+} from "./batches.js";
 export {
   Messages,
   type BetaBase64PDFBlock,
@@ -60,4 +60,5 @@ export {
   type MessageCreateParamsNonStreaming,
   type MessageCreateParamsStreaming,
   type MessageCountTokensParams,
-} from './messages';
+  type BetaMessageStreamParams,
+} from "./messages.js";