@anthropic-ai/sdk 0.40.1 → 0.50.1

package/src/internal/utils/log.ts

@@ -0,0 +1,127 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { hasOwn } from './values';
+import { type BaseAnthropic } from '../../client';
+import { RequestOptions } from '../request-options';
+
+type LogFn = (message: string, ...rest: unknown[]) => void;
+export type Logger = {
+  error: LogFn;
+  warn: LogFn;
+  info: LogFn;
+  debug: LogFn;
+};
+export type LogLevel = 'off' | 'error' | 'warn' | 'info' | 'debug';
+
+const levelNumbers = {
+  off: 0,
+  error: 200,
+  warn: 300,
+  info: 400,
+  debug: 500,
+};
+
+export const parseLogLevel = (
+  maybeLevel: string | undefined,
+  sourceName: string,
+  client: BaseAnthropic,
+): LogLevel | undefined => {
+  if (!maybeLevel) {
+    return undefined;
+  }
+  if (hasOwn(levelNumbers, maybeLevel)) {
+    return maybeLevel;
+  }
+  loggerFor(client).warn(
+    `${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(
+      Object.keys(levelNumbers),
+    )}`,
+  );
+  return undefined;
+};
+
+function noop() {}
+
+function makeLogFn(fnLevel: keyof Logger, logger: Logger | undefined, logLevel: LogLevel) {
+  if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) {
+    return noop;
+  } else {
+    // Don't wrap logger functions, we want the stacktrace intact!
+    return logger[fnLevel].bind(logger);
+  }
+}
+
+const noopLogger = {
+  error: noop,
+  warn: noop,
+  info: noop,
+  debug: noop,
+};
+
+let cachedLoggers = new WeakMap<Logger, [LogLevel, Logger]>();
+
+export function loggerFor(client: BaseAnthropic): Logger {
+  const logger = client.logger;
+  const logLevel = client.logLevel ?? 'off';
+  if (!logger) {
+    return noopLogger;
+  }
+
+  const cachedLogger = cachedLoggers.get(logger);
+  if (cachedLogger && cachedLogger[0] === logLevel) {
+    return cachedLogger[1];
+  }
+
+  const levelLogger = {
+    error: makeLogFn('error', logger, logLevel),
+    warn: makeLogFn('warn', logger, logLevel),
+    info: makeLogFn('info', logger, logLevel),
+    debug: makeLogFn('debug', logger, logLevel),
+  };
+
+  cachedLoggers.set(logger, [logLevel, levelLogger]);
+
+  return levelLogger;
+}
+
+export const formatRequestDetails = (details: {
+  options?: RequestOptions | undefined;
+  headers?: Headers | Record<string, string> | undefined;
+  retryOfRequestLogID?: string | undefined;
+  retryOf?: string | undefined;
+  url?: string | undefined;
+  status?: number | undefined;
+  method?: string | undefined;
+  durationMs?: number | undefined;
+  message?: unknown;
+  body?: unknown;
+}) => {
+  if (details.options) {
+    details.options = { ...details.options };
+    delete details.options['headers']; // redundant + leaks internals
+  }
+  if (details.headers) {
+    details.headers = Object.fromEntries(
+      (details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(
+        ([name, value]) => [
+          name,
+          (
+            name.toLowerCase() === 'x-api-key' ||
+            name.toLowerCase() === 'authorization' ||
+            name.toLowerCase() === 'cookie' ||
+            name.toLowerCase() === 'set-cookie'
+          ) ?
+            '***'
+          : value,
+        ],
+      ),
+    );
+  }
+  if ('retryOfRequestLogID' in details) {
+    if (details.retryOfRequestLogID) {
+      details.retryOf = details.retryOfRequestLogID;
+    }
+    delete details.retryOfRequestLogID;
+  }
+  return details;
+};

package/src/internal/utils/path.ts

@@ -0,0 +1,65 @@
+import { AnthropicError } from '../../core/error';
+
+/**
+ * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
+ *
+ * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3:
+ * > unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * > sub-delims  = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ * > pchar       = unreserved / pct-encoded / sub-delims / ":" / "@"
+ */
+export function encodeURIPath(str: string) {
+  return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
+}
+
+export const createPathTagFunction = (pathEncoder = encodeURIPath) =>
+  function path(statics: readonly string[], ...params: readonly unknown[]): string {
+    // If there are no params, no processing is needed.
+    if (statics.length === 1) return statics[0]!;
+
+    let postPath = false;
+    const path = statics.reduce((previousValue, currentValue, index) => {
+      if (/[?#]/.test(currentValue)) {
+        postPath = true;
+      }
+      return (
+        previousValue +
+        currentValue +
+        (index === params.length ? '' : (postPath ? encodeURIComponent : pathEncoder)(String(params[index])))
+      );
+    }, '');
+
+    const pathOnly = path.split(/[?#]/, 1)[0]!;
+    const invalidSegments = [];
+    const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
+    let match;
+
+    // Find all invalid segments
+    while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
+      invalidSegments.push({
+        start: match.index,
+        length: match[0].length,
+      });
+    }
+
+    if (invalidSegments.length > 0) {
+      let lastEnd = 0;
+      const underline = invalidSegments.reduce((acc, segment) => {
+        const spaces = ' '.repeat(segment.start - lastEnd);
+        const arrows = '^'.repeat(segment.length);
+        lastEnd = segment.start + segment.length;
+        return acc + spaces + arrows;
+      }, '');
+
+      throw new AnthropicError(
+        `Path parameters result in path with invalid segments:\n${path}\n${underline}`,
+      );
+    }
+
+    return path;
+  };
+
+/**
+ * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced.
+ */
+export const path = createPathTagFunction(encodeURIPath);

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<void>((resolve) => setTimeout(resolve, ms));

package/src/internal/utils/uuid.ts

@@ -0,0 +1,17 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+export let uuid4 = function () {
+  const { crypto } = globalThis as any;
+  if (crypto?.randomUUID) {
+    uuid4 = crypto.randomUUID.bind(crypto);
+    return crypto.randomUUID();
+  }
+  const u8 = new Uint8Array(1);
+  const randomByte = crypto ? () => crypto.getRandomValues(u8)[0]! : () => (Math.random() * 0xff) & 0xff;
+  return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) =>
+    (+c ^ (randomByte() & (15 >> (+c / 4)))).toString(16),
+  );
+};

package/src/internal/utils/values.ts

@@ -0,0 +1,102 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { AnthropicError } from '../../core/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<T extends object = object>(obj: T, key: PropertyKey): key is keyof T {
+  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);
+};
+
+export const safeJSON = (text: string) => {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return undefined;
+  }
+};

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/BetaMessageStream.ts

@@ -1,5 +1,5 @@
-import * as Core from "../core.js";
-import { AnthropicError, APIUserAbortError } from "../error.js";
+import { isAbortError } from '../internal/errors';
+import { AnthropicError, APIUserAbortError } from '../error';
 import {
   type BetaContentBlock,
   Messages as BetaMessages,
@@ -10,10 +10,11 @@ import {
   type MessageCreateParamsBase as BetaMessageCreateParamsBase,
   type BetaTextBlock,
   type BetaTextCitation,
-} from "../resources/beta/messages/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";
+} from '../resources/beta/messages/messages';
+import { Stream } from '../streaming';
+import { partialParse } from '../_vendor/partial-json-parser/parser';
+import { type RequestOptions } from '../internal/request-options';
+import { type ReadableStream } from '../internal/shim-types';
 
 export interface MessageStreamEvents {
   connect: () => void;
@@ -132,7 +133,7 @@ export class BetaMessageStream implements AsyncIterable<BetaMessageStreamEvent>
   static createMessage(
     messages: BetaMessages,
     params: BetaMessageCreateParamsBase,
-    options?: Core.RequestOptions,
+    options?: RequestOptions,
   ): BetaMessageStream {
     const runner = new BetaMessageStream();
     for (const message of params.messages) {
@@ -169,7 +170,7 @@ export class BetaMessageStream implements AsyncIterable<BetaMessageStreamEvent>
   protected async _createMessage(
     messages: BetaMessages,
     params: BetaMessageCreateParams,
-    options?: Core.RequestOptions,
+    options?: RequestOptions,
   ): Promise<void> {
     const signal = options?.signal;
     if (signal) {
@@ -331,7 +332,7 @@ export class BetaMessageStream implements AsyncIterable<BetaMessageStreamEvent>
 
   #handleError = (error: unknown) => {
     this.#errored = true;
-    if (error instanceof Error && error.name === 'AbortError') {
+    if (isAbortError(error)) {
       error = new APIUserAbortError();
     }
     if (error instanceof APIUserAbortError) {
@@ -485,7 +486,7 @@ export class BetaMessageStream implements AsyncIterable<BetaMessageStreamEvent>
 
   protected async _fromReadableStream(
     readableStream: ReadableStream,
-    options?: Core.RequestOptions,
+    options?: RequestOptions,
   ): Promise<void> {
     const signal = options?.signal;
     if (signal) {
@@ -530,6 +531,15 @@ export class BetaMessageStream implements AsyncIterable<BetaMessageStreamEvent>
         snapshot.stop_reason = event.delta.stop_reason;
         snapshot.stop_sequence = event.delta.stop_sequence;
         snapshot.usage.output_tokens = event.usage.output_tokens;
+
+        // Update other usage fields if they exist in the event
+        if (event.usage.input_tokens) {
+          snapshot.usage.input_tokens = event.usage.input_tokens;
+        }
+        snapshot.usage.cache_creation_input_tokens = event.usage.cache_creation_input_tokens;
+        snapshot.usage.cache_read_input_tokens = event.usage.cache_read_input_tokens;
+        snapshot.usage.server_tool_use = event.usage.server_tool_use;
+
         return snapshot;
       case 'content_block_start':
         snapshot.content.push(event.content_block);

package/src/lib/MessageStream.ts

@@ -1,5 +1,5 @@
-import * as Core from "../core.js";
-import { AnthropicError, APIUserAbortError } from "../error.js";
+import { isAbortError } from '../internal/errors';
+import { AnthropicError, APIUserAbortError } from '../error';
 import {
   type ContentBlock,
   Messages,
@@ -10,10 +10,11 @@ import {
   type MessageCreateParamsBase,
   type TextBlock,
   type TextCitation,
-} 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";
+} 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;
@@ -132,7 +133,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) {
@@ -169,7 +170,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) {
@@ -331,7 +332,7 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
 
   #handleError = (error: unknown) => {
     this.#errored = true;
-    if (error instanceof Error && error.name === 'AbortError') {
+    if (isAbortError(error)) {
       error = new APIUserAbortError();
     }
     if (error instanceof APIUserAbortError) {
@@ -485,7 +486,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) {
@@ -530,6 +531,15 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
         snapshot.stop_reason = event.delta.stop_reason;
         snapshot.stop_sequence = event.delta.stop_sequence;
         snapshot.usage.output_tokens = event.usage.output_tokens;
+
+        // Update other usage fields if they exist in the event
+        if (event.usage.input_tokens) {
+          snapshot.usage.input_tokens = event.usage.input_tokens;
+        }
+        snapshot.usage.cache_creation_input_tokens = event.usage.cache_creation_input_tokens;
+        snapshot.usage.cache_read_input_tokens = event.usage.cache_read_input_tokens;
+        snapshot.usage.server_tool_use = event.usage.server_tool_use;
+
         return snapshot;
       case 'content_block_start':
         snapshot.content.push(event.content_block);

package/src/pagination.ts

@@ -1,92 +1,2 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-import { AbstractPage, Response, APIClient, FinalRequestOptions, PageInfo } from "./core.js";
-
-export interface PageResponse<Item> {
-  data: Array<Item>;
-
-  has_more: boolean;
-
-  first_id: string | null;
-
-  last_id: string | null;
-}
-
-export interface PageParams {
-  /**
-   * Number of items per page.
-   */
-  limit?: number;
-
-  before_id?: string;
-
-  after_id?: string;
-}
-
-export class Page<Item> extends AbstractPage<Item> implements PageResponse<Item> {
-  data: Array<Item>;
-
-  has_more: boolean;
-
-  first_id: string | null;
-
-  last_id: string | null;
-
-  constructor(client: APIClient, response: Response, body: PageResponse<Item>, options: FinalRequestOptions) {
-    super(client, response, body, options);
-
-    this.data = body.data || [];
-    this.has_more = body.has_more || false;
-    this.first_id = body.first_id || null;
-    this.last_id = body.last_id || null;
-  }
-
-  getPaginatedItems(): Item[] {
-    return this.data ?? [];
-  }
-
-  override hasNextPage(): boolean {
-    if (this.has_more === false) {
-      return false;
-    }
-
-    return super.hasNextPage();
-  }
-
-  // @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 firstId = this.first_id;
-      if (!firstId) {
-        return null;
-      }
-
-      return {
-        params: {
-          before_id: firstId,
-        },
-      };
-    }
-
-    const cursor = this.last_id;
-    if (!cursor) {
-      return null;
-    }
-
-    return {
-      params: {
-        after_id: cursor,
-      },
-    };
-  }
-}
+/** @deprecated Import from ./core/pagination instead */
+export * from './core/pagination';

package/src/resource.ts

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