@anthropic-ai/sdk 0.5.0 → 0.5.2

package/{_shims → src/_shims}/getMultipartRequestOptions.node.ts

@@ -6,6 +6,7 @@ import { FormData } from './formdata.node';
 import type { RequestOptions } from '../core';
 import { Readable } from 'node:stream';
 import { FormDataEncoder } from 'form-data-encoder';
+import { MultipartBody } from '../uploads';
 
 export async function getMultipartRequestOptions<T extends {} = Record<string, unknown>>(
   form: FormData,
@@ -13,7 +14,7 @@ export async function getMultipartRequestOptions<T extends {} = Record<string, u
 ): Promise<RequestOptions<T>> {
   const encoder = new FormDataEncoder(form);
   const readable = Readable.from(encoder);
-  const body = { __multipartBody__: readable };
+  const body = new MultipartBody(readable);
   const headers = {
     ...opts.headers,
     ...encoder.headers,

package/{_shims → src/_shims}/getMultipartRequestOptions.ts

@@ -4,10 +4,11 @@
 
 import { FormData } from './formdata';
 import type { RequestOptions } from '../core';
+import { MultipartBody } from '../uploads';
 
 export async function getMultipartRequestOptions<T extends {} = Record<string, unknown>>(
   form: FormData,
   opts: RequestOptions<T>,
 ): Promise<RequestOptions<T>> {
-  return { ...opts, body: { __multipartBody__: form } as any };
+  return { ...opts, body: new MultipartBody(form) as any };
 }

package/src/_shims/node-readable.node.ts

@@ -0,0 +1,10 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+export type { Readable } from 'node:stream';
+import { ReadStream as FsReadStream } from 'node:fs';
+export type { FsReadStream };
+
+export function isFsReadStream(value: any): value is FsReadStream {
+  return value instanceof FsReadStream;
+}

package/src/_shims/node-readable.ts

@@ -0,0 +1,30 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+
+// shim these Node types to avoid importing @types/node and polluting the user's
+// type environment in non-node projects
+
+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
+}
+
+export function isFsReadStream(value: any): value is FsReadStream {
+  return false;
+}

package/{core.ts → src/core.ts}

@@ -1,17 +1,23 @@
-import type { Readable } from 'node:stream';
-import type { Agent } from 'http';
-
-import qs from 'qs';
-
+import * as qs from 'qs';
 import { VERSION } from './version';
 import { Stream } from './streaming';
 import { APIError, APIConnectionError, APIConnectionTimeoutError } from './error';
-import { getDefaultAgent } from '@anthropic-ai/sdk/_shims/agent';
-import { fetch, isPolyfilled as fetchIsPolyfilled } from '@anthropic-ai/sdk/_shims/fetch';
-import type { RequestInfo, RequestInit, Response } from '@anthropic-ai/sdk/_shims/fetch';
+import type { Readable } from '@anthropic-ai/sdk/_shims/node-readable';
+import { getDefaultAgent, type Agent } from '@anthropic-ai/sdk/_shims/agent';
+import {
+  fetch,
+  isPolyfilled as fetchIsPolyfilled,
+  type RequestInfo,
+  type RequestInit,
+  type Response,
+} from '@anthropic-ai/sdk/_shims/fetch';
 import { isMultipartBody } from './uploads';
-export { maybeMultipartFormRequestOptions, multipartFormRequestOptions, createForm } from './uploads';
-export type { Uploadable } from '@anthropic-ai/sdk/_shims/uploadable';
+export {
+  maybeMultipartFormRequestOptions,
+  multipartFormRequestOptions,
+  createForm,
+  type Uploadable,
+} from './uploads';
 
 const MAX_RETRIES = 2;
 
@@ -67,6 +73,8 @@ export abstract class APIClient {
     };
   }
 
+  protected abstract defaultQuery(): DefaultQuery | undefined;
+
   /**
    * Override this to add your own headers validation:
    */
@@ -118,7 +126,7 @@ export abstract class APIClient {
     const { method, path, query, headers: headers = {} } = options;
 
     const body =
-      isMultipartBody(options.body) ? options.body.__multipartBody__
+      isMultipartBody(options.body) ? options.body.body
       : options.body ? JSON.stringify(options.body, null, 2)
       : null;
     const contentLength = typeof body === 'string' ? body.length.toString() : null;
@@ -148,7 +156,7 @@ export abstract class APIClient {
 
     const req: RequestInit = {
       method,
-      ...(body && { body }),
+      ...(body && { body: body as any }),
       headers: reqHeaders,
       ...(httpAgent && { agent: httpAgent }),
     };
@@ -254,6 +262,11 @@ export abstract class APIClient {
         new URL(path)
       : new URL(this.baseURL + (this.baseURL.endsWith('/') && path.startsWith('/') ? path.slice(1) : path));
 
+    const defaultQuery = this.defaultQuery();
+    if (!isEmptyObj(defaultQuery)) {
+      query = { ...defaultQuery, ...query } as Req;
+    }
+
     if (query) {
       url.search = qs.stringify(query, this.qsOptions());
     }
@@ -263,11 +276,12 @@ export abstract class APIClient {
 
   async fetchWithTimeout(
     url: RequestInfo,
-    { signal, ...options }: RequestInit = {},
+    init: RequestInit | undefined,
     ms: number,
     controller: AbortController,
-  ) {
-    if (signal) signal.addEventListener('abort', controller.abort);
+  ): Promise<Response> {
+    const { signal, ...options } = init || {};
+    if (signal) signal.addEventListener('abort', () => controller.abort());
 
     const timeout = setTimeout(() => controller.abort(), ms);
 
@@ -491,18 +505,25 @@ export class PagePromise<
 export const createResponseHeaders = (
   headers: Awaited<ReturnType<Fetch>>['headers'],
 ): Record<string, string> => {
-  return new Proxy(Object.fromEntries(headers.entries()), {
-    get(target, name) {
-      const key = name.toString();
-      return target[key.toLowerCase()] || target[key];
+  return new Proxy(
+    Object.fromEntries(
+      // @ts-ignore
+      headers.entries(),
+    ),
+    {
+      get(target, name) {
+        const key = name.toString();
+        return target[key.toLowerCase()] || target[key];
+      },
     },
-  });
+  );
 };
 
 type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
 
 export type RequestClient = { fetch: Fetch };
 export type Headers = Record<string, string | null | undefined>;
+export type DefaultQuery = Record<string, string | undefined>;
 export type KeysEnum<T> = { [P in keyof Required<T>]: true };
 
 export type RequestOptions<Req extends {} = Record<string, unknown> | Readable> = {
@@ -551,6 +572,7 @@ export type FinalRequestOptions<Req extends {} = Record<string, unknown> | Reada
 };
 
 export type APIResponse<T> = T & {
+  /** @deprecated - we plan to add a different way to access raw response information shortly. */
   responseHeaders: Headers;
 };
 

package/{index.ts → src/index.ts}

@@ -1,10 +1,10 @@
 // File generated from our OpenAPI spec by Stainless.
 
-import qs from 'qs';
+import * as qs from 'qs';
 import * as Core from './core';
-import * as API from './resources';
+import * as API from './resources/index';
 import * as Errors from './error';
-import type { Agent } from 'http';
+import type { Agent } from '@anthropic-ai/sdk/_shims/agent';
 import * as Uploads from './uploads';
 
 type Config = {
@@ -12,11 +12,53 @@ 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;
 };
 
@@ -48,6 +90,10 @@ export class Anthropic extends Core.APIClient {
 
   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(),
@@ -150,4 +196,5 @@ export namespace Anthropic {
   export import Completion = API.Completion;
   export import CompletionCreateParams = API.CompletionCreateParams;
 }
+
 export default Anthropic;

package/{resources → src/resources}/completions.ts

@@ -1,9 +1,9 @@
 // File generated from our OpenAPI spec by Stainless.
 
-import * as Core from '~/core';
-import { APIResource } from '~/resource';
+import * as Core from '@anthropic-ai/sdk/core';
+import { APIResource } from '@anthropic-ai/sdk/resource';
 import * as API from './';
-import { Stream } from '~/streaming';
+import { Stream } from '@anthropic-ai/sdk/streaming';
 
 export class Completions extends APIResource {
   /**
@@ -21,7 +21,7 @@ export class Completions extends APIResource {
     body: CompletionCreateParams,
     options?: Core.RequestOptions,
   ): Promise<Core.APIResponse<Completion | Stream<Completion>>> {
-    return this.post('/v1/complete', { body, ...options, stream: body.stream ?? false });
+    return this.post('/v1/complete', { body, timeout: 600000, ...options, stream: body.stream ?? false });
   }
 }
 

package/{streaming.ts → src/streaming.ts}

@@ -1,7 +1,11 @@
 import type { Response } from '@anthropic-ai/sdk/_shims/fetch';
-import { APIResponse, Headers, createResponseHeaders } from '~/core';
-import { safeJSON } from '~/core';
-import { APIError } from '~/error';
+
+import { APIResponse, Headers, createResponseHeaders } from './core';
+
+import { safeJSON } from '@anthropic-ai/sdk/core';
+import { APIError } from '@anthropic-ai/sdk/error';
+
+type Bytes = string | ArrayBuffer | Uint8Array | Buffer | null | undefined;
 
 type ServerSentEvent = {
   event: string | null;
@@ -65,7 +69,9 @@ class SSEDecoder {
 }
 
 export class Stream<Item> implements AsyncIterable<Item>, APIResponse<Stream<Item>> {
+  /** @deprecated - please use the async iterator instead. We plan to add additional helper methods shortly. */
   response: Response;
+  /** @deprecated - we plan to add a different way to access raw response information shortly. */
   responseHeaders: Headers;
   controller: AbortController;
 
@@ -83,18 +89,11 @@ export class Stream<Item> implements AsyncIterable<Item>, APIResponse<Stream<Ite
       this.controller.abort();
       throw new Error(`Attempted to iterate over a response with no body`);
     }
-
     const lineDecoder = new LineDecoder();
 
-    for await (const chunk of this.response.body) {
-      let text;
-      if (chunk instanceof Buffer) {
-        text = chunk.toString();
-      } else if ((chunk as any) instanceof Uint8Array) {
-        text = Buffer.from(chunk).toString();
-      } else {
-        text = chunk;
-      }
+    const iter = readableStreamAsyncIterable<Bytes>(this.response.body);
+    for await (const chunk of iter) {
+      const text = decodeText(chunk);
 
       for (const line of lineDecoder.decode(text)) {
         const sse = this.decoder.decode(line);
@@ -215,3 +214,67 @@ function partition(str: string, delimiter: string): [string, string, string] {
 
   return [str, '', ''];
 }
+
+let _textDecoder;
+function decodeText(bytes: Bytes): string {
+  if (bytes == null) return '';
+  if (typeof bytes === 'string') return bytes;
+
+  // Node:
+  if (typeof Buffer !== 'undefined') {
+    if (bytes instanceof Buffer) {
+      return bytes.toString();
+    }
+    if (bytes instanceof Uint8Array) {
+      return Buffer.from(bytes).toString();
+    }
+
+    throw new Error(`Unexpected: received non-Uint8Array (${bytes.constructor.name}) in Node.`);
+  }
+
+  // Browser
+  if (typeof TextDecoder !== 'undefined') {
+    if (bytes instanceof Uint8Array || bytes instanceof ArrayBuffer) {
+      _textDecoder ??= new TextDecoder('utf8');
+      return _textDecoder.decode(bytes);
+    }
+
+    throw new Error(
+      `Unexpected: received non-Uint8Array/ArrayBuffer (${
+        (bytes as any).constructor.name
+      }) in a web platform.`,
+    );
+  }
+
+  throw new Error(`Unexpected: neither Buffer nor TextDecoder are available as globals.`);
+}
+
+/**
+ * Most browsers don't yet have async iterable support for ReadableStream,
+ * and Node has a very different way of reading bytes from its "ReadableStream".
+ *
+ * This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1624185965
+ *
+ * We make extensive use of "any" here to avoid pulling in either "node" or "dom" types
+ * to library users' type scopes.
+ */
+function readableStreamAsyncIterable<T>(stream: any): AsyncIterableIterator<T> {
+  if (stream[Symbol.asyncIterator]) {
+    return stream[Symbol.asyncIterator];
+  }
+
+  const reader = stream.getReader();
+
+  return {
+    next() {
+      return reader.read();
+    },
+    async return() {
+      reader.releaseLock();
+      return { done: true, value: undefined };
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+}

package/src/uploads.ts

@@ -0,0 +1,248 @@
+import { type RequestOptions } from './core';
+import { type Readable } from '@anthropic-ai/sdk/_shims/node-readable';
+import { type BodyInit } from '@anthropic-ai/sdk/_shims/fetch';
+import { FormData, File, type FilePropertyBag } from '@anthropic-ai/sdk/_shims/formdata';
+import { getMultipartRequestOptions } from '@anthropic-ai/sdk/_shims/getMultipartRequestOptions';
+import { fileFromPath } from '@anthropic-ai/sdk/_shims/fileFromPath';
+import { type FsReadStream, isFsReadStream } from '@anthropic-ai/sdk/_shims/node-readable';
+
+export { fileFromPath };
+
+export type BlobPart = string | ArrayBuffer | ArrayBufferView | BlobLike | Uint8Array | DataView;
+
+/**
+ * Typically, this is a native "File" class.
+ *
+ * We provide the {@link toFile} utility to convert a variety of objects
+ * into the File class.
+ *
+ * For convenience, you can also pass a fetch Response, or in Node,
+ * the result of fs.createReadStream().
+ */
+export type Uploadable = FileLike | ResponseLike | FsReadStream;
+
+/**
+ * Intended to match web.Blob, node.Blob, node-fetch.Blob, etc.
+ */
+export interface BlobLike {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/size) */
+  readonly size: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/type) */
+  readonly type: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/text) */
+  text(): Promise<string>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/slice) */
+  slice(start?: number, end?: number): BlobLike;
+  // unfortunately @types/node-fetch@^2.6.4 doesn't type the arrayBuffer method
+}
+
+/**
+ * Intended to match web.File, node.File, node-fetch.File, etc.
+ */
+export interface FileLike extends BlobLike {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/lastModified) */
+  readonly lastModified: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */
+  readonly name: string;
+}
+
+/**
+ * Intended to match web.Response, node.Response, node-fetch.Response, etc.
+ */
+export interface ResponseLike {
+  url: string;
+  blob(): Promise<BlobLike>;
+}
+
+export const isResponseLike = (value: any): value is ResponseLike =>
+  value != null &&
+  typeof value === 'object' &&
+  typeof value.url === 'string' &&
+  typeof value.blob === 'function';
+
+export const isFileLike = (value: any): value is FileLike =>
+  value != null &&
+  typeof value === 'object' &&
+  typeof value.name === 'string' &&
+  typeof value.lastModified === 'number' &&
+  isBlobLike(value);
+
+/**
+ * The BlobLike type omits arrayBuffer() because @types/node-fetch@^2.6.4 lacks it; but this check
+ * adds the arrayBuffer() method type because it is available and used at runtime
+ */
+export const isBlobLike = (value: any): value is BlobLike & { arrayBuffer(): Promise<ArrayBuffer> } =>
+  value != null &&
+  typeof value === 'object' &&
+  typeof value.size === 'number' &&
+  typeof value.type === 'string' &&
+  typeof value.text === 'function' &&
+  typeof value.slice === 'function' &&
+  typeof value.arrayBuffer === 'function';
+
+export const isUploadable = (value: any): value is Uploadable => {
+  return isFileLike(value) || isResponseLike(value) || isFsReadStream(value);
+};
+
+export type ToFileInput = Uploadable | Exclude<BlobPart, string> | AsyncIterable<BlobPart>;
+
+/**
+ * Helper for creating a {@link File} to pass to an SDK upload method from a variety of different data formats
+ * @param bits the raw content of the file.  Can be an {@link Uploadable}, {@link BlobPart}, or {@link AsyncIterable} of {@link BlobPart}s
+ * @param {string=} name the name of the file. If omitted, toFile will try to determine a file name from bits if possible
+ * @param {Object=} options additional properties
+ * @param {string=} options.type the MIME type of the content
+ * @param {number=} options.lastModified the last modified timestamp
+ * @returns a {@link File} with the given properties
+ */
+export async function toFile(
+  value: ToFileInput,
+  name?: string | null | undefined,
+  options: FilePropertyBag | undefined = {},
+): Promise<FileLike> {
+  if (isResponseLike(value)) {
+    const blob = await value.blob();
+    name ||= new URL(value.url).pathname.split(/[\\/]/).pop() ?? 'unknown_file';
+
+    return new File([blob as any], name, options);
+  }
+
+  const bits = await getBytes(value);
+
+  name ||= getName(value) ?? 'unknown_file';
+
+  if (!options.type) {
+    const type = (bits[0] as any)?.type;
+    if (typeof type === 'string') {
+      options = { ...options, type };
+    }
+  }
+
+  return new File(bits, name, options);
+}
+
+async function getBytes(value: ToFileInput): Promise<Array<BlobPart>> {
+  if (value instanceof Promise) return getBytes(await (value as any));
+
+  let parts: Array<BlobPart> = [];
+  if (
+    typeof value === 'string' ||
+    ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc.
+    value instanceof ArrayBuffer
+  ) {
+    parts.push(value);
+  } else if (isBlobLike(value)) {
+    parts.push(await value.arrayBuffer());
+  } else if (
+    isAsyncIterableIterator(value) // includes Readable, ReadableStream, etc.
+  ) {
+    for await (const chunk of value) {
+      parts.push(chunk as BlobPart); // TODO, consider validating?
+    }
+  } else {
+    throw new Error(
+      `Unexpected data type: ${typeof value}; constructor: ${
+        value?.constructor?.name
+      }; props: ${propsForError(value)}`,
+    );
+  }
+
+  return parts;
+}
+
+function propsForError(value: any): string {
+  const props = Object.getOwnPropertyNames(value);
+  return `[${props.map((p) => `"${p}"`).join(', ')}]`;
+}
+
+function getName(value: any): string | undefined {
+  return (
+    getStringFromMaybeBuffer(value.name) ||
+    getStringFromMaybeBuffer(value.filename) ||
+    // For fs.ReadStream
+    getStringFromMaybeBuffer(value.path)?.split(/[\\/]/).pop()
+  );
+}
+
+const getStringFromMaybeBuffer = (x: string | Buffer | unknown): string | undefined => {
+  if (typeof x === 'string') return x;
+  if (typeof Buffer !== 'undefined' && x instanceof Buffer) return String(x);
+  return undefined;
+};
+
+const isAsyncIterableIterator = (value: any): value is AsyncIterableIterator<unknown> =>
+  value != null && typeof value === 'object' && typeof value[Symbol.asyncIterator] === 'function';
+
+export class MultipartBody {
+  constructor(public body: Readable | BodyInit) {}
+  get [Symbol.toStringTag](): string {
+    return 'MultipartBody';
+  }
+}
+
+export const isMultipartBody = (body: any): body is MultipartBody =>
+  body && typeof body === 'object' && body.body && body[Symbol.toStringTag] === 'MultipartBody';
+
+/**
+ * Returns a multipart/form-data request if any part of the given request body contains a File / Blob value.
+ * Otherwise returns the request as is.
+ */
+export const maybeMultipartFormRequestOptions = async <T extends {} = Record<string, unknown>>(
+  opts: RequestOptions<T>,
+): Promise<RequestOptions<T | MultipartBody>> => {
+  if (!hasUploadableValue(opts.body)) return opts;
+
+  const form = await createForm(opts.body);
+  return getMultipartRequestOptions(form, opts);
+};
+
+export const multipartFormRequestOptions = async <T extends {} = Record<string, unknown>>(
+  opts: RequestOptions<T>,
+): Promise<RequestOptions<T | MultipartBody>> => {
+  const form = await createForm(opts.body);
+  return getMultipartRequestOptions(form, opts);
+};
+
+export const createForm = async <T = Record<string, unknown>>(body: T | undefined): Promise<FormData> => {
+  const form = new FormData();
+  await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value)));
+  return form;
+};
+
+const hasUploadableValue = (value: unknown): boolean => {
+  if (isUploadable(value)) return true;
+  if (Array.isArray(value)) return value.some(hasUploadableValue);
+  if (value && typeof value === 'object') {
+    for (const k in value) {
+      if (hasUploadableValue((value as any)[k])) return true;
+    }
+  }
+  return false;
+};
+
+const addFormValue = async (form: FormData, key: string, value: unknown): Promise<void> => {
+  if (value === undefined) return;
+  if (value == null) {
+    throw new TypeError(
+      `Received null for "${key}"; to pass null in FormData, you must use the string 'null'`,
+    );
+  }
+
+  // TODO: make nested formats configurable
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    form.append(key, value);
+  } else if (isUploadable(value)) {
+    const file = await toFile(value);
+    form.append(key, file);
+  } else if (Array.isArray(value)) {
+    await Promise.all(value.map((entry) => addFormValue(form, key + '[]', entry)));
+  } else if (typeof value === 'object') {
+    await Promise.all(
+      Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop)),
+    );
+  } else {
+    throw new TypeError(
+      `Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`,
+    );
+  }
+};

package/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = '0.5.2';

package/{dist/esm/streaming.d.ts → streaming.d.ts}

@@ -1,7 +1,9 @@
 import type { Response } from '@anthropic-ai/sdk/_shims/fetch';
 import { APIResponse, Headers } from './core.js';
 export declare class Stream<Item> implements AsyncIterable<Item>, APIResponse<Stream<Item>> {
+  /** @deprecated - please use the async iterator instead. We plan to add additional helper methods shortly. */
   response: Response;
+  /** @deprecated - we plan to add a different way to access raw response information shortly. */
   responseHeaders: Headers;
   controller: AbortController;
   private decoder;

package/streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAAE,WAAW,EAAE,OAAO,EAAyB,MAAM,QAAQ,CAAC;AAoErE,qBAAa,MAAM,CAAC,IAAI,CAAE,YAAW,aAAa,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjF,6GAA6G;IAC7G,QAAQ,EAAE,QAAQ,CAAC;IACnB,+FAA+F;IAC/F,eAAe,EAAE,OAAO,CAAC;IACzB,UAAU,EAAE,eAAe,CAAC;IAE5B,OAAO,CAAC,OAAO,CAAa;gBAEhB,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,eAAe;YAO5C,YAAY;IAuBpB,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,CAAC;CAkCrE"}