openai 7.5.0 → 7.7.0

package/src/core/EventEmitter.ts

@@ -4,6 +4,8 @@ type EventListener<Events, EventType extends keyof Events> = Events[EventType];
 type EventListeners<Events, EventType extends keyof Events> = {
   listener: EventListener<Events, EventType>;
   once?: boolean;
+  removed?: boolean;
+  detached?: boolean;
 }[];
 
 /** Extracts the ordered listener-argument tuple for one named event. */
@@ -17,6 +19,12 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
   #listeners: {
     [Event in keyof EventTypes]?: EventListeners<EventTypes, Event>;
   } = Object.create(null);
+  #emittedListenerRegistrations = new WeakMap<
+    object,
+    { event: PropertyKey; registration: { removed?: boolean; detached?: boolean } }
+  >();
+  #pendingListenerCleanup = new Set<PropertyKey>();
+  #listenerDispatchDepth = 0;
 
   /**
    * Adds the listener function to the end of the listeners array for the event.
@@ -43,7 +51,22 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
     if (!listeners) {
       return this;
     }
-    const index = listeners.findIndex((l) => l.listener === listener);
+
+    const emittedRegistration = this.#emittedListenerRegistrations.get(listener as object);
+    if (
+      emittedRegistration?.event === event &&
+      !emittedRegistration.registration.removed &&
+      !emittedRegistration.registration.detached
+    ) {
+      this.#removeEmittedListener(
+        event,
+        emittedRegistration.registration as EventListeners<EventTypes, Event>[number],
+      );
+      return this;
+    }
+    const index = listeners.findIndex(
+      (registration) => !registration.removed && registration.listener === listener,
+    );
     if (index !== -1) {
       listeners.splice(index, 1);
     }
@@ -61,6 +84,52 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
     return this;
   }
 
+  #onceForEmitted<Event extends keyof EventTypes>(
+    event: Event,
+    listener: EventListener<EventTypes, Event>,
+  ): void {
+    const previousListeners = this.#listeners[event];
+    const previousLength = previousListeners?.length ?? 0;
+    this.once(event, listener);
+    const listeners = this.#listeners[event];
+    const [registration] = listeners?.slice(-1) ?? [];
+    if (
+      (previousListeners === undefined || listeners === previousListeners) &&
+      listeners?.length === previousLength + 1 &&
+      registration?.listener === listener &&
+      registration.once
+    ) {
+      this.#emittedListenerRegistrations.set(listener as object, { event, registration });
+    }
+  }
+
+  #removeEmittedListener<Event extends keyof EventTypes>(
+    event: Event,
+    registration: EventListeners<EventTypes, Event>[number],
+  ): void {
+    if (registration.removed) {
+      return;
+    }
+
+    registration.removed = true;
+    this.#emittedListenerRegistrations.delete(registration.listener as object);
+    this.#pendingListenerCleanup.add(event);
+    if (this.#listenerDispatchDepth === 0) {
+      this.#cleanupEmittedListeners();
+    }
+  }
+
+  #cleanupEmittedListeners(): void {
+    for (const event of this.#pendingListenerCleanup) {
+      const eventType = event as keyof EventTypes;
+      const listeners = this.#listeners[eventType];
+      if (listeners) {
+        this.#listeners[eventType] = listeners.filter((listener) => !listener.removed) as any;
+      }
+    }
+    this.#pendingListenerCleanup.clear();
+  }
+
   /**
    * This is similar to `.once()`, but returns a Promise that resolves the next time
    * the event is triggered, instead of calling a listener callback.
@@ -98,9 +167,9 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
       };
 
       if (event !== 'error') {
-        this.once('error', listeners.onError as any);
+        this.#onceForEmitted('error', listeners.onError as any);
       }
-      this.once(event, listeners.onEvent as any);
+      this.#onceForEmitted(event, listeners.onEvent as any);
     });
   }
 
@@ -111,16 +180,31 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
   ) {
     const listeners: EventListeners<EventTypes, Event> | undefined = this.#listeners[event];
     if (listeners) {
-      this.#listeners[event] = listeners.filter((l) => !l.once) as any;
-      for (const { listener } of listeners as any) {
-        listener(...(args as any));
+      this.#listeners[event] = listeners.filter((listener) => {
+        if (listener.once) {
+          listener.detached = true;
+        }
+        return !listener.once && !listener.removed;
+      }) as any;
+      this.#listenerDispatchDepth += 1;
+      try {
+        for (const registration of listeners as any) {
+          if (!registration.removed) {
+            registration.listener(...(args as any));
+          }
+        }
+      } finally {
+        this.#listenerDispatchDepth -= 1;
+        if (this.#listenerDispatchDepth === 0) {
+          this.#cleanupEmittedListeners();
+        }
       }
     }
   }
 
   protected _hasListener(event: keyof EventTypes): boolean {
     const listeners = this.#listeners[event];
-    return listeners && listeners.length > 0;
+    return listeners && listeners.some((listener) => !listener.removed);
   }
 }
 

package/src/core/streaming.ts

@@ -9,6 +9,45 @@ import type { OpenAI } from '../client';
 
 type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
 
+type StreamTeeQueue<Item> = {
+  readonly length: number;
+  enqueue: (value: Promise<IteratorResult<Item>>) => void;
+  dequeue: () => Promise<IteratorResult<Item>> | undefined;
+};
+
+function createStreamTeeQueue<Item>(): StreamTeeQueue<Item> {
+  let entries: (Promise<IteratorResult<Item>> | undefined)[] = [];
+  let head = 0;
+
+  return {
+    get length() {
+      return entries.length - head;
+    },
+    enqueue(value) {
+      entries.push(value);
+    },
+    dequeue() {
+      if (head === entries.length) {
+        return undefined;
+      }
+
+      const value = entries[head];
+      entries[head] = undefined;
+      head += 1;
+
+      if (head === entries.length) {
+        entries = [];
+        head = 0;
+      } else if (head >= 1024 && head * 2 >= entries.length) {
+        entries = entries.slice(head);
+        head = 0;
+      }
+
+      return value;
+    },
+  };
+}
+
 /** A decoded server-sent event before its JSON payload has been parsed. */
 export type ServerSentEvent = {
   /** Explicit SSE event name, or `null` when the event has no `event:` field. */
@@ -64,7 +103,7 @@ export class Stream<Item> implements AsyncIterable<Item> {
       let receivedCompletionSentinel = false;
       try {
         for await (const sse of _iterSSEMessages(response, controller)) {
-          if (sse.data.startsWith('[DONE]')) {
+          if (sse.data === '[DONE]') {
             receivedCompletionSentinel = true;
             break;
           }
@@ -74,10 +113,14 @@ export class Stream<Item> implements AsyncIterable<Item> {
 
             try {
               data = JSON.parse(sse.data) as any;
-            } catch (e) {
-              logger.error(`Could not parse message into JSON:`, sse.data);
-              logger.error(`From chunk:`, sse.raw);
-              throw e;
+            } catch {
+              logger.error(`Could not parse message into JSON:`);
+              logger.error(`From chunk:`);
+              throw new SyntaxError('Error reading response: malformed server-sent event JSON.');
+            }
+
+            if (sse.event === 'error') {
+              throw new APIError(undefined, data?.error ?? data, undefined, response.headers);
             }
 
             if (data && data.error) {
@@ -89,14 +132,10 @@ export class Stream<Item> implements AsyncIterable<Item> {
             let data;
             try {
               data = JSON.parse(sse.data);
-            } catch (e) {
-              console.error(`Could not parse message into JSON:`, sse.data);
-              console.error(`From chunk:`, sse.raw);
-              throw e;
-            }
-            // SSE error events surface as APIError instances.
-            if (sse.event === 'error') {
-              throw new APIError(undefined, data.error, data.message, undefined);
+            } catch {
+              logger.error(`Could not parse message into JSON:`);
+              logger.error(`From chunk:`);
+              throw new SyntaxError('Error reading response: malformed server-sent event JSON.');
             }
             yield { event: sse.event, data } as any;
           }
@@ -199,7 +238,18 @@ export class Stream<Item> implements AsyncIterable<Item> {
             continue;
           }
           if (line) {
-            yield JSON.parse(line) as Item;
+            let data: Item;
+            try {
+              data = JSON.parse(line) as Item;
+            } catch (error) {
+              if (error instanceof SyntaxError) {
+                throw new SyntaxError('Error reading response: malformed newline-delimited JSON.');
+              }
+
+              throw error;
+            }
+
+            yield data;
           }
         }
         done = true;
@@ -230,18 +280,18 @@ export class Stream<Item> implements AsyncIterable<Item> {
    * independently read from at different speeds.
    */
   tee(): [Stream<Item>, Stream<Item>] {
-    const left: Promise<IteratorResult<Item>>[] = [];
-    const right: Promise<IteratorResult<Item>>[] = [];
+    const left = createStreamTeeQueue<Item>();
+    const right = createStreamTeeQueue<Item>();
     const iterator = this.iterator();
 
-    const teeIterator = (queue: Promise<IteratorResult<Item>>[]): AsyncIterator<Item> => ({
+    const teeIterator = (queue: StreamTeeQueue<Item>): AsyncIterator<Item> => ({
       next: () => {
         if (queue.length === 0) {
           const result = iterator.next();
-          left.push(result);
-          right.push(result);
+          left.enqueue(result);
+          right.enqueue(result);
         }
-        return queue.shift()!;
+        return queue.dequeue()!;
       },
     });
 
@@ -284,8 +334,131 @@ export class Stream<Item> implements AsyncIterable<Item> {
   }
 }
 
+function createAbortableSSESource(body: NonNullable<Response['body']>, signal: AbortSignal) {
+  const reader = typeof body.getReader === 'function' ? body.getReader() : undefined;
+  const source = reader
+    ? {
+        next: () => reader.read(),
+        return: () => reader.cancel(),
+      }
+    : ReadableStreamToAsyncIterable<Bytes>(body)[Symbol.asyncIterator]();
+  const ended: IteratorResult<Bytes> = { value: undefined, done: true };
+  let closed = false;
+  let canceled = false;
+  let cancellation: Promise<unknown> | undefined;
+  let interrupt: (() => void) | undefined;
+
+  const waitForAbort = () =>
+    // oxlint-disable-next-line promise/avoid-new -- AbortSignal callbacks need a portable Promise bridge.
+    new Promise<void>((resolve) => {
+      interrupt = resolve;
+    });
+
+  const cancel = () => {
+    if (canceled || closed) {
+      return cancellation;
+    }
+    canceled = true;
+    try {
+      cancellation = Promise.resolve(source.return?.());
+    } catch (error) {
+      cancellation = Promise.reject(error);
+    }
+    cancellation.catch(() => undefined);
+    return cancellation;
+  };
+  const abort = () => {
+    queueMicrotask(() => {
+      interrupt?.();
+      cancel();
+    });
+  };
+  const iterator: AsyncIterableIterator<Bytes> = {
+    async next() {
+      if (signal.aborted) {
+        return ended;
+      }
+      const aborted = waitForAbort().then(() => ended);
+      try {
+        const result = await Promise.race([source.next(), aborted]);
+        if (signal.aborted) {
+          return ended;
+        }
+        if (result.done) {
+          closed = true;
+          return ended;
+        }
+        return { value: result.value, done: false };
+      } catch (error) {
+        if (signal.aborted && (isAbortError(error) || error === signal.reason)) {
+          return ended;
+        }
+        throw error;
+      } finally {
+        interrupt = undefined;
+      }
+    },
+    async return() {
+      const pending = cancel();
+      if (pending && !signal.aborted) {
+        const aborted = waitForAbort();
+        try {
+          if (!signal.aborted) {
+            await Promise.race([pending, aborted]);
+          }
+        } finally {
+          interrupt = undefined;
+        }
+      }
+      return ended;
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+
+  return {
+    iterator,
+    start() {
+      signal.addEventListener('abort', abort, { once: true });
+      if (signal.aborted) {
+        abort();
+      }
+    },
+    async cleanup(failed: boolean) {
+      let cleanupError: unknown;
+      try {
+        signal.removeEventListener('abort', abort);
+      } catch (error) {
+        cleanupError = error;
+      }
+      if (!closed) {
+        const pending = cancel();
+        if (pending && !failed && !signal.aborted) {
+          try {
+            await pending;
+          } catch (error) {
+            cleanupError ??= error;
+          }
+        }
+      }
+      if (reader) {
+        try {
+          reader.releaseLock();
+        } catch (error) {
+          cleanupError ??= error;
+        }
+      }
+      if (cleanupError !== undefined && !failed && !signal.aborted) {
+        throw cleanupError;
+      }
+    },
+  };
+}
+
 /**
  * Decodes complete SSE records from a response and aborts when its body is absent.
+ * Complete events are decoded on demand without imposing a line or event size limit.
  *
  * @yields {ServerSentEvent} Each decoded server-sent event in wire order.
  */
@@ -308,22 +481,45 @@ export async function* _iterSSEMessages(
 
   const sseDecoder = new SSEDecoder();
   const lineDecoder = new LineDecoder();
-
-  const iter = ReadableStreamToAsyncIterable<Bytes>(response.body);
-  for await (const sseChunk of iterSSEChunks(iter)) {
-    for (const line of lineDecoder.decode(sseChunk)) {
+  const { signal } = controller;
+  const source = createAbortableSSESource(response.body, signal);
+  let failed = false;
+
+  try {
+    source.start();
+    for await (const sseChunk of iterSSEChunks(source.iterator)) {
+      if (signal.aborted) {
+        return;
+      }
+      for (const line of lineDecoder.decode(sseChunk)) {
+        if (signal.aborted) {
+          return;
+        }
+        const sse = sseDecoder.decode(line);
+        if (sse) {
+          yield sse;
+        }
+      }
+    }
+    if (signal.aborted) {
+      return;
+    }
+    for (const line of lineDecoder.flush()) {
+      if (signal.aborted) {
+        return;
+      }
       const sse = sseDecoder.decode(line);
       if (sse) {
         yield sse;
       }
     }
-  }
-
-  for (const line of lineDecoder.flush()) {
-    const sse = sseDecoder.decode(line);
-    if (sse) {
-      yield sse;
+  } catch (error) {
+    failed = true;
+    if (!signal.aborted || (!isAbortError(error) && error !== signal.reason)) {
+      throw error;
     }
+  } finally {
+    await source.cleanup(failed);
   }
 }
 

package/src/helpers/audio.ts

@@ -100,7 +100,7 @@ export async function playAudio(input: NodeJS.ReadableStream | Response | File):
 
 /** Controls microphone selection and when an in-progress recording is finalized. */
 type RecordAudioOptions = {
-  /** Stops recording when aborted and resolves with the audio captured so far. */
+  /** Stops recording when aborted; successful termination returns the captured audio. */
   signal?: AbortSignal;
 
   /** Zero-based audio-input device number passed to FFmpeg; defaults to `0`. */
@@ -110,6 +110,14 @@ type RecordAudioOptions = {
   timeout?: number;
 };
 
+function removeRecordingAbortListener(signal: AbortSignal | undefined, listener: () => void): void {
+  try {
+    signal?.removeEventListener('abort', listener);
+  } catch {
+    // A cleanup callback must not replace the recording's terminal outcome.
+  }
+}
+
 function nodejsRecordAudio({ signal, device, timeout }: RecordAudioOptions = {}): Promise<File> {
   checkFileSupport();
   return new Promise((resolve, reject) => {
@@ -119,27 +127,48 @@ function nodejsRecordAudio({ signal, device, timeout }: RecordAudioOptions = {})
     let internalSignal: AbortSignal | undefined;
     let wasStopped = false;
     let settled = false;
+    let callerAbortObserved = false;
+    let timeoutAbortObserved = false;
+    let rejectRecording: (error: unknown) => void = reject;
 
     const collectData = (chunk: Buffer) => {
-      data.push(chunk);
+      if (!settled) {
+        data.push(chunk);
+      }
     };
     const stopRecording = () => {
       if (!settled && ffmpeg) {
-        wasStopped ||= ffmpeg.kill('SIGTERM');
+        try {
+          wasStopped ||= ffmpeg.kill('SIGTERM');
+        } catch (error) {
+          rejectRecording(error);
+        }
       }
     };
+    const stopCallerRecording = () => {
+      callerAbortObserved = true;
+      stopRecording();
+    };
+    const stopTimeoutRecording = () => {
+      timeoutAbortObserved = true;
+      stopRecording();
+    };
     const cleanup = () => {
       if (settled) {
         return false;
       }
 
       settled = true;
-      signal?.removeEventListener('abort', stopRecording);
-      internalSignal?.removeEventListener('abort', stopRecording);
-      ffmpeg?.stdout?.removeListener('data', collectData);
+      removeRecordingAbortListener(signal, stopCallerRecording);
+      removeRecordingAbortListener(internalSignal, stopTimeoutRecording);
+      try {
+        ffmpeg?.stdout?.removeListener('data', collectData);
+      } catch {
+        // Continue settling even when the output stream rejects cleanup.
+      }
       return true;
     };
-    const rejectRecording = (error: unknown) => {
+    rejectRecording = (error: unknown) => {
       if (cleanup()) {
         reject(error);
       }
@@ -154,6 +183,35 @@ function nodejsRecordAudio({ signal, device, timeout }: RecordAudioOptions = {})
       resolve(audioFile);
     };
 
+    const observeTimeout = () => {
+      internalSignal?.addEventListener('abort', stopTimeoutRecording, { once: true });
+      if (settled) {
+        removeRecordingAbortListener(internalSignal, stopTimeoutRecording);
+        return false;
+      }
+
+      if (internalSignal && !timeoutAbortObserved && internalSignal.aborted) {
+        stopTimeoutRecording();
+      }
+      return !settled;
+    };
+    const observeCaller = () => {
+      if (!signal) {
+        return;
+      }
+      if (signal.aborted) {
+        stopRecording();
+        return;
+      }
+
+      signal.addEventListener('abort', stopCallerRecording, { once: true });
+      if (settled) {
+        removeRecordingAbortListener(signal, stopCallerRecording);
+      } else if (!callerAbortObserved && signal.aborted) {
+        stopCallerRecording();
+      }
+    };
+
     try {
       if (typeof timeout === 'number' && (timeout > 0 || Number.isNaN(timeout))) {
         internalSignal = AbortSignal.timeout(timeout);
@@ -182,8 +240,16 @@ function nodejsRecordAudio({ signal, device, timeout }: RecordAudioOptions = {})
       ffmpeg.stdout?.on('data', collectData);
 
       ffmpeg.on('error', (error) => {
-        console.error(error);
-        rejectRecording(error);
+        if (!cleanup()) {
+          return;
+        }
+
+        try {
+          console.error(error);
+        } catch {
+          // A custom logger must not hide the original process failure.
+        }
+        reject(error);
       });
 
       ffmpeg.on('close', (code) => {
@@ -194,18 +260,23 @@ function nodejsRecordAudio({ signal, device, timeout }: RecordAudioOptions = {})
         returnData();
       });
 
-      internalSignal?.addEventListener('abort', stopRecording, { once: true });
+      if (settled || !observeTimeout()) {
+        return;
+      }
+      observeCaller();
+    } catch (error) {
+      if (!cleanup()) {
+        return;
+      }
 
-      if (signal) {
-        if (signal.aborted) {
-          stopRecording();
-        } else {
-          signal.addEventListener('abort', stopRecording, { once: true });
+      try {
+        if (!wasStopped) {
+          ffmpeg?.kill('SIGTERM');
         }
+      } catch {
+        // Preserve the original setup error when process termination also fails.
       }
-    } catch (error) {
-      stopRecording();
-      rejectRecording(error);
+      reject(error);
     }
   });
 }
@@ -216,13 +287,13 @@ function nodejsRecordAudio({ signal, device, timeout }: RecordAudioOptions = {})
  * This helper is supported only in Node.js-compatible runtimes and requires
  * the `ffmpeg` executable from FFmpeg to be available on `PATH`. Recording
  * continues until the FFmpeg process exits, the supplied signal is aborted, or
- * a positive timeout elapses. Aborting or timing out finalizes and returns the
- * audio captured so far instead of rejecting.
+ * a positive timeout elapses. Successful cancellation returns the audio captured
+ * so far; if sending `SIGTERM` throws, recording rejects with that error.
  *
  * @param options Audio-input device, optional abort signal, and recording timeout.
  * @returns The captured WAV file with MIME type `audio/wav`.
- * @throws {Error} If recording is unsupported, `ffmpeg` cannot start, or the
- * recording process exits unsuccessfully before an intentional stop.
+ * @throws {Error} If recording is unsupported, `ffmpeg` cannot start or exits
+ * unsuccessfully before an intentional stop, or sending it `SIGTERM` throws.
  */
 export async function recordAudio(options: RecordAudioOptions = {}): Promise<File> {
   if (isNode) {