openai 7.5.0 → 7.6.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()!;
       },
     });
 
@@ -286,6 +336,7 @@ export class Stream<Item> implements AsyncIterable<Item> {
 
 /**
  * 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.
  */

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) {

package/src/helpers/standard-schema.ts

@@ -1,6 +1,11 @@
 import { OpenAIError } from '../error';
 import type { AutoParseableResponseFormat, AutoParseableTextFormat, AutoParseableTool } from '../lib/parser';
-import { makeParseableResponseFormat, makeParseableTextFormat, makeParseableTool } from '../lib/parser';
+import {
+  makeParseableResponseFormat,
+  makeParseableTextFormat,
+  makeParseableTool,
+  parseResponseFormatContent,
+} from '../lib/parser';
 import type { AutoParseableResponseTool } from '../lib/ResponsesParser';
 import { makeParseableResponseTool } from '../lib/ResponsesParser';
 import type { JSONSchema } from '../lib/jsonschema';
@@ -500,11 +505,30 @@ function normalizeStructuredOutputSchema(schema: JSONSchema): JSONSchema {
   return normalizedSchema;
 }
 
+type StandardSchemaBinding<Schema extends StandardSchemaLike> = {
+  standard: Schema['~standard'];
+  validate: Schema['~standard']['validate'];
+};
+
+function bindStandardSchema<Schema extends StandardSchemaLike>(standardSchema: Schema) {
+  let binding: StandardSchemaBinding<Schema> | undefined;
+
+  return (): StandardSchemaBinding<Schema> => {
+    if (!binding) {
+      const standard = standardSchema['~standard'];
+      binding = { standard, validate: standard.validate };
+    }
+    return binding;
+  };
+}
+
 function parseStandardSchema<Schema extends StandardSchemaLike>(
-  standardSchema: Schema,
+  getBinding: () => StandardSchemaBinding<Schema>,
   content: string,
 ): InferStandardOutput<Schema> {
-  const result = standardSchema['~standard'].validate(JSON.parse(content));
+  const parsed = parseResponseFormatContent({ type: 'json_schema', $parseRaw: undefined }, content);
+  const { standard, validate } = getBinding();
+  const result = Reflect.apply(validate, standard, [parsed]);
 
   if (isPromiseLike(result)) {
     void Promise.resolve(result).catch(() => undefined);
@@ -520,11 +544,11 @@ function parseStandardSchema<Schema extends StandardSchemaLike>(
   return result.value as InferStandardOutput<Schema>;
 }
 
-function resolveStandardJSONSchema(
-  standardSchema: StandardSchemaLike,
+function resolveStandardJSONSchema<Schema extends StandardSchemaLike>(
+  getBinding: () => StandardSchemaBinding<Schema>,
   schemaOverride?: JSONSchema | Record<string, unknown> | undefined,
 ): Record<string, unknown> {
-  const schema = (schemaOverride ?? standardSchema['~standard'].jsonSchema?.input({ target: 'draft-07' })) as
+  const schema = (schemaOverride ?? getBinding().standard.jsonSchema?.input({ target: 'draft-07' })) as
     | JSONSchema
     | undefined;
 
@@ -564,6 +588,7 @@ export function standardResponseFormat<Schema extends StandardSchemaLike>(
   props?: StandardResponseFormatProps,
 ): AutoParseableResponseFormat<InferStandardOutput<Schema>> {
   const { schema, ...formatProps } = props ?? {};
+  const getBinding = bindStandardSchema(standardSchema);
 
   return makeParseableResponseFormat<InferStandardOutput<Schema>>(
     {
@@ -572,10 +597,10 @@ export function standardResponseFormat<Schema extends StandardSchemaLike>(
         ...formatProps,
         name,
         strict: true,
-        schema: resolveStandardJSONSchema(standardSchema, schema),
+        schema: resolveStandardJSONSchema(getBinding, schema),
       },
     },
-    (content) => parseStandardSchema(standardSchema, content),
+    (content) => parseStandardSchema(getBinding, content),
   );
 }
 
@@ -602,6 +627,7 @@ export function standardTextFormat<Schema extends StandardSchemaLike>(
   props?: StandardTextFormatProps,
 ): AutoParseableTextFormat<InferStandardOutput<Schema>> {
   const { schema, ...formatProps } = props ?? {};
+  const getBinding = bindStandardSchema(standardSchema);
 
   return makeParseableTextFormat<InferStandardOutput<Schema>>(
     {
@@ -609,9 +635,9 @@ export function standardTextFormat<Schema extends StandardSchemaLike>(
       ...formatProps,
       name,
       strict: true,
-      schema: resolveStandardJSONSchema(standardSchema, schema),
+      schema: resolveStandardJSONSchema(getBinding, schema),
     },
-    (content) => parseStandardSchema(standardSchema, content),
+    (content) => parseStandardSchema(getBinding, content),
   );
 }
 
@@ -678,19 +704,23 @@ export function standardFunction<Parameters extends StandardSchemaLike>(
 export function standardFunction<Parameters extends StandardSchemaLike>(
   options: StandardToolOptions<Parameters>,
 ) {
+  const name = options.name;
+  const parameters = options.parameters;
+  const getBinding = bindStandardSchema(parameters);
+
   return makeParseableTool<any>(
     {
       type: 'function',
       function: {
-        name: options.name,
-        parameters: resolveStandardJSONSchema(options.parameters, options.schema),
+        name,
+        parameters: resolveStandardJSONSchema(getBinding, options.schema),
         strict: true,
         ...(options.description ? { description: options.description } : undefined),
       },
     },
     {
       callback: options.function,
-      parser: (args) => parseStandardSchema(options.parameters, args),
+      parser: (args) => parseStandardSchema(getBinding, args),
     },
   );
 }
@@ -757,17 +787,21 @@ export function standardResponsesFunction<Parameters extends StandardSchemaLike>
 export function standardResponsesFunction<Parameters extends StandardSchemaLike>(
   options: StandardToolOptions<Parameters>,
 ) {
+  const name = options.name;
+  const parameters = options.parameters;
+  const getBinding = bindStandardSchema(parameters);
+
   return makeParseableResponseTool<any>(
     {
       type: 'function',
-      name: options.name,
-      parameters: resolveStandardJSONSchema(options.parameters, options.schema),
+      name,
+      parameters: resolveStandardJSONSchema(getBinding, options.schema),
       strict: true,
       ...(options.description ? { description: options.description } : undefined),
     },
     {
       callback: options.function,
-      parser: (args) => parseStandardSchema(options.parameters, args),
+      parser: (args) => parseStandardSchema(getBinding, args),
     },
   );
 }