openai 6.46.0 → 6.48.0

package/src/lib/AbstractChatCompletionRunner.ts

@@ -15,10 +15,15 @@ import type {
   ParsedChatCompletion,
 } from '../resources/chat/completions';
 import type { CompletionUsage } from '../resources/completions';
-import type { ChatCompletionRunner, ChatCompletionToolRunnerParams } from './ChatCompletionRunner';
+import type {
+  ChatCompletionRunner,
+  ChatCompletionToolRunnerParamsWithContext,
+  ChatCompletionToolRunnerParamsWithoutContext,
+} from './ChatCompletionRunner';
 import type {
   ChatCompletionStreamingRunner,
-  ChatCompletionStreamingToolRunnerParams,
+  ChatCompletionStreamingToolRunnerParamsWithContext,
+  ChatCompletionStreamingToolRunnerParamsWithoutContext,
 } from './ChatCompletionStreamingRunner';
 import { isAssistantMessage, isToolMessage } from './chatCompletionUtils';
 import { BaseEvents, EventStream } from './EventStream';
@@ -285,16 +290,19 @@ export class AbstractChatCompletionRunner<
     return await this._createChatCompletion(client, params, options);
   }
 
-  protected async _runTools<FunctionsArgs extends BaseFunctionsArgs>(
+  protected async _runTools<FunctionsArgs extends BaseFunctionsArgs, ToolContext>(
     client: OpenAI,
     params:
-      | ChatCompletionToolRunnerParams<FunctionsArgs>
-      | ChatCompletionStreamingToolRunnerParams<FunctionsArgs>,
+      | ChatCompletionToolRunnerParamsWithContext<FunctionsArgs, ToolContext>
+      | ChatCompletionToolRunnerParamsWithoutContext<FunctionsArgs>
+      | ChatCompletionStreamingToolRunnerParamsWithContext<FunctionsArgs, ToolContext>
+      | ChatCompletionStreamingToolRunnerParamsWithoutContext<FunctionsArgs>,
     runner: ChatCompletionRunner<any> | ChatCompletionStreamingRunner<any>,
     options?: RunnerOptions,
   ) {
     const role = 'tool' as const;
-    const { tool_choice = 'auto', stream, ...restParams } = params;
+    const { tool_choice = 'auto', stream, toolContext: inputToolContext, ...restParams } = params;
+    const toolContext = inputToolContext as ToolContext;
     const singleFunctionToCall =
       typeof tool_choice !== 'string' && tool_choice.type === 'function' && tool_choice?.function?.name;
     const { maxChatCompletions = DEFAULT_MAX_CHAT_COMPLETIONS, afterCompletion } = options || {};
@@ -322,7 +330,7 @@ export class AbstractChatCompletionRunner<
       return tool as any as RunnableToolFunction<any>;
     });
 
-    const functionsByName: Record<string, RunnableFunction<any>> = {};
+    const functionsByName: Record<string, RunnableFunction<any, ToolContext>> = {};
     for (const f of inputTools) {
       if (f.type === 'function') {
         functionsByName[f.function.name || f.function.function.name] = f.function;
@@ -389,9 +397,9 @@ export class AbstractChatCompletionRunner<
           const content = error instanceof Error ? error.message : String(error);
           return { message: { role, tool_call_id, content }, functionCalled: false };
         }
-        rawContent = await fn.function(parsed, runner);
+        rawContent = await fn.function(parsed, runner, toolContext);
       } else {
-        rawContent = await fn.function(args, runner);
+        rawContent = await fn.function(args, runner, toolContext);
       }
 
       const content = this.#stringifyFunctionCallResult(rawContent);

package/src/lib/AssistantStream.ts

@@ -103,11 +103,12 @@ export class AssistantStream
 
     //Catch all for passing along all events
     this.on('event', (event) => {
+      const eventCopy = structuredClone(event);
       const reader = readQueue.shift();
       if (reader) {
-        reader.resolve(event);
+        reader.resolve(eventCopy);
       } else {
-        pushQueue.push(event);
+        pushQueue.push(eventCopy);
       }
     });
 

package/src/lib/ChatCompletionRunner.ts

@@ -16,20 +16,60 @@ export interface ChatCompletionRunnerEvents extends AbstractChatCompletionRunner
   content: (content: string) => void;
 }
 
-export type ChatCompletionToolRunnerParams<FunctionsArgs extends BaseFunctionsArgs> = Omit<
-  ChatCompletionCreateParamsNonStreaming,
-  'tools'
-> & {
-  tools: RunnableTools<FunctionsArgs> | AutoParseableTool<any, true>[];
+type ChatCompletionToolRunnerParamsBase = Omit<ChatCompletionCreateParamsNonStreaming, 'tools'>;
+
+/**
+ * Parameters for tools that do not require a context value.
+ */
+export type ChatCompletionToolRunnerParamsWithoutContext<FunctionsArgs extends BaseFunctionsArgs> =
+  ChatCompletionToolRunnerParamsBase & {
+    tools: RunnableTools<FunctionsArgs> | AutoParseableTool<any, true>[];
+    toolContext?: never;
+  };
+
+/**
+ * Parameters for tools that require a context value.
+ */
+export type ChatCompletionToolRunnerParamsWithContext<
+  FunctionsArgs extends BaseFunctionsArgs,
+  ToolContext,
+> = ChatCompletionToolRunnerParamsBase & {
+  tools: RunnableTools<FunctionsArgs, ToolContext> | AutoParseableTool<any, true>[];
+  /**
+   * Context to pass to each tool callback during this run.
+   */
+  toolContext: ToolContext;
 };
 
+/**
+ * Parameters for running tools. Supplying a context type makes `toolContext`
+ * required; omitting it preserves the existing no-context form.
+ */
+export type ChatCompletionToolRunnerParams<FunctionsArgs extends BaseFunctionsArgs, ToolContext = never> = [
+  ToolContext,
+] extends [never] ?
+  ChatCompletionToolRunnerParamsWithoutContext<FunctionsArgs>
+: ChatCompletionToolRunnerParamsWithContext<FunctionsArgs, ToolContext>;
+
 export class ChatCompletionRunner<ParsedT = null> extends AbstractChatCompletionRunner<
   ChatCompletionRunnerEvents,
   ParsedT
 > {
+  static runTools<ParsedT, ToolContext = unknown>(
+    client: OpenAI,
+    params: ChatCompletionToolRunnerParamsWithContext<any[], ToolContext>,
+    options?: RunnerOptions,
+  ): ChatCompletionRunner<ParsedT>;
   static runTools<ParsedT>(
     client: OpenAI,
-    params: ChatCompletionToolRunnerParams<any[]>,
+    params: ChatCompletionToolRunnerParamsWithoutContext<any[]>,
+    options?: RunnerOptions,
+  ): ChatCompletionRunner<ParsedT>;
+  static runTools<ParsedT, ToolContext = unknown>(
+    client: OpenAI,
+    params:
+      | ChatCompletionToolRunnerParamsWithContext<any[], ToolContext>
+      | ChatCompletionToolRunnerParamsWithoutContext<any[]>,
     options?: RunnerOptions,
   ): ChatCompletionRunner<ParsedT> {
     const runner = new ChatCompletionRunner<ParsedT>();

package/src/lib/ChatCompletionStream.ts

@@ -26,6 +26,7 @@ import {
   type ChatCompletionCreateParams,
   type ChatCompletionCreateParamsBase,
   type ChatCompletionCreateParamsStreaming,
+  type ChatCompletionMessageParam,
   type ChatCompletionRole,
 } from '../resources/chat/completions/completions';
 import { Stream } from '../streaming';
@@ -118,6 +119,69 @@ export type ChatCompletionStreamParams = Omit<ChatCompletionCreateParamsBase, 's
   stream?: true;
 };
 
+type ChatCompletionReadableStreamMessage = {
+  type: 'message';
+  message: ChatCompletionMessageParam;
+  tool_call_ids?: string[];
+};
+
+// Keep message records readable as empty chunks by older SDKs. Their finalizer
+// overwrites `object`, so the encoded payload does not leak into completions.
+const CHAT_COMPLETION_READABLE_STREAM_MESSAGE_PREFIX = 'chat.completion.chunk.message:';
+
+type ChatCompletionReadableStreamMessageChunk = Pick<ChatCompletionChunk, 'id' | 'created' | 'model'> & {
+  choices: [];
+  object: `${typeof CHAT_COMPLETION_READABLE_STREAM_MESSAGE_PREFIX}${string}`;
+};
+
+export type ChatCompletionReadableStreamItem =
+  | ChatCompletionChunk
+  | ChatCompletionReadableStreamMessage
+  | ChatCompletionReadableStreamMessageChunk;
+
+export function makeChatCompletionReadableStreamMessageChunk(
+  chunk: ChatCompletionChunk,
+  message: ChatCompletionMessageParam,
+  toolCallIds?: string[],
+): ChatCompletionReadableStreamMessageChunk {
+  const payload: ChatCompletionReadableStreamMessage = {
+    type: 'message',
+    message,
+    ...(toolCallIds ? { tool_call_ids: toolCallIds } : {}),
+  };
+
+  return {
+    id: chunk.id,
+    choices: [],
+    created: chunk.created,
+    model: chunk.model,
+    object: `${CHAT_COMPLETION_READABLE_STREAM_MESSAGE_PREFIX}${JSON.stringify(payload)}`,
+  };
+}
+
+function isChatCompletionReadableStreamMessage(
+  item: ChatCompletionReadableStreamItem,
+): item is ChatCompletionReadableStreamMessage | ChatCompletionReadableStreamMessageChunk {
+  return (
+    ('type' in item && item.type === 'message' && 'message' in item) ||
+    ('object' in item &&
+      typeof item.object === 'string' &&
+      item.object.startsWith(CHAT_COMPLETION_READABLE_STREAM_MESSAGE_PREFIX))
+  );
+}
+
+function getChatCompletionReadableStreamMessage(
+  item: ChatCompletionReadableStreamMessage | ChatCompletionReadableStreamMessageChunk,
+): ChatCompletionReadableStreamMessage {
+  if ('type' in item) {
+    return item;
+  }
+
+  return JSON.parse(
+    item.object.slice(CHAT_COMPLETION_READABLE_STREAM_MESSAGE_PREFIX.length),
+  ) as ChatCompletionReadableStreamMessage;
+}
+
 interface ChoiceEventState {
   content_done: boolean;
   refusal_done: boolean;
@@ -205,27 +269,28 @@ export class ChatCompletionStream<ParsedT = null>
 
     for (const choice of chunk.choices) {
       const choiceSnapshot = completion.choices[choice.index]!;
+      const { delta } = choice;
 
       if (
-        choice.delta.content != null &&
+        delta?.content != null &&
         choiceSnapshot.message?.role === 'assistant' &&
         choiceSnapshot.message?.content
       ) {
-        this._emit('content', choice.delta.content, choiceSnapshot.message.content);
+        this._emit('content', delta.content, choiceSnapshot.message.content);
         this._emit('content.delta', {
-          delta: choice.delta.content,
+          delta: delta.content,
           snapshot: choiceSnapshot.message.content,
           parsed: choiceSnapshot.message.parsed,
         });
       }
 
       if (
-        choice.delta.refusal != null &&
+        delta?.refusal != null &&
         choiceSnapshot.message?.role === 'assistant' &&
         choiceSnapshot.message?.refusal
       ) {
         this._emit('refusal.delta', {
-          delta: choice.delta.refusal,
+          delta: delta.refusal,
           snapshot: choiceSnapshot.message.refusal,
         });
       }
@@ -254,7 +319,7 @@ export class ChatCompletionStream<ParsedT = null>
         }
       }
 
-      for (const toolCall of choice.delta.tool_calls ?? []) {
+      for (const toolCall of delta?.tool_calls ?? []) {
         if (state.current_tool_call_index !== toolCall.index) {
           this.#emitContentDoneEvents(choiceSnapshot);
 
@@ -267,7 +332,7 @@ export class ChatCompletionStream<ParsedT = null>
         state.current_tool_call_index = toolCall.index;
       }
 
-      for (const toolCallDelta of choice.delta.tool_calls ?? []) {
+      for (const toolCallDelta of delta?.tool_calls ?? []) {
         const toolCallSnapshot = choiceSnapshot.message.tool_calls?.[toolCallDelta.index];
         if (!toolCallSnapshot?.type) {
           continue;
@@ -398,21 +463,51 @@ export class ChatCompletionStream<ParsedT = null>
     this._listenForAbort(options?.signal);
     this.#beginRequest();
     this._connected();
-    const stream = Stream.fromReadableStream<ChatCompletionChunk>(readableStream, this.controller);
+    const stream = Stream.fromReadableStream<ChatCompletionReadableStreamItem>(
+      readableStream,
+      this.controller,
+    );
     let chatId;
-    for await (const chunk of stream) {
-      if (chatId && chatId !== chunk.id) {
+    for await (const item of stream) {
+      if (isChatCompletionReadableStreamMessage(item)) {
+        const message = getChatCompletionReadableStreamMessage(item);
+        if (this.#currentChatCompletionSnapshot) {
+          const toolCalls = this.#currentChatCompletionSnapshot.choices[0]?.message.tool_calls;
+          for (const [index, id] of message.tool_call_ids?.entries() ?? []) {
+            const toolCall = toolCalls?.[index];
+            if (toolCall && id) {
+              toolCall.id = id;
+            }
+          }
+
+          this._addChatCompletion(this.#endRequest());
+          chatId = undefined;
+        }
+        this._addMessage(message.message);
+        continue;
+      }
+
+      const chunk = item;
+
+      if (chatId && chunk.id && chatId !== chunk.id) {
         // A new request has been made.
         this._addChatCompletion(this.#endRequest());
       }
 
       this.#addChunk(chunk);
-      chatId = chunk.id;
+      if (chunk.id) chatId = chunk.id;
     }
     if (stream.controller.signal?.aborted) {
       throw new APIUserAbortError();
     }
-    return this._addChatCompletion(this.#endRequest());
+    if (this.#currentChatCompletionSnapshot) {
+      return this._addChatCompletion(this.#endRequest());
+    }
+    const lastChatCompletion = this._chatCompletions[this._chatCompletions.length - 1];
+    if (lastChatCompletion) {
+      return lastChatCompletion;
+    }
+    throw new OpenAIError(`request ended without sending any chunks`);
   }
 
   #getAutoParseableResponseFormat(): AutoParseableResponseFormat<ParsedT> | null {
@@ -432,7 +527,7 @@ export class ChatCompletionStream<ParsedT = null>
         ...rest,
         choices: [],
       };
-    } else {
+    } else if (chunk.id) {
       Object.assign(snapshot, rest);
     }
 

package/src/lib/ChatCompletionStreamingRunner.ts

@@ -1,26 +1,63 @@
 import {
   type ChatCompletionChunk,
   type ChatCompletionCreateParamsStreaming,
+  type ChatCompletionMessageParam,
 } from '../resources/chat/completions';
 import { RunnerOptions, type AbstractChatCompletionRunnerEvents } from './AbstractChatCompletionRunner';
 import { type ReadableStream } from '../internal/shim-types';
 import { RunnableTools, type BaseFunctionsArgs } from './RunnableFunction';
-import { ChatCompletionSnapshot, ChatCompletionStream } from './ChatCompletionStream';
+import {
+  type ChatCompletionReadableStreamItem,
+  ChatCompletionSnapshot,
+  ChatCompletionStream,
+  makeChatCompletionReadableStreamMessageChunk,
+} from './ChatCompletionStream';
+import { OpenAIError } from '../error';
 import OpenAI from '../index';
 import { AutoParseableTool } from '../lib/parser';
+import { Stream } from '../streaming';
+import { isAssistantMessage, isToolMessage } from './chatCompletionUtils';
 
 export interface ChatCompletionStreamEvents extends AbstractChatCompletionRunnerEvents {
   content: (contentDelta: string, contentSnapshot: string) => void;
   chunk: (chunk: ChatCompletionChunk, snapshot: ChatCompletionSnapshot) => void;
 }
 
-export type ChatCompletionStreamingToolRunnerParams<FunctionsArgs extends BaseFunctionsArgs> = Omit<
-  ChatCompletionCreateParamsStreaming,
-  'tools'
-> & {
-  tools: RunnableTools<FunctionsArgs> | AutoParseableTool<any, true>[];
+type ChatCompletionStreamingToolRunnerParamsBase = Omit<ChatCompletionCreateParamsStreaming, 'tools'>;
+
+/**
+ * Parameters for tools that do not require a context value.
+ */
+export type ChatCompletionStreamingToolRunnerParamsWithoutContext<FunctionsArgs extends BaseFunctionsArgs> =
+  ChatCompletionStreamingToolRunnerParamsBase & {
+    tools: RunnableTools<FunctionsArgs> | AutoParseableTool<any, true>[];
+    toolContext?: never;
+  };
+
+/**
+ * Parameters for tools that require a context value.
+ */
+export type ChatCompletionStreamingToolRunnerParamsWithContext<
+  FunctionsArgs extends BaseFunctionsArgs,
+  ToolContext,
+> = ChatCompletionStreamingToolRunnerParamsBase & {
+  tools: RunnableTools<FunctionsArgs, ToolContext> | AutoParseableTool<any, true>[];
+  /**
+   * Context to pass to each tool callback during this run.
+   */
+  toolContext: ToolContext;
 };
 
+/**
+ * Parameters for running streaming tools. Supplying a context type makes
+ * `toolContext` required; omitting it preserves the existing no-context form.
+ */
+export type ChatCompletionStreamingToolRunnerParams<
+  FunctionsArgs extends BaseFunctionsArgs,
+  ToolContext = never,
+> = [ToolContext] extends [never] ? ChatCompletionStreamingToolRunnerParamsWithoutContext<FunctionsArgs>
+: ChatCompletionStreamingToolRunnerParamsWithContext<FunctionsArgs, ToolContext>;
+
 export class ChatCompletionStreamingRunner<ParsedT = null>
   extends ChatCompletionStream<ParsedT>
   implements AsyncIterable<ChatCompletionChunk>
@@ -31,9 +68,109 @@ export class ChatCompletionStreamingRunner<ParsedT = null>
     return runner;
   }
 
+  override toReadableStream(): ReadableStream {
+    const pushQueue: ChatCompletionReadableStreamItem[] = [];
+    const readQueue: {
+      resolve: (event: ChatCompletionReadableStreamItem | undefined) => void;
+      reject: (err: unknown) => void;
+    }[] = [];
+    let done = false;
+    let lastChunk: ChatCompletionChunk | undefined;
+    let toolCallIds: string[] | undefined;
+
+    const pushEvent = (event: ChatCompletionReadableStreamItem) => {
+      const reader = readQueue.shift();
+      if (reader) {
+        reader.resolve(event);
+      } else {
+        pushQueue.push(event);
+      }
+    };
+
+    this.on('chunk', (chunk) => {
+      lastChunk = chunk;
+      pushEvent(chunk);
+    });
+    this.on('message', (message: ChatCompletionMessageParam) => {
+      if (isAssistantMessage(message)) {
+        toolCallIds = message.tool_calls?.map((toolCall) => toolCall.id);
+        return;
+      }
+
+      if (isToolMessage(message)) {
+        if (!lastChunk) {
+          throw new OpenAIError('cannot serialize a tool message before receiving any chunks');
+        }
+        pushEvent(makeChatCompletionReadableStreamMessageChunk(lastChunk, message, toolCallIds));
+      }
+    });
+
+    this.on('end', () => {
+      done = true;
+      for (const reader of readQueue) {
+        reader.resolve(undefined);
+      }
+      readQueue.length = 0;
+    });
+
+    this.on('abort', (err) => {
+      done = true;
+      for (const reader of readQueue) {
+        reader.reject(err);
+      }
+      readQueue.length = 0;
+    });
+
+    this.on('error', (err) => {
+      done = true;
+      for (const reader of readQueue) {
+        reader.reject(err);
+      }
+      readQueue.length = 0;
+    });
+
+    const iterator = (): AsyncIterator<ChatCompletionReadableStreamItem> => ({
+      next: async (): Promise<IteratorResult<ChatCompletionReadableStreamItem>> => {
+        if (!pushQueue.length) {
+          if (done) {
+            return { value: undefined, done: true };
+          }
+          return new Promise<ChatCompletionReadableStreamItem | undefined>((resolve, reject) =>
+            readQueue.push({ resolve, reject }),
+          ).then((event) => (event ? { value: event, done: false } : { value: undefined, done: true }));
+        }
+        const event = pushQueue.shift();
+        if (!event) {
+          return { value: undefined, done: true };
+        }
+        return { value: event, done: false };
+      },
+      return: async () => {
+        this.abort();
+        return { value: undefined, done: true };
+      },
+    });
+
+    const stream = new Stream(iterator, this.controller);
+    return stream.toReadableStream();
+  }
+
+  static runTools<T extends (string | object)[], ParsedT = null, ToolContext = unknown>(
+    client: OpenAI,
+    params: ChatCompletionStreamingToolRunnerParamsWithContext<T, ToolContext>,
+    options?: RunnerOptions,
+  ): ChatCompletionStreamingRunner<ParsedT>;
+
   static runTools<T extends (string | object)[], ParsedT = null>(
     client: OpenAI,
-    params: ChatCompletionStreamingToolRunnerParams<T>,
+    params: ChatCompletionStreamingToolRunnerParamsWithoutContext<T>,
+    options?: RunnerOptions,
+  ): ChatCompletionStreamingRunner<ParsedT>;
+  static runTools<T extends (string | object)[], ParsedT = null, ToolContext = unknown>(
+    client: OpenAI,
+    params:
+      | ChatCompletionStreamingToolRunnerParamsWithContext<T, ToolContext>
+      | ChatCompletionStreamingToolRunnerParamsWithoutContext<T>,
     options?: RunnerOptions,
   ): ChatCompletionStreamingRunner<ParsedT> {
     const runner = new ChatCompletionStreamingRunner<ParsedT>(

package/src/lib/EventStream.ts

@@ -44,10 +44,17 @@ export class EventStream<EventTypes extends BaseEvents> {
     // Unfortunately if we call `executor()` immediately we get runtime errors about
     // references to `this` before the `super()` constructor call returns.
     setTimeout(() => {
-      executor().then(() => {
-        this._emitFinal();
-        this._emit('end');
-      }, this.#handleError.bind(this));
+      Promise.resolve()
+        .then(executor)
+        .then(() => {
+          try {
+            this._emitFinal();
+          } catch (error) {
+            this.#handleError(error);
+            return;
+          }
+          this._emit('end');
+        }, this.#handleError.bind(this));
     }, 0);
   }
 
@@ -157,6 +164,109 @@ export class EventStream<EventTypes extends BaseEvents> {
     });
   }
 
+  /**
+   * Returns an async iterator that yields every time the event is triggered.
+   * The iterator ends when the stream ends and rejects if the stream errors
+   * or is aborted. If you request the 'error' or 'abort' event, the iterator
+   * yields that event instead of rejecting.
+   *
+   * Example:
+   *
+   *   for await (const [message] of stream.events('message')) {
+   *     await processMessage(message);
+   *   }
+   */
+  events<Event extends keyof EventTypes>(
+    event: Event,
+  ): AsyncIterableIterator<EventParameters<EventTypes, Event>> {
+    type Parameters = EventParameters<EventTypes, Event>;
+    type Result = IteratorResult<Parameters>;
+    type Reader = {
+      resolve: (result: Result) => void;
+      reject: (error: OpenAIError) => void;
+    };
+
+    const pushQueue: Parameters[] = [];
+    const readQueue: Reader[] = [];
+    let ended = this.ended;
+    let failure: OpenAIError | undefined;
+    let failureDelivered = false;
+
+    const doneResult = (): Result => ({ value: undefined as never, done: true });
+    const finishReaders = () => {
+      while (readQueue.length) {
+        readQueue.shift()!.resolve(doneResult());
+      }
+    };
+    const rejectReader = () => {
+      if (!failure || failureDelivered || !readQueue.length) return;
+      failureDelivered = true;
+      readQueue.shift()!.reject(failure);
+    };
+    const cleanup = () => {
+      this.off(event, onEvent as EventListener<EventTypes, Event>);
+      this.off('end', onEnd);
+      if (event !== 'error') this.off('error', onFailure);
+      if (event !== 'abort') this.off('abort', onFailure);
+    };
+    const onEvent = (...args: Parameters) => {
+      if (ended) return;
+      const reader = readQueue.shift();
+      if (reader) {
+        reader.resolve({ value: args, done: false });
+      } else {
+        pushQueue.push(args);
+      }
+    };
+    const onFailure = (error: OpenAIError) => {
+      failure = error;
+      if (!pushQueue.length) rejectReader();
+    };
+    const onEnd = () => {
+      ended = true;
+      cleanup();
+      if (!pushQueue.length) {
+        rejectReader();
+        finishReaders();
+      }
+    };
+
+    if (!ended) {
+      this.on(event, onEvent as EventListener<EventTypes, Event>);
+      this.on('end', onEnd);
+      if (event !== 'error') this.on('error', onFailure);
+      if (event !== 'abort') this.on('abort', onFailure);
+    }
+
+    return {
+      next: () => {
+        const value = pushQueue.shift();
+        if (value) return Promise.resolve({ value, done: false });
+
+        if (failure && !failureDelivered) {
+          failureDelivered = true;
+          return Promise.reject(failure);
+        }
+
+        if (ended) return Promise.resolve(doneResult());
+
+        return new Promise<Result>((resolve, reject) => {
+          readQueue.push({ resolve, reject });
+        });
+      },
+      return: () => {
+        ended = true;
+        pushQueue.length = 0;
+        cleanup();
+        finishReaders();
+        return Promise.resolve(doneResult());
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+    };
+  }
+
   async done(): Promise<void> {
     this.#catchingPromiseCreated = true;
     await this.#endPromise;