openai 7.10.0 → 7.12.1

package/src/core/streaming.ts

@@ -9,22 +9,34 @@ import type { OpenAI } from '../client';
 
 type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
 
+function isTransportAbortError(error: unknown): boolean {
+  return !(error instanceof APIError) && isAbortError(error);
+}
+
 type StreamTeeQueue<Item> = {
   readonly length: number;
+  readonly canceled: boolean;
   enqueue: (value: Promise<IteratorResult<Item>>) => void;
   dequeue: () => Promise<IteratorResult<Item>> | undefined;
+  cancel: () => void;
 };
 
 function createStreamTeeQueue<Item>(): StreamTeeQueue<Item> {
   let entries: (Promise<IteratorResult<Item>> | undefined)[] = [];
   let head = 0;
+  let canceled = false;
 
   return {
     get length() {
       return entries.length - head;
     },
+    get canceled() {
+      return canceled;
+    },
     enqueue(value) {
-      entries.push(value);
+      if (!canceled) {
+        entries.push(value);
+      }
     },
     dequeue() {
       if (head === entries.length) {
@@ -45,6 +57,11 @@ function createStreamTeeQueue<Item>(): StreamTeeQueue<Item> {
 
       return value;
     },
+    cancel() {
+      canceled = true;
+      entries.length = 0;
+      head = 0;
+    },
   };
 }
 
@@ -69,6 +86,7 @@ export class Stream<Item> implements AsyncIterable<Item> {
   /** Abort controller for the underlying request and all branches created with `tee()`. */
   controller: AbortController;
   #client: OpenAI | undefined;
+  #isTeeBranch = false;
   private iterator: () => AsyncIterator<Item>;
 
   /** Wraps an asynchronous event iterator and the controller that owns its request. */
@@ -101,8 +119,17 @@ export class Stream<Item> implements AsyncIterable<Item> {
       consumed = true;
       let done = false;
       let receivedCompletionSentinel = false;
+      const messages = _iterSSEMessages(response, controller);
+      const closeMessages = messages.return.bind(messages);
+      messages.return = (value) => {
+        // Abort before nested iterator cleanup can wait on the response body's cancellation.
+        if (!receivedCompletionSentinel) {
+          controller.abort();
+        }
+        return closeMessages(value);
+      };
       try {
-        for await (const sse of _iterSSEMessages(response, controller)) {
+        for await (const sse of messages) {
           if (sse.data === '[DONE]') {
             receivedCompletionSentinel = true;
             break;
@@ -145,7 +172,7 @@ export class Stream<Item> implements AsyncIterable<Item> {
         // Abort errors and cleanup failures after the completion sentinel are non-fatal.
         if (
           receivedCompletionSentinel ||
-          isAbortError(e) ||
+          isTransportAbortError(e) ||
           (controller.signal.aborted && e === controller.signal.reason)
         ) {
           return;
@@ -234,9 +261,6 @@ export class Stream<Item> implements AsyncIterable<Item> {
       let done = false;
       try {
         for await (const line of iterLines()) {
-          if (done) {
-            continue;
-          }
           if (line) {
             let data: Item;
             try {
@@ -278,14 +302,24 @@ export class Stream<Item> implements AsyncIterable<Item> {
   /**
    * Splits the stream into two streams which can be
    * independently read from at different speeds.
+   * Closing a branch discards its buffered events without stopping its sibling.
+   * Future reads on that branch finish immediately; previously issued `next()`
+   * promises remain shared with its sibling and may still resolve with events.
+   * Closing both branches invokes the source iterator's `return()` when available.
+   * For {@link Stream.fromReadableStream}, closing both branches before iteration
+   * starts does not cancel the supplied readable; cancel that readable directly.
    */
   tee(): [Stream<Item>, Stream<Item>] {
+    const { controller } = this;
     const left = createStreamTeeQueue<Item>();
     const right = createStreamTeeQueue<Item>();
     const iterator = this.iterator();
 
     const teeIterator = (queue: StreamTeeQueue<Item>): AsyncIterator<Item> => ({
       next: () => {
+        if (queue.canceled) {
+          return Promise.resolve({ value: undefined, done: true });
+        }
         if (queue.length === 0) {
           const result = iterator.next();
           left.enqueue(result);
@@ -293,20 +327,34 @@ export class Stream<Item> implements AsyncIterable<Item> {
         }
         return queue.dequeue()!;
       },
+      return: async () => {
+        if (!queue.canceled) {
+          queue.cancel();
+          if (left.canceled && right.canceled) {
+            await this.#cancelIterator(iterator, controller);
+          }
+        }
+        return { value: undefined, done: true };
+      },
     });
 
-    return [
-      new Stream(() => teeIterator(left), this.controller, this.#client),
-      new Stream(() => teeIterator(right), this.controller, this.#client),
-    ];
+    const branch = (queue: StreamTeeQueue<Item>) => {
+      const stream = new Stream(() => teeIterator(queue), controller, this.#client);
+      stream.#isTeeBranch = true;
+      return stream;
+    };
+    return [branch(left), branch(right)];
   }
 
   /**
    * Converts this stream to a newline-separated ReadableStream of
    * JSON stringified values in the stream
    * which can be turned back into a Stream with `Stream.fromReadableStream()`.
+   * Canceling a response-backed readable aborts its request. Canceling a tee
+   * branch discards its buffered events and leaves sibling consumers running.
    */
   toReadableStream(): ReadableStream {
+    const { controller } = this;
     let iter: AsyncIterator<Item>;
 
     return makeReadableStream({
@@ -327,11 +375,19 @@ export class Stream<Item> implements AsyncIterable<Item> {
           ctrl.error(err);
         }
       },
-      async cancel() {
-        await iter.return?.();
-      },
+      cancel: () => this.#cancelIterator(iter, controller),
     });
   }
+
+  async #cancelIterator(iterator: AsyncIterator<Item>, controller: AbortController): Promise<void> {
+    const returnMethod = iterator.return;
+    if (returnMethod) {
+      if (!this.#isTeeBranch) {
+        controller.abort();
+      }
+      await Reflect.apply(returnMethod, iterator, []);
+    }
+  }
 }
 
 function createAbortableSSESource(body: NonNullable<Response['body']>, signal: AbortSignal) {

package/src/helpers/audio.ts

@@ -24,7 +24,17 @@ const recordingProviders: Record<NodeJS.Platform, string> = {
 };
 
 function isResponse(stream: NodeJS.ReadableStream | Response | File): stream is Response {
-  return (stream as any).body !== undefined;
+  // Readables have event and flow-control methods, even after they have ended.
+  const nodeReadable =
+    'pipe' in stream &&
+    typeof stream.pipe === 'function' &&
+    'on' in stream &&
+    typeof stream.on === 'function' &&
+    'pause' in stream &&
+    typeof stream.pause === 'function' &&
+    'resume' in stream &&
+    typeof stream.resume === 'function';
+  return !nodeReadable && 'body' in stream && stream.body !== undefined;
 }
 
 function isFile(stream: NodeJS.ReadableStream | Response | File): stream is File {
@@ -57,10 +67,18 @@ async function nodejsPlayAudio(stream: NodeJS.ReadableStream | Response | File):
       ffplay.stderr?.resume();
       ffplay.on('error', reject);
 
+      // The player can exit before the input stream finishes its cleanup.
+      let inputFinished = false;
+      let processClosed = false;
       pipeline(source, ffplay.stdin, (error) => {
         if (error) {
           ffplay.kill();
           reject(error);
+          return;
+        }
+        inputFinished = true;
+        if (processClosed) {
+          resolve();
         }
       });
 
@@ -69,7 +87,10 @@ async function nodejsPlayAudio(stream: NodeJS.ReadableStream | Response | File):
           reject(new Error(`ffplay process exited with code ${code}`));
           return;
         }
-        resolve();
+        processClosed = true;
+        if (inputFinished) {
+          resolve();
+        }
       });
     } catch (error) {
       reject(error);
@@ -103,7 +124,7 @@ type RecordAudioOptions = {
   /** Stops recording when aborted; successful termination returns the captured audio. */
   signal?: AbortSignal;
 
-  /** Zero-based audio-input device number passed to FFmpeg; defaults to `0`. */
+  /** Zero-based audio-input index (ALSA card number on Linux); defaults to `0`. */
   device?: number;
 
   /** Positive recording duration in milliseconds; nonpositive values disable the timeout. */
@@ -137,7 +158,7 @@ function nodejsRecordAudio({ signal, device, timeout }: RecordAudioOptions = {})
       }
     };
     const stopRecording = () => {
-      if (!settled && ffmpeg) {
+      if (!settled && ffmpeg?.pid) {
         try {
           wasStopped ||= ffmpeg.kill('SIGTERM');
         } catch (error) {
@@ -223,7 +244,7 @@ function nodejsRecordAudio({ signal, device, timeout }: RecordAudioOptions = {})
           '-f',
           provider,
           '-i',
-          `:${device ?? 0}`, // default audio input device; adjust as needed
+          provider === 'alsa' ? `hw:${device ?? 0}` : `:${device ?? 0}`,
           '-ar',
           DEFAULT_SAMPLE_RATE.toString(),
           '-ac',
@@ -270,7 +291,7 @@ function nodejsRecordAudio({ signal, device, timeout }: RecordAudioOptions = {})
       }
 
       try {
-        if (!wasStopped) {
+        if (!wasStopped && ffmpeg?.pid) {
           ffmpeg?.kill('SIGTERM');
         }
       } catch {

package/src/helpers/zod.ts

@@ -82,11 +82,11 @@ function validateSchemaDefinitions(schemaDefinitions: ZodSchemaDefinitions | und
 
 function escapeSchemaDefinitionRefs<T extends object>(
   schema: T,
-  schemaDefinitions: ZodSchemaDefinitions | undefined,
+  definitionNames: ReadonlyMap<string, string>,
 ): T {
   const refReplacements = new Map(
-    Object.keys(schemaDefinitions ?? {}).map((name) => [
-      `#/definitions/${name}`,
+    [...definitionNames].map(([id, name]) => [
+      `#/definitions/${id}`,
       `#/definitions/${encodeSchemaDefinitionRefToken(name)}`,
     ]),
   );
@@ -147,7 +147,10 @@ function zodV3ToJsonSchema(
       : undefined),
   });
 
-  const escapedSchema = escapeSchemaDefinitionRefs(jsonSchema, options.schemaDefinitions);
+  const escapedSchema = escapeSchemaDefinitionRefs(
+    jsonSchema,
+    new Map(Object.keys(options.schemaDefinitions ?? {}).map((name) => [name, name])),
+  );
   assertJSONSerializableSchema(escapedSchema);
   return escapedSchema;
 }
@@ -157,16 +160,29 @@ function zodV4ToJsonSchema(
   options: { schemaDefinitions?: ZodSchemaDefinitions | undefined } = {},
 ): Record<string, unknown> {
   const metadata = options.schemaDefinitions ? z4.registry<Record<string, unknown>>() : undefined;
+  const definitionNames = new Map<string, string>();
   for (const [name, definition] of Object.entries(options.schemaDefinitions ?? {})) {
-    metadata?.add(definition as unknown as z4.ZodType, { id: name });
+    // Avoid `/` and `~` so Zod versions that escape JSON Pointer tokens emit the same IDs.
+    const id = encodeURIComponent(name).replace(/~/g, '%7E');
+    definitionNames.set(id, name);
+    metadata?.add(definition as unknown as z4.ZodType, { id });
   }
 
   const jsonSchema = z4.toJSONSchema(schema, {
     target: 'draft-7',
     ...(metadata ? { metadata } : undefined),
-    override: ({ zodSchema, jsonSchema }) => {
+    override: ({ zodSchema, jsonSchema, path }) => {
       const def = zodSchema._zod.def;
 
+      if (def.type === 'object' && hasOwn(def.shape, '__proto__')) {
+        const propertyPath = [...path, 'properties', '__proto__']
+          .map((part) => encodeSchemaDefinitionRefToken(String(part)))
+          .join('/');
+        throw new Error(
+          `Zod field at \`#/${propertyPath}\` uses unsupported property name \`__proto__\`, which Zod omits from parsed output.`,
+        );
+      }
+
       if (def.type === 'union' && 'discriminator' in def && Array.isArray(jsonSchema.oneOf)) {
         if (jsonSchema.anyOf !== undefined) {
           throw new Error(
@@ -182,7 +198,15 @@ function zodV4ToJsonSchema(
     },
   }) as JSONSchema;
 
-  const escapedSchema = escapeSchemaDefinitionRefs(jsonSchema, options.schemaDefinitions);
+  const escapedSchema = escapeSchemaDefinitionRefs(jsonSchema, definitionNames);
+  if (escapedSchema.definitions) {
+    escapedSchema.definitions = Object.fromEntries(
+      Object.entries(escapedSchema.definitions).map(([id, definition]) => [
+        definitionNames.get(id) ?? id,
+        definition,
+      ]),
+    );
+  }
 
   return toStrictJsonSchema(escapedSchema) as Record<string, unknown>;
 }
@@ -333,18 +357,8 @@ export function zodTextFormat<ZodInput extends ZodTypeLike>(
   );
 }
 
-/**
- * Creates a chat completion `function` tool that can be invoked
- * automatically by the chat completion `.runTools()` method or automatically
- * parsed by `.parse()` / `.stream()`.
- *
- * Arguments are converted to strict JSON Schema and validated with the supplied
- * Zod schema before the optional callback receives them.
- *
- * @param options Model-visible function name, Zod parameter schema, description,
- * and optional callback used by `chat.completions.runTools()`.
- */
-export function zodFunction<Parameters extends ZodTypeLike>(options: {
+/** Model-facing settings and an optional execution callback for a Zod function tool. */
+interface ZodFunctionOptions<Parameters extends ZodTypeLike> {
   /** Model-visible function name used to identify matching tool calls. */
   name: string;
 
@@ -356,19 +370,53 @@ export function zodFunction<Parameters extends ZodTypeLike>(options: {
 
   /** Optional model-visible explanation of when and how the function should be used. */
   description?: string | undefined;
-}): AutoParseableTool<{
+}
+
+/** A Zod function tool retaining its inferred argument and callback types. */
+type ZodFunctionTool<
+  Parameters extends ZodTypeLike,
+  Callback extends ZodFunctionOptions<Parameters>['function'],
+> = AutoParseableTool<{
   /** Inferred argument type produced by the Zod parameter schema. */
   arguments: InferZodType<Parameters>;
-
   /** Model-visible name used to match generated function calls. */
   name: string;
+  /** Callback availability determines whether the tool can be executed. */
+  function: Callback;
+}>;
 
-  /** Callback signature associated with validated function-call arguments. */
-  function: (args: InferZodType<Parameters>) => unknown;
-}> {
-  const zodSchema = options.parameters as unknown as ZodSchema;
+/**
+ * Creates a chat completion `function` tool that can be invoked automatically
+ * by `.runTools()` or parsed by `.parse()` / `.stream()`.
+ *
+ * Arguments are converted to strict JSON Schema and validated with the supplied
+ * Zod schema before the callback receives them.
+ *
+ * @param options Model-visible function name, Zod parameter schema, description,
+ * and callback used by `chat.completions.runTools()`.
+ */
+export function zodFunction<Parameters extends ZodTypeLike>(
+  options: ZodFunctionOptions<Parameters> & {
+    /** Callback invoked with validated arguments by chat `runTools()`. */
+    function: NonNullable<ZodFunctionOptions<Parameters>['function']>;
+  },
+): ZodFunctionTool<Parameters, NonNullable<ZodFunctionOptions<Parameters>['function']>>;
+
+/**
+ * Creates a strict chat completion function tool for `.parse()` / `.stream()`.
+ * Without a guaranteed callback, the tool cannot be executed by `.runTools()`.
+ *
+ * @param options Model-visible function details and an optional callback.
+ */
+export function zodFunction<Parameters extends ZodTypeLike>(
+  options: ZodFunctionOptions<Parameters>,
+): ZodFunctionTool<Parameters, ZodFunctionOptions<Parameters>['function']>;
+
+/** Builds a strict Chat Completions function tool from the supplied Zod schema. */
+export function zodFunction<Parameters extends ZodTypeLike>(options: ZodFunctionOptions<Parameters>) {
+  const parameters = options.parameters;
+  const zodSchema = parameters as unknown as ZodSchema;
 
-  // @ts-expect-error TODO
   return makeParseableTool<any>(
     {
       type: 'function',
@@ -383,7 +431,7 @@ export function zodFunction<Parameters extends ZodTypeLike>(options: {
     },
     {
       callback: options.function,
-      parser: (args) => parseZodObject(options.parameters, args),
+      parser: (args) => parseZodObject(parameters, args),
     },
   );
 }
@@ -421,7 +469,8 @@ export function zodResponsesFunction<Parameters extends ZodTypeLike>(options: {
   /** Callback signature associated with validated function-call arguments. */
   function: (args: InferZodType<Parameters>) => unknown;
 }> {
-  const zodSchema = options.parameters as unknown as ZodSchema;
+  const parameters = options.parameters;
+  const zodSchema = parameters as unknown as ZodSchema;
 
   return makeParseableResponseTool<any>(
     {
@@ -435,7 +484,7 @@ export function zodResponsesFunction<Parameters extends ZodTypeLike>(options: {
     },
     {
       callback: options.function,
-      parser: (args) => parseZodObject(options.parameters, args),
+      parser: (args) => parseZodObject(parameters, args),
     },
   );
 }

package/src/internal/bedrock.ts

@@ -290,7 +290,7 @@ export function assertValidBedrockBearerCredential(credential: string): void {
   }
 }
 
-interface BedrockBearerSignalFailure {
+interface BedrockAuthSignalFailure {
   error?: { value: unknown };
   removeListeners?: () => void;
 }
@@ -313,13 +313,13 @@ function removeBedrockAbortListener(signal: AbortSignal, listener: () => void):
   }
 }
 
-function resolveAbortableBedrockBearerToken(
-  tokenProvider: ApiKeySetter,
+function resolveAbortableBedrockAuth<T>(
+  operation: () => Promise<T>,
   signals: readonly AbortSignal[],
-  failure: BedrockBearerSignalFailure,
-): Promise<string> {
+  failure: BedrockAuthSignalFailure,
+): Promise<T> {
   // oxlint-disable-next-line promise/avoid-new -- AbortSignal events require a Promise callback bridge.
-  return new Promise<string>((resolve, reject) => {
+  return new Promise<T>((resolve, reject) => {
     let settled = false;
     const listeners: { signal: AbortSignal; listener: () => void }[] = [];
 
@@ -333,13 +333,13 @@ function resolveAbortableBedrockBearerToken(
     };
     failure.removeListeners = removeListeners;
 
-    const settle = (result: { token: string } | { error: unknown }) => {
+    const settle = (result: { value: T } | { error: unknown }) => {
       if (settled) {
         return;
       }
       settled = true;
-      if ('token' in result) {
-        resolve(result.token);
+      if ('value' in result) {
+        resolve(result.value);
       } else {
         removeListeners();
         reject(result.error);
@@ -399,26 +399,75 @@ function resolveAbortableBedrockBearerToken(
       }
     }
 
-    let token: Promise<string>;
+    let pending: Promise<T>;
     try {
-      token = tokenProvider();
+      pending = operation();
     } catch (error) {
       settle({ error });
       return;
     }
 
-    const observeToken = async () => {
+    const observeResult = async () => {
       try {
-        settle({ token: await token });
+        settle({ value: await pending });
       } catch (error) {
         settle({ error });
       }
     };
     // Observe the result even if the provider synchronously triggered cancellation.
-    void observeToken();
+    void observeResult();
   });
 }
 
+/**
+ * Resolves Bedrock authentication work with caller cancellation, then applies
+ * its result synchronously after the final cancellation checks.
+ *
+ * @internal
+ */
+export async function prepareBedrockAuth<T>(
+  request: FinalizedRequestInit,
+  context: ProviderRequestContext,
+  operation: {
+    resolve: () => Promise<T>;
+    failureMessage: string;
+    apply: (value: T) => void;
+  },
+): Promise<void> {
+  const signals: AbortSignal[] = [];
+  for (const signal of [context.options.signal, request.signal]) {
+    if (signal != null && !signals.includes(signal)) {
+      signals.push(signal);
+    }
+  }
+  const signalFailure: BedrockAuthSignalFailure = {};
+  let value: T;
+  try {
+    try {
+      value =
+        signals.length > 0
+          ? await resolveAbortableBedrockAuth(operation.resolve, signals, signalFailure)
+          : await operation.resolve();
+    } catch (cause) {
+      if (signalFailure.error && Object.is(cause, signalFailure.error.value)) {
+        throw cause;
+      }
+      throw errorWithCause(operation.failureMessage, cause);
+    }
+    if (signalFailure.error) {
+      throw signalFailure.error.value;
+    }
+    for (const signal of signals) {
+      if (signal.aborted) {
+        throw createBedrockUserAbortError(signal);
+      }
+    }
+  } finally {
+    signalFailure.removeListeners?.();
+  }
+  operation.apply(value);
+}
+
 class BedrockBearerAuth implements BedrockRequestAuth {
   private readonly tokenProvider: ApiKeySetter;
 
@@ -430,52 +479,29 @@ class BedrockBearerAuth implements BedrockRequestAuth {
     const headers = new Headers(request.headers);
     assertProviderOwnsAuthorization(headers);
 
-    const signals: AbortSignal[] = [];
-    for (const signal of [context.options.signal, request.signal]) {
-      if (signal != null && !signals.includes(signal)) {
-        signals.push(signal);
-      }
-    }
-    const signalFailure: BedrockBearerSignalFailure = {};
-    let token: unknown;
-    try {
-      try {
-        token =
-          signals.length > 0
-            ? await resolveAbortableBedrockBearerToken(() => this.tokenProvider(), signals, signalFailure)
-            : await this.tokenProvider();
-      } catch (cause) {
-        if (signalFailure.error && Object.is(cause, signalFailure.error.value)) {
-          throw cause;
+    await prepareBedrockAuth(request, context, {
+      resolve: () => this.tokenProvider(),
+      failureMessage: 'Failed to resolve a bearer credential for Bedrock.',
+      apply: (token) => {
+        if (typeof token !== 'string' || !token.trim()) {
+          throw new Errors.OpenAIError(
+            'The Bedrock bearer credential provider must return a non-empty string.',
+          );
         }
-        throw errorWithCause('Failed to resolve a bearer credential for Bedrock.', cause);
-      }
-      if (signalFailure.error) {
-        throw signalFailure.error.value;
-      }
-      for (const signal of signals) {
-        if (signal.aborted) {
-          throw createBedrockUserAbortError(signal);
+        assertValidBedrockBearerCredential(token);
+        try {
+          headers.set('authorization', `Bearer ${token}`);
+        } catch (error) {
+          if (error instanceof TypeError) {
+            // oxlint-disable-next-line eslint/preserve-caught-error -- The original error contains the bearer credential.
+            throw new TypeError('Bedrock bearer credential contains an invalid HTTP header value.');
+          }
+          throw error;
         }
-      }
-    } finally {
-      signalFailure.removeListeners?.();
-    }
-    if (typeof token !== 'string' || !token.trim()) {
-      throw new Errors.OpenAIError('The Bedrock bearer credential provider must return a non-empty string.');
-    }
-    assertValidBedrockBearerCredential(token);
-    try {
-      headers.set('authorization', `Bearer ${token}`);
-    } catch (error) {
-      if (error instanceof TypeError) {
-        // oxlint-disable-next-line eslint/preserve-caught-error -- The original error contains the bearer credential.
-        throw new TypeError('Bedrock bearer credential contains an invalid HTTP header value.');
-      }
-      throw error;
-    }
-    request.redirect = 'manual';
-    request.headers = headers;
+        request.redirect = 'manual';
+        request.headers = headers;
+      },
+    });
   }
 }
 

package/src/internal/detect-platform.ts

@@ -75,7 +75,7 @@ const getPlatformProperties = (): PlatformProperties => {
       'X-Stainless-OS': 'Unknown',
       'X-Stainless-Arch': `other:${EdgeRuntime}`,
       'X-Stainless-Runtime': 'edge',
-      'X-Stainless-Runtime-Version': (globalThis as any).process.version,
+      'X-Stainless-Runtime-Version': (globalThis as any).process?.version ?? 'unknown',
     };
   }
   // Check if Node.js
@@ -128,7 +128,7 @@ function getBrowserInfo(): BrowserInfo | null {
 
   // NOTE: The order matters here!
   const browserPatterns = [
-    { key: 'edge' as const, pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: 'edge' as const, pattern: /\bEdg(?:e|A|iOS)?\b(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
     { key: 'ie' as const, pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
     { key: 'ie' as const, pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ },
     { key: 'chrome' as const, pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },

package/src/internal/errors.ts

@@ -14,11 +14,12 @@ export const castToError = (err: any): Error => {
   if (typeof err === 'object' && err !== null) {
     try {
       if (Object.prototype.toString.call(err) === '[object Error]') {
+        const hasCause = 'cause' in err;
         // @ts-ignore - not all envs have native support for cause yet
-        const error = new Error(err.message, err.cause ? { cause: err.cause } : {});
+        const error = new Error(err.message, hasCause ? { cause: err.cause } : {});
         if (err.stack) error.stack = err.stack;
         // @ts-ignore - not all envs have native support for cause yet
-        if (err.cause && !error.cause) error.cause = err.cause;
+        if (hasCause && !Object.prototype.hasOwnProperty.call(error, 'cause')) error.cause = err.cause;
         if (err.name) error.name = err.name;
         return error;
       }