openai 7.16.0 → 7.17.0

package/lib/EventStream.mjs

@@ -1,4 +1,4 @@
-var _EventStream_instances, _EventStream_connectedPromise, _EventStream_resolveConnectedPromise, _EventStream_rejectConnectedPromise, _EventStream_endPromise, _EventStream_resolveEndPromise, _EventStream_rejectEndPromise, _EventStream_listeners, _EventStream_abortListeners, _EventStream_emittedListenerRegistrations, _EventStream_pendingListenerCleanup, _EventStream_pendingBufferedEventChecks, _EventStream_listenerDispatchDepth, _EventStream_ended, _EventStream_errored, _EventStream_aborted, _EventStream_catchingPromiseCreated, _EventStream_terminalFailure, _EventStream_removeAbortListeners, _EventStream_onceForEmitted, _EventStream_removeEmittedListener, _EventStream_cleanupEmittedListeners, _EventStream_handleError, _EventStream_settleTerminalEvent;
+var _EventStream_instances, _EventStream_connectedPromise, _EventStream_resolveConnectedPromise, _EventStream_rejectConnectedPromise, _EventStream_endPromise, _EventStream_resolveEndPromise, _EventStream_rejectEndPromise, _EventStream_listeners, _EventStream_abortListeners, _EventStream_emittedListenerRegistrations, _EventStream_pendingListenerCleanup, _EventStream_pendingBufferedEventChecks, _EventStream_listenerDispatchDepth, _EventStream_ended, _EventStream_errored, _EventStream_aborted, _EventStream_catchingPromiseCreated, _EventStream_terminalFailure, _EventStream_abortFromSignal, _EventStream_removeAbortListeners, _EventStream_onceForEmitted, _EventStream_removeEmittedListener, _EventStream_cleanupEmittedListeners, _EventStream_handleError, _EventStream_settleTerminalEvent;
 import { __classPrivateFieldGet, __classPrivateFieldSet } from "../internal/tslib.mjs";
 import { APIConnectionError, APIConnectionTimeoutError, APIError, APIUserAbortError, AuthenticationError, BadRequestError, ConflictError, ContentFilterFinishReasonError, InternalServerError, InvalidWebhookSignatureError, LengthFinishReasonError, NotFoundError, OAuthError, OpenAIError, PermissionDeniedError, RateLimitError, SubjectTokenProviderError, UnprocessableEntityError, } from "../error.mjs";
 const MAX_BUFFERED_ITERATOR_EVENTS = 4096;
@@ -10,7 +10,9 @@ const MAX_BUFFERED_EVENT_DEPTH = 256;
 const bufferedJSONStringify = JSON.stringify;
 const bufferedJSONParse = JSON.parse;
 const sdkOwnedBufferedEventArguments = new WeakSet();
+// SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
 const typedArrayBufferGetter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'buffer')?.get;
+// SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
 const typedArrayLengthGetter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'length')?.get;
 const dataViewBufferGetter = Object.getOwnPropertyDescriptor(DataView.prototype, 'buffer')?.get;
 const symbolDescriptionGetter = Object.getOwnPropertyDescriptor(Symbol.prototype, 'description')?.get;
@@ -24,6 +26,8 @@ const errorStackDescriptor = Object.getOwnPropertyDescriptor(new Error('native s
 const functionToString = Function.prototype.toString;
 const objectToString = Object.prototype.toString;
 const errorBrandDescriptor = Object.getOwnPropertyDescriptor(Error, 'isError');
+// The native Error.isError predicate brands arbitrary values before an Error contract can be assumed.
+// SAFETY: The captured native Error.isError property was checked to be a function before it is used as a brand predicate.
 const nativeErrorBrand = errorBrandDescriptor && 'value' in errorBrandDescriptor && typeof errorBrandDescriptor.value === 'function'
     ? errorBrandDescriptor.value
     : undefined;
@@ -53,6 +57,7 @@ const trustedIntrinsicPrototypes = new Set([
 const trustedNativeConstructorSources = new Set();
 const canonicalIntrinsicDescriptors = new Map();
 const foreignErrorStackDescriptors = new WeakMap();
+// oxlint-disable-next-line anti-slop/no-object-parameters -- The native proxy predicate accepts arbitrary object identities without invoking their handlers.
 function captureNativeProxyDetector() {
     if (typeof process === 'undefined') {
         return undefined;
@@ -62,6 +67,7 @@ function captureNativeProxyDetector() {
         if (!loader || !('value' in loader) || typeof loader.value !== 'function') {
             return undefined;
         }
+        // oxlint-disable-next-line anti-slop/no-reflect-apply -- Invoke the descriptor value without reading a potentially overridden call property.
         const util = Reflect.apply(loader.value, process, ['node:util']);
         if (typeof util !== 'object' || util === null) {
             return undefined;
@@ -74,6 +80,8 @@ function captureNativeProxyDetector() {
         if (!detector || !('value' in detector) || typeof detector.value !== 'function') {
             return undefined;
         }
+        // SAFETY: The native detector data property was checked to be callable; it is invoked only to test the corresponding intrinsic object brand.
+        // oxlint-disable-next-line anti-slop/no-object-parameters -- The captured native predicate is called only for objects, before their properties are inspected.
         return detector.value;
     }
     catch {
@@ -93,6 +101,7 @@ function rememberTrustedIntrinsic(constructor) {
         (typeof prototypeDescriptor.value !== 'object' && typeof prototypeDescriptor.value !== 'function')) {
         return;
     }
+    // SAFETY: The prototype data descriptor was checked as a non-null object before adding its identity to the trusted-intrinsic set.
     trustedIntrinsicPrototypes.add(prototypeDescriptor.value);
     const source = functionToString.call(constructor);
     if (/^function [A-Za-z_$][\w$]*\(\) \{ \[native code\] \}$/u.test(source) &&
@@ -152,6 +161,7 @@ for (const name of [
         rememberTrustedIntrinsic(descriptor.value);
     }
 }
+// SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
 const typedArrayConstructorDescriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'constructor');
 if (typedArrayConstructorDescriptor && 'value' in typedArrayConstructorDescriptor) {
     rememberTrustedIntrinsic(typedArrayConstructorDescriptor.value);
@@ -168,6 +178,7 @@ const blobInternalHandlePrototype = (() => {
         for (const key of Object.getOwnPropertySymbols(blob)) {
             const descriptor = Object.getOwnPropertyDescriptor(blob, key);
             if (descriptor && 'value' in descriptor && typeof descriptor.value === 'object' && descriptor.value) {
+                // SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
                 return Object.getPrototypeOf(descriptor.value);
             }
         }
@@ -180,6 +191,7 @@ const blobInternalHandlePrototype = (() => {
 const mapEntries = Map.prototype.entries;
 const setValues = Set.prototype.values;
 const headersEntriesDescriptor = typeof Headers === 'function' ? Object.getOwnPropertyDescriptor(Headers.prototype, 'entries') : undefined;
+// SAFETY: The own Headers entries data property was checked to be callable and retains the native method signature.
 const headersEntries = headersEntriesDescriptor &&
     'value' in headersEntriesDescriptor &&
     typeof headersEntriesDescriptor.value === 'function'
@@ -195,11 +207,13 @@ const retainedStorageBrands = new Set([
     'Set',
     'Headers',
 ]);
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Foreign prototypes are untrusted objects until their constructor descriptors are verified.
 function getTrustedForeignIntrinsic(prototype) {
     const descriptor = Object.getOwnPropertyDescriptor(prototype, 'constructor');
     if (!descriptor || !('value' in descriptor) || typeof descriptor.value !== 'function') {
         return undefined;
     }
+    // SAFETY: The descriptor contains a function; the following native-source and prototype checks verify the Error constructor before use.
     const constructor = descriptor.value;
     const source = functionToString.call(constructor);
     const descriptors = canonicalIntrinsicDescriptors.get(source);
@@ -214,12 +228,16 @@ function getTrustedForeignIntrinsic(prototype) {
         constructorPrototype.writable !== false) {
         return undefined;
     }
+    // SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
     return { constructor, descriptors, functionPrototype: Object.getPrototypeOf(constructor) };
 }
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Intrinsic trust is established by object identity or verified cross-realm descriptors.
 function isTrustedIntrinsicPrototype(prototype) {
     return trustedIntrinsicPrototypes.has(prototype) || getTrustedForeignIntrinsic(prototype) !== undefined;
 }
-function isCanonicalIntrinsicFunction(value, canonical, functionPrototype) {
+function isCanonicalIntrinsicFunction(value, canonical, 
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Cross-realm function prototypes are compared by identity without trusting a callable signature.
+functionPrototype) {
     if (canonical === undefined) {
         return value === undefined;
     }
@@ -230,6 +248,7 @@ function isCanonicalIntrinsicFunction(value, canonical, functionPrototype) {
     if (functionToString.call(value) !== source) {
         return false;
     }
+    // SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
     const actualFunctionPrototype = Object.getPrototypeOf(value);
     if (actualFunctionPrototype === functionPrototype) {
         return true;
@@ -241,7 +260,9 @@ function isCanonicalIntrinsicFunction(value, canonical, functionPrototype) {
     return (intrinsic !== undefined &&
         functionToString.call(intrinsic.constructor) === nativeFunctionConstructorSource);
 }
-function isCanonicalIntrinsicDescriptor(descriptor, canonical, functionPrototype) {
+function isCanonicalIntrinsicDescriptor(descriptor, canonical, 
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Descriptor validation compares the verified function-prototype identity without reading its fields.
+functionPrototype) {
     if (!canonical ||
         descriptor.configurable !== canonical.configurable ||
         descriptor.enumerable !== canonical.enumerable ||
@@ -263,6 +284,7 @@ function isCanonicalIntrinsicDescriptor(descriptor, canonical, functionPrototype
     return (isCanonicalIntrinsicFunction(descriptor.get, canonical.get, functionPrototype) &&
         isCanonicalIntrinsicFunction(descriptor.set, canonical.set, functionPrototype));
 }
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Native error branding must inspect arbitrary objects before assuming an Error contract.
 function hasNativeErrorBrand(current) {
     if (nativeErrorBrand) {
         return nativeErrorBrand.call(Error, current);
@@ -272,21 +294,27 @@ function hasNativeErrorBrand(current) {
         if (Object.getOwnPropertyDescriptor(prototype, Symbol.toStringTag)) {
             return false;
         }
+        // SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
         prototype = Object.getPrototypeOf(prototype);
     }
     return prototype === null && objectToString.call(current) === '[object Error]';
 }
-function getVerifiedForeignErrorConstructor(current, stackDescriptor) {
+function getVerifiedForeignErrorConstructor(
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Foreign error constructors are verified from descriptors of an otherwise untrusted object.
+current, stackDescriptor) {
     if (typeof stackDescriptor.get !== 'function' || typeof stackDescriptor.set !== 'function') {
         return undefined;
     }
+    // SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
     let prototype = Object.getPrototypeOf(current);
     for (let depth = 0; prototype !== null && depth < MAX_BUFFERED_EVENT_DEPTH; depth += 1) {
         const descriptor = Object.getOwnPropertyDescriptor(prototype, 'constructor');
         if (descriptor && 'value' in descriptor && typeof descriptor.value === 'function') {
+            // SAFETY: The descriptor contains a function; the following intrinsic and constructor-prototype checks decide whether it is a trusted Error constructor.
             const constructor = descriptor.value;
             if (functionToString.call(constructor) === nativeErrorConstructorSource &&
                 isTrustedIntrinsicPrototype(prototype)) {
+                // SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
                 const functionPrototype = Object.getPrototypeOf(constructor);
                 if (Object.getPrototypeOf(stackDescriptor.get) === functionPrototype &&
                     Object.getPrototypeOf(stackDescriptor.set) === functionPrototype) {
@@ -295,10 +323,12 @@ function getVerifiedForeignErrorConstructor(current, stackDescriptor) {
                 return undefined;
             }
         }
+        // SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
         prototype = Object.getPrototypeOf(prototype);
     }
     return undefined;
 }
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Stack accessors are trusted only after the object passes native error branding.
 function isTrustedNativeErrorStack(current, descriptor) {
     if (!hasNativeErrorBrand(current)) {
         return false;
@@ -317,6 +347,7 @@ function isTrustedNativeErrorStack(current, descriptor) {
     }
     let canonicalDescriptor = foreignErrorStackDescriptors.get(verified.prototype);
     if (!canonicalDescriptor) {
+        // SAFETY: Reflect.construct returns an untyped value; unknown preserves that uncertainty for the descriptor checks below.
         const canonical = Reflect.construct(verified.constructor, []);
         if (typeof canonical !== 'object' ||
             canonical === null ||
@@ -368,7 +399,9 @@ function createEventQueue() {
         },
     };
 }
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Retained storage branding walks arbitrary object prototypes without assuming their native type.
 function getRetainedStorageBrand(current) {
+    // SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
     let prototype = Object.getPrototypeOf(current);
     for (let depth = 0; prototype !== null && depth < MAX_BUFFERED_EVENT_DEPTH; depth += 1) {
         if (prototype === Date.prototype) {
@@ -391,19 +424,24 @@ function getRetainedStorageBrand(current) {
             retainedStorageBrands.has(descriptor.value)) {
             return descriptor.value;
         }
+        // SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
         prototype = Object.getPrototypeOf(prototype);
     }
     return undefined;
 }
-function estimateRetainedBufferBytes(current, visit, depth) {
+function estimateRetainedBufferBytes(
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Memory accounting inspects arbitrary retained objects and detects native backing storage at runtime.
+current, visit, depth) {
     if (ArrayBuffer.isView(current)) {
         let buffer;
         let kind = 'typed-array';
         try {
+            // SAFETY: The captured intrinsic getter performs its own receiver brand check; its result stays unknown until the ArrayBuffer validation below.
             buffer = typedArrayBufferGetter?.call(current);
         }
         catch {
             kind = 'data-view';
+            // SAFETY: The DataView intrinsic getter performs its receiver brand check; its result stays unknown until the ArrayBuffer validation below.
             buffer = dataViewBufferGetter?.call(current);
         }
         if (typeof buffer !== 'object' || buffer === null) {
@@ -417,6 +455,7 @@ function estimateRetainedBufferBytes(current, visit, depth) {
     if (!brand) {
         return undefined;
     }
+    // oxlint-disable-next-line anti-slop/no-unknown-returns -- Captured native accessors are checked for a finite numeric result before retained-size accounting.
     let getter;
     const kind = 'buffer';
     switch (brand) {
@@ -439,6 +478,7 @@ function estimateRetainedBufferBytes(current, visit, depth) {
             return { bytes: 0, kind: 'map' };
         }
         case 'Date': {
+            // oxlint-disable-next-line anti-slop/no-reflect-apply -- Invoke the captured intrinsic without reading its mutable call property.
             Reflect.apply(dateTimestampGetter, current, []);
             return { bytes: 8, kind: 'date' };
         }
@@ -460,7 +500,9 @@ function estimateRetainedBufferBytes(current, visit, depth) {
         kind,
     };
 }
-function visitHiddenEventValues(current, kind, visit) {
+function visitHiddenEventValues(
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Native collection contents are inspected only after storage branding, without trusting structural fields.
+current, kind, visit) {
     if (kind === 'map') {
         for (const [key, entry] of mapEntries.call(current)) {
             if (!visit(key, 8) || !visit(entry, 8)) {
@@ -479,6 +521,7 @@ function visitHiddenEventValues(current, kind, visit) {
         if (!headersEntries) {
             return false;
         }
+        // SAFETY: The captured native Headers.entries method performs its receiver brand check inside the enclosing try/catch.
         for (const [name, value] of headersEntries.call(current)) {
             if (!visit(name, 8) || !visit(value, 8)) {
                 return false;
@@ -487,7 +530,9 @@ function visitHiddenEventValues(current, kind, visit) {
     }
     return true;
 }
-function getInspectableEventKeys(current, kind, availableBytes) {
+function getInspectableEventKeys(
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Event key inspection must accept arbitrary retained objects, arrays, and native storage views.
+current, kind, availableBytes) {
     if (Array.isArray(current)) {
         const descriptor = Object.getOwnPropertyDescriptor(current, 'length');
         const length = descriptor && 'value' in descriptor ? descriptor.value : undefined;
@@ -516,7 +561,9 @@ function getInspectableEventKeys(current, kind, availableBytes) {
         return !Number.isInteger(index) || index < 0 || index >= length || String(index) !== key;
     });
 }
-function visitInspectableEventProperties(current, kind, depth, availableBytes, charge, visit) {
+function visitInspectableEventProperties(
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Retained event properties are inspected through descriptors on arbitrary object identities.
+current, kind, depth, availableBytes, charge, visit) {
     const keys = getInspectableEventKeys(current, kind, availableBytes());
     if (keys === undefined) {
         return false;
@@ -542,7 +589,12 @@ function visitInspectableEventProperties(current, kind, depth, availableBytes, c
     }
     return true;
 }
-function visitRetainedEventPrototypes(current, depth, isBlobInternalHandle, visited, availableBytes, charge, visit, retainPrototype) {
+function visitRetainedEventPrototypes(
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Retention accounting follows arbitrary object prototypes without assuming their properties.
+current, depth, isBlobInternalHandle, visited, availableBytes, charge, visit, 
+// oxlint-disable-next-line anti-slop/no-object-parameters -- The retention callback records prototype identity before inspecting its descriptors.
+retainPrototype) {
+    // SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
     let prototype = Object.getPrototypeOf(current);
     for (let prototypeDepth = depth + 1; prototype !== null; prototypeDepth += 1) {
         if (prototypeDepth >= MAX_BUFFERED_EVENT_DEPTH) {
@@ -587,6 +639,7 @@ function visitRetainedEventPrototypes(current, depth, isBlobInternalHandle, visi
         if (!retained) {
             return false;
         }
+        // SAFETY: Object.getPrototypeOf returns an object or null; this native-prototype inspection does not assume an application-specific instance type.
         prototype = Object.getPrototypeOf(retainedPrototype);
     }
     return true;
@@ -619,6 +672,7 @@ function inspectBufferedEventGraph(value, remainingBytes) {
         }
         return bytes <= remainingBytes;
     };
+    // oxlint-disable-next-line anti-slop/no-object-parameters -- The ledger records object and symbol identities, which have no shared structural contract.
     const addIdentity = (identity) => {
         if (activeNode) {
             activeNode.edges.add(identity);
@@ -627,6 +681,7 @@ function inspectBufferedEventGraph(value, remainingBytes) {
             roots.add(identity);
         }
     };
+    // oxlint-disable-next-line anti-slop/no-object-parameters -- Retained graph nodes are identified by object or symbol identity independently of their fields.
     const retainIdentity = (identity, inspect) => {
         addIdentity(identity);
         const node = { bytes: 0, edges: new Set() };
@@ -651,6 +706,8 @@ function inspectBufferedEventGraph(value, remainingBytes) {
             if (!symbolDescriptionGetter) {
                 return false;
             }
+            // SAFETY: The captured Symbol description getter is called after the symbol branch and returns a string or undefined by its native contract.
+            // oxlint-disable-next-line anti-slop/no-reflect-apply -- Invoke the captured intrinsic without reading its mutable call property.
             const description = Reflect.apply(symbolDescriptionGetter, current, []);
             return charge(8 + (description?.length ?? 0) * 2);
         })) {
@@ -767,7 +824,9 @@ function collectBufferedLedgerIdentities(roots, candidate, records, work) {
     }
     return identities;
 }
-function getBufferedLedgerChange(identity, graph, records, changes, node) {
+function getBufferedLedgerChange(
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Ledger changes are keyed by object or symbol identity, not a structural event type.
+identity, graph, records, changes, node) {
     const existing = changes.get(identity);
     if (existing) {
         if (node) {
@@ -952,6 +1011,7 @@ function createBufferedEventLedger() {
         }
         entry.identities.clear();
     };
+    // oxlint-disable-next-line anti-slop/no-known-value-widening -- The ledger contract contextually types its callbacks and keeps retained-identity internals private.
     return {
         retain(graph) {
             const entry = { scalarBytes: 0, roots: new Set(), identities: new Set() };
@@ -1063,18 +1123,28 @@ export class EventStream {
     abort() {
         this.controller.abort();
     }
+    /** Creates a user-abort error retaining this runner's cancellation reason. */
+    _userAbortError() {
+        const error = new APIUserAbortError();
+        Object.defineProperty(error, 'cause', {
+            value: this.controller.signal.reason,
+            writable: true,
+            configurable: true,
+        });
+        return error;
+    }
     _listenForAbort(signal) {
         if (!signal || this.ended) {
             return;
         }
         if (signal.aborted) {
-            this.controller.abort();
+            __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_abortFromSignal).call(this, signal);
             return;
         }
         if (__classPrivateFieldGet(this, _EventStream_abortListeners, "f").some((registration) => registration.signal === signal)) {
             return;
         }
-        const listener = () => this.controller.abort();
+        const listener = () => __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_abortFromSignal).call(this, signal);
         signal.addEventListener('abort', listener, { once: true });
         __classPrivateFieldGet(this, _EventStream_abortListeners, "f").push({ signal, listener });
     }
@@ -1103,10 +1173,12 @@ export class EventStream {
         if (!listeners) {
             return this;
         }
+        // SAFETY: Listener functions are object identities used as WeakMap keys; registration and removal use the same function instance.
         const emittedRegistration = __classPrivateFieldGet(this, _EventStream_emittedListenerRegistrations, "f").get(listener);
         if (emittedRegistration?.event === event &&
             !emittedRegistration.registration.removed &&
             !emittedRegistration.registration.detached) {
+            // SAFETY: The stored registration event was compared with this event above, preserving the event/listener type correlation.
             __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_removeEmittedListener).call(this, event, emittedRegistration.registration);
             return this;
         }
@@ -1144,6 +1216,7 @@ export class EventStream {
         return new Promise((resolve, reject) => {
             __classPrivateFieldSet(this, _EventStream_catchingPromiseCreated, true, "f");
             const onError = (error) => {
+                // SAFETY: This callback is paired with the same event when registered and removed; its variadic body forwards the event tuple or captured error.
                 this.off(event, onEvent);
                 reject(error);
             };
@@ -1151,11 +1224,14 @@ export class EventStream {
                 if (event !== 'error') {
                     this.off('error', onError);
                 }
+                // SAFETY: The emitted API returns the sole argument or the full tuple according to its existing EventTypes-dependent result contract.
                 resolve((values.length > 1 ? values : values[0]));
             };
             if (event !== 'error') {
+                // SAFETY: This callback is paired with the same event when registered and removed; its variadic body forwards the event tuple or captured error.
                 __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_onceForEmitted).call(this, 'error', onError);
             }
+            // SAFETY: This callback is paired with the same event when registered and removed; its variadic body forwards the event tuple or captured error.
             __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_onceForEmitted).call(this, event, onEvent);
         });
     }
@@ -1182,7 +1258,9 @@ export class EventStream {
                     sdkOwnedBufferedEventArguments.delete(args);
                 }
             };
+            // SAFETY: This callback is paired with the same event when registered and removed; its variadic body forwards the event tuple or captured error.
             this.on(event, onEvent);
+            // SAFETY: This callback is paired with the same event when registered and removed; its variadic body forwards the event tuple or captured error.
             return () => this.off(event, onEvent);
         }, {
             // When iterating the 'error' or 'abort' event itself, yield it as a
@@ -1213,6 +1291,7 @@ export class EventStream {
         let failure;
         let failureDelivered = false;
         let detach = () => undefined;
+        // SAFETY: A completed iterator result has no yielded value; never preserves the iterator public result type for done: true.
         const doneResult = () => ({ value: undefined, done: true });
         const finishReaders = () => {
             while (readQueue.length) {
@@ -1289,10 +1368,12 @@ export class EventStream {
                     return;
                 }
                 if (typeof value === 'object' && value !== null && sdkOwnedBufferedEventArguments.has(value)) {
+                    // SAFETY: Only SDK-created argument tuples are inserted into this private WeakSet, so membership establishes the array identity.
                     const argumentsTuple = value;
                     for (let index = 0; index < argumentsTuple.length; index += 1) {
                         const argument = argumentsTuple[index];
                         if (typeof argument === 'string') {
+                            // SAFETY: The branch checked argument is a string; JSON stringify/parse returns that same string value while detaching retained storage.
                             argumentsTuple[index] = bufferedJSONParse(bufferedJSONStringify(argument));
                         }
                     }
@@ -1429,6 +1510,7 @@ export class EventStream {
         let dispatchThrew = false;
         try {
             if (listeners) {
+                // SAFETY: Filtering only removes registrations from the same event bucket and preserves the listener signatures for that event.
                 __classPrivateFieldGet(this, _EventStream_listeners, "f")[event] = listeners.filter((listener) => {
                     if (listener.once) {
                         listener.detached = true;
@@ -1437,9 +1519,11 @@ export class EventStream {
                 });
                 __classPrivateFieldSet(this, _EventStream_listenerDispatchDepth, __classPrivateFieldGet(this, _EventStream_listenerDispatchDepth, "f") + 1, "f");
                 try {
+                    // SAFETY: The listener bucket and argument tuple come from the same EventTypes key; this bridges TypeScript generic indexed-access correlation.
                     for (const registration of listeners) {
                         if (!registration.removed) {
                             const { listener } = registration;
+                            // SAFETY: The listener bucket and argument tuple come from the same EventTypes key; this bridges TypeScript generic indexed-access correlation.
                             listener(...args);
                         }
                     }
@@ -1480,7 +1564,14 @@ export class EventStream {
         // Hook for subclasses.
     }
 }
-_EventStream_connectedPromise = new WeakMap(), _EventStream_resolveConnectedPromise = new WeakMap(), _EventStream_rejectConnectedPromise = new WeakMap(), _EventStream_endPromise = new WeakMap(), _EventStream_resolveEndPromise = new WeakMap(), _EventStream_rejectEndPromise = new WeakMap(), _EventStream_listeners = new WeakMap(), _EventStream_abortListeners = new WeakMap(), _EventStream_emittedListenerRegistrations = new WeakMap(), _EventStream_pendingListenerCleanup = new WeakMap(), _EventStream_pendingBufferedEventChecks = new WeakMap(), _EventStream_listenerDispatchDepth = new WeakMap(), _EventStream_ended = new WeakMap(), _EventStream_errored = new WeakMap(), _EventStream_aborted = new WeakMap(), _EventStream_catchingPromiseCreated = new WeakMap(), _EventStream_terminalFailure = new WeakMap(), _EventStream_instances = new WeakSet(), _EventStream_removeAbortListeners = function _EventStream_removeAbortListeners() {
+_EventStream_connectedPromise = new WeakMap(), _EventStream_resolveConnectedPromise = new WeakMap(), _EventStream_rejectConnectedPromise = new WeakMap(), _EventStream_endPromise = new WeakMap(), _EventStream_resolveEndPromise = new WeakMap(), _EventStream_rejectEndPromise = new WeakMap(), _EventStream_listeners = new WeakMap(), _EventStream_abortListeners = new WeakMap(), _EventStream_emittedListenerRegistrations = new WeakMap(), _EventStream_pendingListenerCleanup = new WeakMap(), _EventStream_pendingBufferedEventChecks = new WeakMap(), _EventStream_listenerDispatchDepth = new WeakMap(), _EventStream_ended = new WeakMap(), _EventStream_errored = new WeakMap(), _EventStream_aborted = new WeakMap(), _EventStream_catchingPromiseCreated = new WeakMap(), _EventStream_terminalFailure = new WeakMap(), _EventStream_instances = new WeakSet(), _EventStream_abortFromSignal = function _EventStream_abortFromSignal(signal) {
+    try {
+        this.controller.abort(signal.reason);
+    }
+    catch {
+        this.controller.abort();
+    }
+}, _EventStream_removeAbortListeners = function _EventStream_removeAbortListeners() {
     for (const { signal, listener } of __classPrivateFieldGet(this, _EventStream_abortListeners, "f").splice(0)) {
         signal.removeEventListener('abort', listener);
     }
@@ -1494,6 +1585,7 @@ _EventStream_connectedPromise = new WeakMap(), _EventStream_resolveConnectedProm
         listeners?.length === previousLength + 1 &&
         registration?.listener === listener &&
         registration.once) {
+        // SAFETY: Listener functions are object identities used as WeakMap keys; registration and removal use the same function instance.
         __classPrivateFieldGet(this, _EventStream_emittedListenerRegistrations, "f").set(listener, { event, registration });
     }
 }, _EventStream_removeEmittedListener = function _EventStream_removeEmittedListener(event, registration) {
@@ -1501,6 +1593,7 @@ _EventStream_connectedPromise = new WeakMap(), _EventStream_resolveConnectedProm
         return;
     }
     registration.removed = true;
+    // SAFETY: Listener functions are object identities used as WeakMap keys; registration and removal use the same function instance.
     __classPrivateFieldGet(this, _EventStream_emittedListenerRegistrations, "f").delete(registration.listener);
     __classPrivateFieldGet(this, _EventStream_pendingListenerCleanup, "f").add(event);
     if (__classPrivateFieldGet(this, _EventStream_listenerDispatchDepth, "f") === 0) {
@@ -1508,9 +1601,11 @@ _EventStream_connectedPromise = new WeakMap(), _EventStream_resolveConnectedProm
     }
 }, _EventStream_cleanupEmittedListeners = function _EventStream_cleanupEmittedListeners() {
     for (const event of __classPrivateFieldGet(this, _EventStream_pendingListenerCleanup, "f")) {
+        // SAFETY: Pending cleanup keys are added only from registered EventTypes events; the key retains its event-map membership.
         const eventType = event;
         const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[eventType];
         if (listeners) {
+            // SAFETY: Filtering only removes registrations from the same event bucket and preserves the listener signatures for that event.
             __classPrivateFieldGet(this, _EventStream_listeners, "f")[eventType] = listeners.filter((listener) => !listener.removed);
         }
     }
@@ -1518,7 +1613,7 @@ _EventStream_connectedPromise = new WeakMap(), _EventStream_resolveConnectedProm
 }, _EventStream_handleError = function _EventStream_handleError(error) {
     __classPrivateFieldSet(this, _EventStream_errored, true, "f");
     if (error instanceof Error && error.name === 'AbortError') {
-        error = new APIUserAbortError();
+        error = this._userAbortError();
     }
     if (error instanceof APIUserAbortError) {
         __classPrivateFieldSet(this, _EventStream_aborted, true, "f");
@@ -1536,6 +1631,7 @@ _EventStream_connectedPromise = new WeakMap(), _EventStream_resolveConnectedProm
     return this._emit('error', new OpenAIError(String(error)));
 }, _EventStream_settleTerminalEvent = function _EventStream_settleTerminalEvent(event, args, hasListeners) {
     if (event === 'abort') {
+        // SAFETY: The abort event key selects the APIUserAbortError argument tuple established by the typed emit contract.
         const error = args[0];
         __classPrivateFieldSet(this, _EventStream_terminalFailure, __classPrivateFieldGet(this, _EventStream_terminalFailure, "f") ?? { kind: 'abort', error }, "f");
         if (!__classPrivateFieldGet(this, _EventStream_catchingPromiseCreated, "f") && !hasListeners) {
@@ -1548,6 +1644,7 @@ _EventStream_connectedPromise = new WeakMap(), _EventStream_resolveConnectedProm
     }
     if (event === 'error') {
         // NOTE: _emit('error', error) should only be called from #handleError().
+        // SAFETY: The error event is emitted by the error-normalization path, which supplies an OpenAIError as its first argument.
         const error = args[0];
         __classPrivateFieldSet(this, _EventStream_terminalFailure, __classPrivateFieldGet(this, _EventStream_terminalFailure, "f") ?? { kind: 'error', error }, "f");
         if (!__classPrivateFieldGet(this, _EventStream_catchingPromiseCreated, "f") && !hasListeners) {