@anthropic-ai/sdk 0.125.0 → 0.127.0

package/src/client.ts

@@ -31,12 +31,16 @@ export type { Middleware, MiddlewareContext, MiddlewareNext } from './core/middl
 export type { APIRequest } from './core/api';
 import * as Pagination from './core/pagination';
 import {
+  type BidirectionalPageCursor,
   type BidirectionalPageCursorParams,
   BidirectionalPageCursorResponse,
+  type Page,
+  type PageCursor,
   type PageCursorParams,
   PageCursorResponse,
   type PageParams,
   PageResponse,
+  type TokenPage,
   type TokenPageParams,
   TokenPageResponse,
 } from './core/pagination';
@@ -320,6 +324,12 @@ import {
   WebFetchToolResultErrorBlock,
   WebFetchToolResultErrorBlockParam,
   WebFetchToolResultErrorCode,
+  WebFetchURLSourceAll,
+  WebFetchURLSourceExcept,
+  WebFetchURLSourceNone,
+  WebFetchURLSourceOnly,
+  WebFetchURLSourceToolReference,
+  WebFetchURLSources,
   WebSearchResultBlock,
   WebSearchResultBlockParam,
   WebSearchTool20250305,
@@ -352,8 +362,8 @@ import { readEnv } from './internal/utils/env';
 import {
   type LogLevel,
   type Logger,
+  debugLogRequestDetails,
   defaultLogLevel,
-  formatRequestDetails,
   loggerFor,
   parseLogLevel,
 } from './internal/utils/log';
@@ -1040,7 +1050,7 @@ export class BaseAnthropic {
         ?.split(',')
         .map((s) => s.trim());
       if (!existing?.includes(OAUTH_API_BETA_HEADER)) {
-        headers.append('anthropic-beta', OAUTH_API_BETA_HEADER);
+        headers.set('anthropic-beta', [...(existing ?? []), OAUTH_API_BETA_HEADER].join(','));
       }
       request.headers = headers;
     }
@@ -1113,7 +1123,10 @@ export class BaseAnthropic {
     retryOfRequestLogID: string | undefined,
   ): Promise<APIResponseProps> {
     const options = await optionsInput;
-    const maxRetries = validatePositiveInteger('maxRetries', options.maxRetries ?? this.maxRetries);
+    let maxRetries = validatePositiveInteger('maxRetries', options.maxRetries ?? this.maxRetries);
+    if (this.isStreamBody(options.body)) {
+      maxRetries = 0;
+    }
     if (retriesRemaining == null) {
       retriesRemaining = maxRetries;
       // Top-level call: reset per-request auth flags so a reused options object
@@ -1166,43 +1179,42 @@ export class BaseAnthropic {
         this.middleware.length > 0 || !!options.middleware?.length || this.backendMiddleware().length > 0;
       if (hasMiddleware && !isTimeout && !isRetryableError(response)) {
         loggerFor(this).info(`[${requestLogID}] middleware error (not retryable)`);
-        loggerFor(this).debug(
-          `[${requestLogID}] middleware error (not retryable)`,
-          formatRequestDetails({
-            retryOfRequestLogID,
-            url,
-            durationMs: headersTime - startTime,
-            message: response.message,
-          }),
-        );
+        debugLogRequestDetails(loggerFor(this), `[${requestLogID}] middleware error (not retryable)`, {
+          retryOfRequestLogID,
+          url,
+          durationMs: headersTime - startTime,
+          message: response.message,
+        });
         throw response;
       }
       if (retriesRemaining) {
         loggerFor(this).info(
           `[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - ${retryMessage}`,
         );
-        loggerFor(this).debug(
+        debugLogRequestDetails(
+          loggerFor(this),
           `[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (${retryMessage})`,
-          formatRequestDetails({
+          {
             retryOfRequestLogID,
             url,
             durationMs: headersTime - startTime,
             message: response.message,
-          }),
+          },
         );
         return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID);
       }
       loggerFor(this).info(
         `[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - error; no more retries left`,
       );
-      loggerFor(this).debug(
+      debugLogRequestDetails(
+        loggerFor(this),
         `[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (error; no more retries left)`,
-        formatRequestDetails({
+        {
           retryOfRequestLogID,
           url,
           durationMs: headersTime - startTime,
           message: response.message,
-        }),
+        },
       );
       if (isTimeout) {
         throw new Errors.APIConnectionTimeoutError();
@@ -1232,16 +1244,13 @@ export class BaseAnthropic {
         await Shims.CancelReadableStream(response.body);
         releaseRequestSignal(controller);
         loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
-        loggerFor(this).debug(
-          `[${requestLogID}] response error (${retryMessage})`,
-          formatRequestDetails({
-            retryOfRequestLogID,
-            url: response.url,
-            status: response.status,
-            headers: response.headers,
-            durationMs: headersTime - startTime,
-          }),
-        );
+        debugLogRequestDetails(loggerFor(this), `[${requestLogID}] response error (${retryMessage})`, {
+          retryOfRequestLogID,
+          url: response.url,
+          status: response.status,
+          headers: response.headers,
+          durationMs: headersTime - startTime,
+        });
         return this.retryRequest(
           options,
           retriesRemaining,
@@ -1258,17 +1267,14 @@ export class BaseAnthropic {
       const errJSON = safeJSON(errText) as any;
       const errMessage = errJSON ? undefined : errText;
 
-      loggerFor(this).debug(
-        `[${requestLogID}] response error (${retryMessage})`,
-        formatRequestDetails({
-          retryOfRequestLogID,
-          url: response.url,
-          status: response.status,
-          headers: response.headers,
-          message: errMessage,
-          durationMs: Date.now() - startTime,
-        }),
-      );
+      debugLogRequestDetails(loggerFor(this), `[${requestLogID}] response error (${retryMessage})`, {
+        retryOfRequestLogID,
+        url: response.url,
+        status: response.status,
+        headers: response.headers,
+        message: errMessage,
+        durationMs: Date.now() - startTime,
+      });
 
       releaseRequestSignal(controller);
       const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
@@ -1276,16 +1282,13 @@ export class BaseAnthropic {
     }
 
     loggerFor(this).info(responseInfo);
-    loggerFor(this).debug(
-      `[${requestLogID}] response start`,
-      formatRequestDetails({
-        retryOfRequestLogID,
-        url: response.url,
-        status: response.status,
-        headers: response.headers,
-        durationMs: headersTime - startTime,
-      }),
-    );
+    debugLogRequestDetails(loggerFor(this), `[${requestLogID}] response start`, {
+      retryOfRequestLogID,
+      url: response.url,
+      status: response.status,
+      headers: response.headers,
+      durationMs: headersTime - startTime,
+    });
 
     armAbandonmentBackstop(response.body ?? response, controller);
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
@@ -1384,16 +1387,13 @@ export class BaseAnthropic {
           await this.prepareRequest(innerInit, { url: innerUrlStr, options: requestOptions });
 
           if (logCtx) {
-            loggerFor(this).debug(
-              `[${logCtx.requestLogID}] sending request`,
-              formatRequestDetails({
-                retryOfRequestLogID: logCtx.retryOfRequestLogID,
-                method: innerInit.method,
-                url: innerUrlStr,
-                options: requestOptions,
-                headers: innerInit.headers,
-              }),
-            );
+            debugLogRequestDetails(loggerFor(this), `[${logCtx.requestLogID}] sending request`, {
+              retryOfRequestLogID: logCtx.retryOfRequestLogID,
+              method: innerInit.method,
+              url: innerUrlStr,
+              options: requestOptions,
+              headers: innerInit.headers,
+            });
           }
 
           return timedFetch(innerUrl, innerInit);
@@ -1484,7 +1484,7 @@ export class BaseAnthropic {
       const maxRetries = options.maxRetries ?? this.maxRetries;
       timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
     }
-    await sleep(timeoutMillis);
+    await sleep(timeoutMillis, options.signal ?? undefined);
 
     return this.makeRequest(options, retriesRemaining - 1, requestLogID);
   }
@@ -1622,11 +1622,7 @@ export class BaseAnthropic {
       ((globalThis as any).ReadableStream && body instanceof (globalThis as any).ReadableStream)
     ) {
       return { bodyHeaders: undefined, body: body as BodyInit };
-    } else if (
-      typeof body === 'object' &&
-      (Symbol.asyncIterator in body ||
-        (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))
-    ) {
+    } else if (this.isStreamBody(body)) {
       return { bodyHeaders: undefined, body: Shims.ReadableStreamFrom(body as AsyncIterable<Uint8Array>) };
     } else if (
       typeof body === 'object' &&
@@ -1641,6 +1637,22 @@ export class BaseAnthropic {
     }
   }
 
+  /**
+   * Whether `body` is sent as a stream, which can be read only once:
+   * a `ReadableStream`, an async iterable or an iterator.
+   */
+  private isStreamBody(body: unknown): boolean {
+    if ((globalThis as any).ReadableStream && body instanceof (globalThis as any).ReadableStream) {
+      return true;
+    }
+    return (
+      typeof body === 'object' &&
+      body !== null &&
+      (Symbol.asyncIterator in body ||
+        (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))
+    );
+  }
+
   static Anthropic = this;
   static HUMAN_PROMPT = HUMAN_PROMPT;
   static AI_PROMPT = AI_PROMPT;
@@ -1688,17 +1700,22 @@ export declare namespace Anthropic {
 
   export type { ApiKeySetter };
 
-  export import Page = Pagination.Page;
-  export { type PageParams as PageParams, type PageResponse as PageResponse };
+  export { type Page as Page, type PageParams as PageParams, type PageResponse as PageResponse };
 
-  export import TokenPage = Pagination.TokenPage;
-  export { type TokenPageParams as TokenPageParams, type TokenPageResponse as TokenPageResponse };
+  export {
+    type TokenPage as TokenPage,
+    type TokenPageParams as TokenPageParams,
+    type TokenPageResponse as TokenPageResponse,
+  };
 
-  export import PageCursor = Pagination.PageCursor;
-  export { type PageCursorParams as PageCursorParams, type PageCursorResponse as PageCursorResponse };
+  export {
+    type PageCursor as PageCursor,
+    type PageCursorParams as PageCursorParams,
+    type PageCursorResponse as PageCursorResponse,
+  };
 
-  export import BidirectionalPageCursor = Pagination.BidirectionalPageCursor;
   export {
+    type BidirectionalPageCursor as BidirectionalPageCursor,
     type BidirectionalPageCursorParams as BidirectionalPageCursorParams,
     type BidirectionalPageCursorResponse as BidirectionalPageCursorResponse,
   };
@@ -1935,6 +1952,12 @@ export declare namespace Anthropic {
     type WebFetchToolResultErrorBlock as WebFetchToolResultErrorBlock,
     type WebFetchToolResultErrorBlockParam as WebFetchToolResultErrorBlockParam,
     type WebFetchToolResultErrorCode as WebFetchToolResultErrorCode,
+    type WebFetchURLSourceAll as WebFetchURLSourceAll,
+    type WebFetchURLSourceExcept as WebFetchURLSourceExcept,
+    type WebFetchURLSourceNone as WebFetchURLSourceNone,
+    type WebFetchURLSourceOnly as WebFetchURLSourceOnly,
+    type WebFetchURLSourceToolReference as WebFetchURLSourceToolReference,
+    type WebFetchURLSources as WebFetchURLSources,
     type WebSearchResultBlock as WebSearchResultBlock,
     type WebSearchResultBlockParam as WebSearchResultBlockParam,
     type WebSearchTool20250305 as WebSearchTool20250305,

package/src/internal/node.browser.ts

@@ -13,10 +13,10 @@ function unavailable<T extends object>(module: string): T {
   });
 }
 
-export const child_process: typeof node.child_process = unavailable('child_process');
-export const crypto: typeof node.crypto = unavailable('crypto');
-export const fs: typeof node.fs = unavailable('fs');
-export const os: typeof node.os = unavailable('os');
-export const path: typeof node.path = unavailable('path');
-export const stream: typeof node.stream = unavailable('stream');
-export const util: typeof node.util = unavailable('util');
+export const child_process: typeof node.child_process = /* @__PURE__ */ unavailable('child_process');
+export const crypto: typeof node.crypto = /* @__PURE__ */ unavailable('crypto');
+export const fs: typeof node.fs = /* @__PURE__ */ unavailable('fs');
+export const os: typeof node.os = /* @__PURE__ */ unavailable('os');
+export const path: typeof node.path = /* @__PURE__ */ unavailable('path');
+export const stream: typeof node.stream = /* @__PURE__ */ unavailable('stream');
+export const util: typeof node.util = /* @__PURE__ */ unavailable('util');

package/src/internal/parse.ts

@@ -1,7 +1,7 @@
 import type { FinalRequestOptions } from './request-options';
 import { Stream } from '../core/streaming';
 import { type BaseAnthropic } from '../client';
-import { formatRequestDetails, loggerFor } from './utils/log';
+import { debugLogRequestDetails, loggerFor } from './utils/log';
 import { releaseRequestSignal } from './request-signal';
 import type { AbstractPage } from '../core/pagination';
 
@@ -63,16 +63,13 @@ export async function defaultParseResponse<T>(
       releaseRequestSignal(props.controller);
     }
   });
-  loggerFor(client).debug(
-    `[${requestLogID}] response parsed`,
-    formatRequestDetails({
-      retryOfRequestLogID,
-      url: response.url,
-      status: response.status,
-      body,
-      durationMs: Date.now() - startTime,
-    }),
-  );
+  debugLogRequestDetails(loggerFor(client), `[${requestLogID}] response parsed`, {
+    retryOfRequestLogID,
+    url: response.url,
+    status: response.status,
+    body,
+    durationMs: Date.now() - startTime,
+  });
   return body;
 }
 

package/src/internal/shims.ts

@@ -6,7 +6,7 @@
  */
 
 import type { Fetch } from './builtin-types';
-import type { ReadableStream } from './shim-types';
+import type { ReadableStream as ReadableStreamType } from './shim-types';
 
 export function getDefaultFetch(): Fetch {
   if (typeof fetch !== 'undefined') {
@@ -18,9 +18,10 @@ export function getDefaultFetch(): Fetch {
   );
 }
 
+// The runtime's global ReadableStream constructor, not the type imported above as ReadableStreamType.
 type ReadableStreamArgs = ConstructorParameters<typeof ReadableStream>;
 
-export function makeReadableStream(...args: ReadableStreamArgs): ReadableStream {
+export function makeReadableStream(...args: ReadableStreamArgs): ReadableStreamType {
   const ReadableStream = (globalThis as any).ReadableStream;
   if (typeof ReadableStream === 'undefined') {
     // Note: All of the platforms / runtimes we officially support already define
@@ -33,7 +34,7 @@ export function makeReadableStream(...args: ReadableStreamArgs): ReadableStream
   return new ReadableStream(...args);
 }
 
-export function ReadableStreamFrom<T>(iterable: Iterable<T> | AsyncIterable<T>): ReadableStream<T> {
+export function ReadableStreamFrom<T>(iterable: Iterable<T> | AsyncIterable<T>): ReadableStreamType<T> {
   let iter: AsyncIterator<T> | Iterator<T> =
     Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
 

package/src/internal/utils/bytes.ts

@@ -14,7 +14,7 @@ export function concatBytes(buffers: Uint8Array[]): Uint8Array {
 }
 
 let encodeUTF8_: (str: string) => Uint8Array;
-export function encodeUTF8(str: string) {
+export function encodeUTF8(str: string): Uint8Array {
   let encoder;
   return (
     encodeUTF8_ ??

package/src/internal/utils/log.ts

@@ -112,7 +112,7 @@ export function defaultLogger(): Logger {
   return cachedDefaultLogger;
 }
 
-export const formatRequestDetails = (details: {
+type RequestDetails = {
   options?: RequestOptions | undefined;
   headers?: Headers | Record<string, string> | undefined;
   retryOfRequestLogID?: string | undefined;
@@ -123,7 +123,21 @@ export const formatRequestDetails = (details: {
   durationMs?: number | undefined;
   message?: unknown;
   body?: unknown;
-}) => {
+};
+
+/**
+ * Logs `details` at debug level. Formatting copies headers and options, so it
+ * runs only when debug logging is enabled.
+ */
+export function debugLogRequestDetails(logger: Logger, message: string, details: RequestDetails): void {
+  // `loggerFor` filters disabled levels to `noop`.
+  if (logger.debug === noop) {
+    return;
+  }
+  logger.debug(message, formatRequestDetails(details));
+}
+
+export const formatRequestDetails = (details: RequestDetails) => {
   if (details.options) {
     details.options = { ...details.options };
     delete details.options['headers']; // redundant + leaks internals

package/src/lib/BetaMessageStream.ts

@@ -695,11 +695,13 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
           }
           case 'compaction_delta': {
             if (snapshotContent?.type === 'compaction') {
-              snapshot.content[event.index] = {
-                ...snapshotContent,
-                content: (snapshotContent.content || '') + event.delta.content,
-                encrypted_content: event.delta.encrypted_content,
-              };
+              // The delta carries the block's final value (null content = failed compaction), so assign.
+              const block = { ...snapshotContent, content: event.delta.content };
+              // beta-gated key: only copy it when the server sent it
+              if ('encrypted_content' in event.delta) {
+                block.encrypted_content = event.delta.encrypted_content;
+              }
+              snapshot.content[event.index] = block;
             }
             break;
           }

package/src/lib/beta-parser.ts

@@ -8,9 +8,7 @@ import {
   BetaTextBlock,
   MessageCreateParams,
 } from '../resources/beta/messages/messages';
-
-// vendored from typefest just to make things look a bit nicer on hover
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+import type { Simplify } from './internal/types';
 
 type AutoParseableBetaOutputConfig = Omit<BetaOutputConfig, 'format'> & {
   format?: BetaJSONOutputFormat | AutoParseableBetaOutputFormat<any> | null;

package/src/lib/internal/stub.ts

@@ -0,0 +1,2 @@
+// placeholder so the build has a `lib/internal` module to check the exports map against
+export const stub = true;

package/src/lib/internal/types.ts

@@ -0,0 +1,2 @@
+/** Flattens an intersection type so it reads better on hover; vendored from type-fest. */
+export type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};

package/src/lib/middleware.ts

@@ -895,6 +895,11 @@ function applyDelta(
       break;
     }
     case 'compaction_delta': {
+      // The delta carries the block's final value; the start event is only a null-content shell.
+      block.content = delta.content;
+      if ('encrypted_content' in delta) {
+        block.encrypted_content = delta.encrypted_content;
+      }
       break;
     }
     default:
@@ -933,8 +938,8 @@ function withMiddlewareHeaders(request: APIRequest, betas: readonly AnthropicBet
   );
   for (const beta of betas) {
     if (!existing.has(beta)) {
-      headers.append('anthropic-beta', beta);
       existing.add(beta);
+      headers.set('anthropic-beta', [...existing].join(','));
     }
   }
   headers.set(

package/src/lib/parser.ts

@@ -8,9 +8,7 @@ import {
   TextBlock,
   MessageCreateParams,
 } from '../resources/messages/messages';
-
-// vendored from typefest just to make things look a bit nicer on hover
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+import type { Simplify } from './internal/types';
 
 type AutoParseableOutputConfig = Omit<OutputConfig, 'format'> & {
   format?: JSONOutputFormat | AutoParseableOutputFormat<any> | null;