claude-flow 2.0.0-alpha.7 → 2.0.0-alpha.71

package/src/ui/extension/node_modules/@anthropic-ai/sdk/src/core.ts

@@ -27,66 +27,50 @@ export {
   createForm,
   type Uploadable,
 } from './uploads.js';
-
 export type Fetch = (url: RequestInfo, init?: RequestInit) => Promise<Response>;
-
 type PromiseOrValue<T> = T | Promise<T>;
-
 type APIResponseProps = {
   response: Response;
   options: FinalRequestOptions;
   controller: AbortController;
 };
-
 async function defaultParseResponse<T>(props: APIResponseProps): Promise<T> {
   const { response } = props;
   if (props.options.stream) {
 constructor('response', response.status, response.url, response.headers, response.body);
-
     // Note: there is an invariant here that isn't represented in the type system
     // that if you set `stream: true` the response type must also be `Stream<T>`
-
     if (props.options.__streamClass) {
       return props.options.__streamClass.fromSSEResponse(response, props.controller) as any;
     }
-
     return Stream.fromSSEResponse(response, props.controller) as any;
   }
-
   // fetch refuses to read the body when the status code is 204.
   if (response.status === 204) {
     return null as T;
   }
-
   if (props.options.__binaryResponse) {
     return response as unknown as T;
   }
-
   const contentType = response.headers.get('content-type');
   const isJSON =
     contentType?.includes('application/json') || contentType?.includes('application/vnd.api+json');
   if (isJSON) {
     const json = await response.json();
-
 constructor('response', response.status, response.url, response.headers, json);
-
     return json as T;
   }
-
   const text = await response.text();
 constructor('response', response.status, response.url, response.headers, text);
-
   // TODO handle blob, arraybuffer, other content types, etc.
   return text as unknown as T;
 }
-
 /**
  * A subclass of `Promise` providing additional helper methods
  * for interacting with the SDK.
  */
 export class APIPromise<T> extends Promise<T> {
   private parsedPromise: Promise<T> | undefined;
-
 constructor(
     private responsePromise: Promise<APIResponseProps>,
     private parseResponse: (props: APIResponseProps) => PromiseOrValue<T> = defaultParseResponse,
@@ -98,11 +82,9 @@ constructor((resolve) => {
 constructor(null as any);
     });
   }
-
   _thenUnwrap<U>(transform: (data: T) => U): APIPromise<U> {
     return new APIPromise(this.responsePromise, async (props) => transform(await this.parseResponse(props)));
   }
-
   /**
    * Gets the raw `Response` instance instead of parsing the response
    * data.
@@ -136,41 +118,34 @@ constructor(): Promise<{ data: T; response: Response }> {
     const [data, response] = await Promise.all([this.parse(), this.asResponse()]);
     return { data, response };
   }
-
   private parse(): Promise<T> {
     if (!this.parsedPromise) {
       this.parsedPromise = this.responsePromise.then(this.parseResponse);
     }
     return this.parsedPromise;
   }
-
   override then<TResult1 = T, TResult2 = never>(
     onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
     onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null,
   ): Promise<TResult1 | TResult2> {
     return this.parse().then(onfulfilled, onrejected);
   }
-
   override catch<TResult = never>(
     onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null,
   ): Promise<T | TResult> {
     return this.parse().catch(onrejected);
   }
-
   override finally(onfinally?: (() => void) | undefined | null): Promise<T> {
     return this.parse().finally(onfinally);
   }
 }
-
 export abstract class APIClient {
   baseURL: string;
   maxRetries: number;
   timeout: number;
   httpAgent: Agent | undefined;
-
   private fetch: Fetch;
   protected idempotencyHeader?: string;
-
 constructor({
     baseURL,
     maxRetries = 2,
@@ -188,14 +163,11 @@ constructor({
     this.maxRetries = validatePositiveInteger('maxRetries', maxRetries);
     this.timeout = validatePositiveInteger('timeout', timeout);
     this.httpAgent = httpAgent;
-
     this.fetch = overridenFetch ?? fetch;
   }
-
   protected authHeaders(opts: FinalRequestOptions): Headers {
     return {};
   }
-
   /**
    * Override this to add your own default headers, for example:
    *
@@ -213,38 +185,29 @@ constructor({
       ...this.authHeaders(opts),
     };
   }
-
   protected abstract defaultQuery(): DefaultQuery | undefined;
-
   /**
    * Override this to add your own headers validation:
    */
   protected validateHeaders(headers: Headers, customHeaders: Headers) {}
-
   protected defaultIdempotencyKey(): string {
     return `stainless-node-retry-${uuid4()}`;
   }
-
   get<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp> {
     return this.methodRequest('get', path, opts);
   }
-
   post<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp> {
     return this.methodRequest('post', path, opts);
   }
-
   patch<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp> {
     return this.methodRequest('patch', path, opts);
   }
-
   put<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp> {
     return this.methodRequest('put', path, opts);
   }
-
   delete<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp> {
     return this.methodRequest('delete', path, opts);
   }
-
   private methodRequest<Req, Rsp>(
     method: HTTPMethod,
     path: string,
@@ -252,7 +215,6 @@ constructor({
   ): APIPromise<Rsp> {
     return this.request(Promise.resolve(opts).then((opts) => ({ method, path, ...opts })));
   }
-
   getAPIList<Item, PageClass extends AbstractPage<Item> = AbstractPage<Item>>(
     path: string,
     Page: new (...args: any[]) => PageClass,
@@ -260,32 +222,26 @@ constructor({
   ): PagePromise<PageClass, Item> {
     return this.requestAPIList(Page, { method: 'get', path, ...opts });
   }
-
   private calculateContentLength(body: unknown): string | null {
     if (typeof body === 'string') {
       if (typeof Buffer !== 'undefined') {
         return Buffer.byteLength(body, 'utf8').toString();
       }
-
       if (typeof TextEncoder !== 'undefined') {
         const encoder = new TextEncoder();
         const encoded = encoder.encode(body);
         return encoded.length.toString();
       }
     }
-
     return null;
   }
-
   buildRequest<Req>(options: FinalRequestOptions<Req>): { req: RequestInit; url: string; timeout: number } {
     const { method, path, query, headers: headers = {} } = options;
-
     const body =
 constructor(options.body) ? options.body.body
       : options.body ? JSON.stringify(options.body, null, 2)
       : null;
     const contentLength = this.calculateContentLength(body);
-
     const url = this.buildURL(path!, query);
     if ('timeout' in options) validatePositiveInteger('timeout', options.timeout);
     const timeout = options.timeout ?? this.timeout;
@@ -301,14 +257,11 @@ constructor(options.body) ? options.body.body
       // This tradeoff optimizes for performance.
       (httpAgent as any).options.timeout = minAgentTimeout;
     }
-
     if (this.idempotencyHeader && method !== 'get') {
       if (!options.idempotencyKey) options.idempotencyKey = this.defaultIdempotencyKey();
       headers[this.idempotencyHeader] = options.idempotencyKey;
     }
-
     const reqHeaders = this.buildHeaders({ options, headers, contentLength });
-
     const req: RequestInit = {
       method,
       ...(body && { body: body as any }),
@@ -318,10 +271,8 @@ constructor(options.body) ? options.body.body
       // not compatible with standard web types
       signal: options.signal ?? null,
     };
-
     return { req, url, timeout };
   }
-
   private buildHeaders({
     options,
     headers,
@@ -335,26 +286,20 @@ constructor(options.body) ? options.body.body
     if (contentLength) {
       reqHeaders['content-length'] = contentLength;
     }
-
     const defaultHeaders = this.defaultHeaders(options);
 constructor(reqHeaders, defaultHeaders);
 constructor(reqHeaders, headers);
-
     // let builtin fetch set the Content-Type for multipart bodies
     if (isMultipartBody(options.body) && shimsKind !== 'node') {
       delete reqHeaders['content-type'];
     }
-
     this.validateHeaders(reqHeaders, headers);
-
     return reqHeaders;
   }
-
   /**
    * Used as a callback for mutating the given `FinalRequestOptions` object.
    */
   protected async prepareOptions(options: FinalRequestOptions): Promise<void> {}
-
   /**
    * Used as a callback for mutating the given `RequestInit` object.
    *
@@ -365,7 +310,6 @@ constructor(reqHeaders, headers);
     request: RequestInit,
     { url, options }: { url: string; options: FinalRequestOptions },
   ): Promise<void> {}
-
   protected parseHeaders(headers: HeadersInit | null | undefined): Record<string, string> {
     return (
       !headers ? {}
@@ -374,7 +318,6 @@ constructor(reqHeaders, headers);
       : { ...headers }
     );
   }
-
   protected makeStatusError(
     status: number | undefined,
     error: Object | undefined,
@@ -383,14 +326,12 @@ constructor(reqHeaders, headers);
   ) {
     return APIError.generate(status, error, message, headers);
   }
-
   request<Req, Rsp>(
     options: PromiseOrValue<FinalRequestOptions<Req>>,
     remainingRetries: number | null = null,
   ): APIPromise<Rsp> {
     return new APIPromise(this.makeRequest(options, remainingRetries));
   }
-
   private async makeRequest<Req>(
     optionsInput: PromiseOrValue<FinalRequestOptions<Req>>,
     retriesRemaining: number | null,
@@ -399,22 +340,15 @@ constructor(reqHeaders, headers);
     if (retriesRemaining == null) {
       retriesRemaining = options.maxRetries ?? this.maxRetries;
     }
-
     await this.prepareOptions(options);
-
     const { req, url, timeout } = this.buildRequest(options);
-
     await this.prepareRequest(req, { url, options });
-
 constructor('request', url, options, req.headers);
-
     if (options.signal?.aborted) {
       throw new APIUserAbortError();
     }
-
     const controller = new AbortController();
     const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
-
     if (response instanceof Error) {
       if (options.signal?.aborted) {
         throw new APIUserAbortError();
@@ -427,30 +361,23 @@ constructor('request', url, options, req.headers);
       }
       throw new APIConnectionError({ cause: response });
     }
-
     const responseHeaders = createResponseHeaders(response.headers);
-
     if (!response.ok) {
       if (retriesRemaining && this.shouldRetry(response)) {
         const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
 constructor(`response (error; ${retryMessage})`, response.status, url, responseHeaders);
         return this.retryRequest(options, retriesRemaining, responseHeaders);
       }
-
       const errText = await response.text().catch((e) => castToError(e).message);
       const errJSON = safeJSON(errText);
       const errMessage = errJSON ? undefined : errText;
       const retryMessage = retriesRemaining ? `(error; no more retries left)` : `(error; not retryable)`;
-
 constructor(`response (error; ${retryMessage})`, response.status, url, responseHeaders, errMessage);
-
       const err = this.makeStatusError(response.status, errJSON, errMessage, responseHeaders);
       throw err;
     }
-
     return { response, options, controller };
   }
-
   requestAPIList<Item = unknown, PageClass extends AbstractPage<Item> = AbstractPage<Item>>(
     Page: new (...args: ConstructorParameters<typeof AbstractPage>) => PageClass,
     options: FinalRequestOptions,
@@ -458,25 +385,20 @@ constructor(`response (error; ${retryMessage})`, response.status, url, responseH
     const request = this.makeRequest(options, null);
     return new PagePromise<PageClass, Item>(this, request, Page);
   }
-
   buildURL<Req>(path: string, query: Req | null | undefined): string {
     const url =
 constructor(path) ?
         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 (typeof query === 'object' && query && !Array.isArray(query)) {
       url.search = this.stringifyQuery(query as Record<string, unknown>);
     }
-
     return url.toString();
   }
-
   protected stringifyQuery(query: Record<string, unknown>): string {
     return Object.entries(query)
       .filter(([_, value]) => typeof value !== 'undefined')
@@ -493,7 +415,6 @@ constructor(path) ?
       })
       .join('&');
   }
-
 constructor(
     url: RequestInfo,
     init: RequestInit | undefined,
@@ -502,9 +423,7 @@ constructor(
   ): Promise<Response> {
     const { signal, ...options } = init || {};
     if (signal) signal.addEventListener('abort', () => controller.abort());
-
     const timeout = setTimeout(() => controller.abort(), ms);
-
     return (
       this.getRequestClient()
         // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
@@ -514,41 +433,31 @@ constructor(timeout);
         })
     );
   }
-
   protected getRequestClient(): RequestClient {
     return { fetch: this.fetch };
   }
-
   private shouldRetry(response: Response): boolean {
     // Note this is not a standard header.
     const shouldRetryHeader = response.headers.get('x-should-retry');
-
     // If the server explicitly says whether or not to retry, obey.
     if (shouldRetryHeader === 'true') return true;
     if (shouldRetryHeader === 'false') return false;
-
     // Retry on request timeouts.
     if (response.status === 408) return true;
-
     // Retry on lock timeouts.
     if (response.status === 409) return true;
-
     // Retry on rate limits.
     if (response.status === 429) return true;
-
     // Retry internal errors.
     if (response.status >= 500) return true;
-
     return false;
   }
-
   private async retryRequest(
     options: FinalRequestOptions,
     retriesRemaining: number,
     responseHeaders?: Headers | undefined,
   ): Promise<APIResponseProps> {
-    let timeoutMillis: number | undefined;
-
+    let timeoutMillis: number | undefined; // TODO: Remove if unused
     // Note the `retry-after-ms` header may not be standard, but is a good idea and we'd like proactive support for it.
     const retryAfterMillisHeader = responseHeaders?.['retry-after-ms'];
     if (retryAfterMillisHeader) {
@@ -557,7 +466,6 @@ constructor(timeout);
         timeoutMillis = timeoutMs;
       }
     }
-
     // About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
     const retryAfterHeader = responseHeaders?.['retry-after'];
     if (retryAfterHeader && !timeoutMillis) {
@@ -568,7 +476,6 @@ constructor(timeout);
         timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
       }
     }
-
     // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
     // just do what it says, but otherwise calculate a default
     if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1000)) {
@@ -576,60 +483,45 @@ constructor(timeout);
       timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
     }
     await sleep(timeoutMillis);
-
     return this.makeRequest(options, retriesRemaining - 1);
   }
-
   private calculateDefaultRetryTimeoutMillis(retriesRemaining: number, maxRetries: number): number {
     const initialRetryDelay = 0.5;
     const maxRetryDelay = 8.0;
-
     const numRetries = maxRetries - retriesRemaining;
-
     // Apply exponential backoff, but not more than the max.
     const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay);
-
     // Apply some jitter, take up to at most 25 percent of the retry time.
     const jitter = 1 - Math.random() * 0.25;
-
     return sleepSeconds * jitter * 1000;
   }
-
   private getUserAgent(): string {
     return `${this.constructor.name}/JS ${VERSION}`;
   }
 }
-
 export type PageInfo = { url: URL } | { params: Record<string, unknown> | null };
-
 export abstract class AbstractPage<Item> implements AsyncIterable<Item> {
   #client: APIClient;
   protected options: FinalRequestOptions;
-
   protected response: Response;
   protected body: unknown;
-
 constructor(client: APIClient, response: Response, body: unknown, options: FinalRequestOptions) {
     this.#client = client;
     this.options = options;
     this.response = response;
     this.body = body;
   }
-
   /**
    * @deprecated Use nextPageInfo instead
    */
   abstract nextPageParams(): Partial<Record<string, unknown>> | null;
   abstract nextPageInfo(): PageInfo | null;
-
   abstract getPaginatedItems(): Item[];
-
 constructor(): boolean {
     const items = this.getPaginatedItems();
     if (!items.length) return false;
     return this.nextPageInfo() != null;
   }
-
 constructor(): Promise<this> {
     const nextInfo = this.nextPageInfo();
     if (!nextInfo) {
@@ -650,7 +542,6 @@ constructor(): Promise<this> {
     }
     return await this.#client.requestAPIList(this.constructor as any, nextOptions);
   }
-
   async *iterPages() {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     let page: AbstractPage<Item> = this;
@@ -660,7 +551,6 @@ constructor(): Promise<this> {
       yield page;
     }
   }
-
   async *[Symbol.asyncIterator]() {
     for await (const page of this.iterPages()) {
       for (const item of page.getPaginatedItems()) {
@@ -669,7 +559,6 @@ constructor(): Promise<this> {
     }
   }
 }
-
 /**
  * This subclass of Promise will resolve to an instantiated Page once the request completes.
  *
@@ -696,7 +585,6 @@ constructor(
       async (props) => new Page(client, props.response, await defaultParseResponse(props), props.options),
     );
   }
-
   /**
    * Allow auto-paginating iteration on an unawaited list call, eg:
    *
@@ -711,7 +599,6 @@ constructor(
     }
   }
 }
-
 export const createResponseHeaders = (
   headers: Awaited<ReturnType<Fetch>>['headers'],
 ): Record<string, string> => {
@@ -728,32 +615,26 @@ constructor(target, name) {
     },
   );
 };
-
 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 = unknown | Record<string, unknown> | Readable> = {
   method?: HTTPMethod;
   path?: string;
   query?: Req | undefined;
   body?: Req | null | undefined;
   headers?: Headers | undefined;
-
   maxRetries?: number;
   stream?: boolean | undefined;
   timeout?: number;
   httpAgent?: Agent;
   signal?: AbortSignal | undefined | null;
   idempotencyKey?: string;
-
   __binaryResponse?: boolean | undefined;
   __streamClass?: typeof Stream;
 };
-
 // This is required so that we can determine if a given object matches the RequestOptions
 // type at runtime. While this requires duplication, it is enforced by the TypeScript
 // compiler such that any missing / extraneous keys will cause an error.
@@ -763,18 +644,15 @@ const requestOptionsKeys: KeysEnum<RequestOptions> = {
   query: true,
   body: true,
   headers: true,
-
   maxRetries: true,
   stream: true,
   timeout: true,
   httpAgent: true,
   signal: true,
   idempotencyKey: true,
-
   __binaryResponse: true,
   __streamClass: true,
 };
-
 export const isRequestOptions = (obj: unknown): obj is RequestOptions => {
   return (
     typeof obj === 'object' &&
@@ -783,12 +661,10 @@ export const isRequestOptions = (obj: unknown): obj is RequestOptions => {
     Object.keys(obj).every((k) => hasOwn(requestOptionsKeys, k))
   );
 };
-
 export type FinalRequestOptions<Req = unknown | Record<string, unknown> | Readable> = RequestOptions<Req> & {
   method: HTTPMethod;
   path: string;
 };
-
 declare const Deno: any;
 declare const EdgeRuntime: any;
 type Arch = 'x32' | 'x64' | 'arm' | 'arm64' | `other:${string}` | 'unknown';
@@ -844,7 +720,6 @@ const getPlatformProperties = (): PlatformProperties => {
       'X-Stainless-Runtime-Version': process.version,
     };
   }
-
   const browserInfo = getBrowserInfo();
   if (browserInfo) {
     return {
@@ -856,7 +731,6 @@ const getPlatformProperties = (): PlatformProperties => {
       'X-Stainless-Runtime-Version': browserInfo.version,
     };
   }
-
   // TODO add support for Cloudflare workers, etc.
   return {
     'X-Stainless-Lang': 'js',
@@ -867,20 +741,16 @@ const getPlatformProperties = (): PlatformProperties => {
     'X-Stainless-Runtime-Version': 'unknown',
   };
 };
-
 type BrowserInfo = {
   browser: Browser;
   version: string;
 };
-
 declare const navigator: { userAgent: string } | undefined;
-
 // Note: modified from https://github.com/JS-DevTools/host-environment/blob/b1ab79ecde37db5d6e163c050e54fe7d287d7c92/src/isomorphic.browser.ts
 function getBrowserInfo(): BrowserInfo | null {
   if (typeof navigator === 'undefined' || !navigator) {
     return null;
   }
-
   // NOTE: The order matters here!
   const browserPatterns = [
     { key: 'edge' as const, pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
@@ -890,7 +760,6 @@ function getBrowserInfo(): BrowserInfo | null {
     { key: 'firefox' as const, pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
     { key: 'safari' as const, pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ },
   ];
-
   // Find the FIRST matching browser
   for (const { key, pattern } of browserPatterns) {
     const match = pattern.exec(navigator.userAgent);
@@ -898,14 +767,11 @@ function getBrowserInfo(): BrowserInfo | null {
       const major = match[1] || 0;
       const minor = match[2] || 0;
       const patch = match[3] || 0;
-
       return { browser: key, version: `${major}.${minor}.${patch}` };
     }
   }
-
   return null;
 }
-
 const normalizeArch = (arch: string): Arch => {
   // Node docs:
   // - https://nodejs.org/api/process.html#processarch
@@ -918,16 +784,13 @@ const normalizeArch = (arch: string): Arch => {
   if (arch) return `other:${arch}`;
   return 'unknown';
 };
-
 const normalizePlatform = (platform: string): PlatformName => {
   // Node platforms:
   // - https://nodejs.org/api/process.html#processplatform
   // Deno platforms:
   // - https://doc.deno.land/deno/stable/~/Deno.build
   // - https://github.com/denoland/deno/issues/14799
-
   platform = platform.toLowerCase();
-
   // NOTE: this iOS check is untested and may not work
   // Node does not work natively on IOS, there is a fork at
   // https://github.com/nodejs-mobile/nodejs-mobile
@@ -942,12 +805,10 @@ const normalizePlatform = (platform: string): PlatformName => {
   if (platform) return `Other:${platform}`;
   return 'Unknown';
 };
-
-let _platformHeaders: PlatformProperties;
+let _platformHeaders: PlatformProperties; // TODO: Remove if unused
 const getPlatformHeaders = () => {
   return (_platformHeaders ??= getPlatformProperties());
 };
-
 export const safeJSON = (text: string) => {
   try {
     return JSON.parse(text);
@@ -955,15 +816,12 @@ export const safeJSON = (text: string) => {
     return undefined;
   }
 };
-
 // https://stackoverflow.com/a/19709846
 const startsWithSchemeRegexp = new RegExp('^(?:[a-z]+:)?//', 'i');
 const isAbsoluteURL = (url: string): boolean => {
   return startsWithSchemeRegexp.test(url);
 };
-
 export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
-
 const validatePositiveInteger = (name: string, n: unknown): number => {
   if (typeof n !== 'number' || !Number.isInteger(n)) {
     throw new AnthropicError(`${name} must be an integer`);
@@ -973,17 +831,14 @@ const validatePositiveInteger = (name: string, n: unknown): number => {
   }
   return n;
 };
-
 export const castToError = (err: any): Error => {
   if (err instanceof Error) return err;
   return new Error(err);
 };
-
 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;
 };
-
 /**
  * Read an environment variable.
  *
@@ -1000,60 +855,49 @@ export const readEnv = (env: string): string | undefined => {
   }
   return undefined;
 };
-
 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);
 };
-
 // 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);
 }
-
 /**
  * Copies headers from "newHeaders" onto "targetHeaders",
  * using lower-case for all properties,
@@ -1065,9 +909,7 @@ function applyHeadersMut(targetHeaders: Headers, newHeaders: Headers): void {
     if (!hasOwn(newHeaders, k)) continue;
     const lowerKey = k.toLowerCase();
     if (!lowerKey) continue;
-
     const val = newHeaders[k];
-
     if (val === null) {
       delete targetHeaders[lowerKey];
     } else if (val !== undefined) {
@@ -1075,13 +917,11 @@ function applyHeadersMut(targetHeaders: Headers, newHeaders: Headers): void {
     }
   }
 }
-
 export function debug(action: string, ...args: any[]) {
   if (typeof process !== 'undefined' && process?.env?.['DEBUG'] === 'true') {
     console.log(`Anthropic:DEBUG:${action}`, ...args);
   }
 }
-
 /**
  * https://stackoverflow.com/a/2117523
  */
@@ -1092,7 +932,6 @@ const uuid4 = () => {
     return v.toString(16);
   });
 };
-
 export const isRunningInBrowser = () => {
   return (
     // @ts-ignore
@@ -1103,16 +942,13 @@ export const isRunningInBrowser = () => {
     typeof navigator !== 'undefined'
   );
 };
-
 export interface HeadersProtocol {
   get: (header: string) => string | null | undefined;
 }
 export type HeadersLike = Record<string, string | string[] | undefined> | HeadersProtocol;
-
 export const isHeadersProtocol = (headers: any): headers is HeadersProtocol => {
   return typeof headers?.get === 'function';
 };
-
 export const getRequiredHeader = (headers: HeadersLike, header: string): string => {
   const lowerCasedHeader = header.toLowerCase();
   if (isHeadersProtocol(headers)) {
@@ -1127,7 +963,6 @@ export const getRequiredHeader = (headers: HeadersLike, header: string): string
       }
     }
   }
-
   for (const [key, value] of Object.entries(headers)) {
     if (key.toLowerCase() === lowerCasedHeader) {
       if (Array.isArray(value)) {
@@ -1138,10 +973,8 @@ export const getRequiredHeader = (headers: HeadersLike, header: string): string
       return value;
     }
   }
-
   throw new Error(`Could not find ${header} header`);
 };
-
 /**
  * Encodes a string to Base64 format.
  */
@@ -1150,14 +983,11 @@ export const toBase64 = (str: string | null | undefined): string => {
   if (typeof Buffer !== 'undefined') {
     return Buffer.from(str).toString('base64');
   }
-
   if (typeof btoa !== 'undefined') {
     return btoa(str);
   }
-
   throw new AnthropicError('Cannot generate b64 string; Expected `Buffer` or `btoa` to be defined');
 };
-
 export function isObj(obj: unknown): obj is Record<string, unknown> {
   return obj != null && typeof obj === 'object' && !Array.isArray(obj);
-}
+}