openai 7.10.0 → 7.13.0

package/src/lib/EventEmitter.ts

@@ -14,6 +14,20 @@ export type EventParameters<Events, EventType extends keyof Events> = Record<
   EventListener<Events, EventType> extends (...args: infer P) => any ? P : never
 >[EventType];
 
+/** Result of awaiting an event: no value, one unwrapped value, or its argument tuple. */
+export type EmittedEventResult<Args extends unknown[]> = [Args] extends [[infer Param]]
+  ? Param
+  : [Args] extends [[]]
+    ? void
+    : [Args] extends [[unknown?]]
+      ? Args[0]
+      : [Args] extends [[unknown, unknown, ...unknown[]]]
+        ? Args
+        :
+            | Args
+            | ([] extends Args ? undefined : never)
+            | (Args extends [...infer Prefix, infer Last] ? ([] extends Prefix ? Last : never) : Args[0]);
+
 /** A lightweight event emitter with type-safe listeners and promise-based event waiting. */
 export class EventEmitter<EventTypes extends Record<string, (...args: any) => any>> {
   #listeners: {
@@ -145,13 +159,7 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
    */
   emitted<Event extends keyof EventTypes>(
     event: Event,
-  ): Promise<
-    EventParameters<EventTypes, Event> extends [infer Param]
-      ? Param
-      : EventParameters<EventTypes, Event> extends []
-        ? void
-        : EventParameters<EventTypes, Event>
-  > {
+  ): Promise<EmittedEventResult<EventParameters<EventTypes, Event>>> {
     return new Promise((resolve, reject) => {
       const onError = (error: unknown) => {
         this.off(event, onEvent as any);
@@ -191,7 +199,8 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
         for (const registration of listeners as any) {
           if (!registration.removed) {
             try {
-              registration.listener(...(args as any));
+              const { listener } = registration;
+              listener(...(args as any));
             } catch (error) {
               if (!listenerThrew) {
                 listenerThrew = true;

package/src/lib/EventStream.ts

@@ -18,6 +18,7 @@ import {
   SubjectTokenProviderError,
   UnprocessableEntityError,
 } from '../error';
+import type { EmittedEventResult } from './EventEmitter';
 
 const MAX_BUFFERED_ITERATOR_EVENTS = 4096;
 const MAX_BUFFERED_ITERATOR_BYTES = 8 * 1024 * 1024;
@@ -1359,6 +1360,10 @@ export class EventStream<EventTypes extends BaseEvents> {
   #errored = false;
   #aborted = false;
   #catchingPromiseCreated = false;
+  // Terminal failure recorded during settlement, before `end` is emitted, so
+  // iterators can surface it even when a throwing user listener prevented
+  // their internal failure listeners from running.
+  #terminalFailure: { kind: 'error' | 'abort'; error: OpenAIError } | undefined;
 
   /** Creates an unstarted stream with independent connection and completion lifecycle promises. */
   constructor() {
@@ -1447,6 +1452,9 @@ export class EventStream<EventTypes extends BaseEvents> {
       this.controller.abort();
       return;
     }
+    if (this.#abortListeners.some((registration) => registration.signal === signal)) {
+      return;
+    }
 
     const listener = () => this.controller.abort();
     signal.addEventListener('abort', listener, { once: true });
@@ -1577,13 +1585,7 @@ export class EventStream<EventTypes extends BaseEvents> {
    */
   emitted<Event extends keyof EventTypes>(
     event: Event,
-  ): Promise<
-    EventParameters<EventTypes, Event> extends [infer Param]
-      ? Param
-      : EventParameters<EventTypes, Event> extends []
-        ? void
-        : EventParameters<EventTypes, Event>
-  > {
+  ): Promise<EmittedEventResult<EventParameters<EventTypes, Event>>> {
     return new Promise((resolve, reject) => {
       this.#catchingPromiseCreated = true;
       const onError = (error: OpenAIError) => {
@@ -1790,8 +1792,24 @@ export class EventStream<EventTypes extends BaseEvents> {
         rejectReader();
       }
     };
+    // A throwing user listener registered before this iterator stops dispatch
+    // before onFailure runs; adopt the failure the stream recorded during
+    // settlement so terminal errors are never converted into clean completion.
+    const adoptTerminalFailure = () => {
+      if (failure) {
+        return;
+      }
+      const terminal = this.#terminalFailure;
+      if (!terminal) {
+        return;
+      }
+      if (terminal.kind === 'error' ? rejectOnError : rejectOnAbort) {
+        failure = terminal.error;
+      }
+    };
     const onEnd = () => {
       ended = true;
+      adoptTerminalFailure();
       cleanup();
       if (!pushQueue.length) {
         rejectReader();
@@ -1826,6 +1844,9 @@ export class EventStream<EventTypes extends BaseEvents> {
           return Promise.resolve({ value, done: false });
         }
 
+        if (ended || this.ended) {
+          adoptTerminalFailure();
+        }
         if (failure && !failureDelivered) {
           failureDelivered = true;
           return Promise.reject(failure);
@@ -1841,6 +1862,9 @@ export class EventStream<EventTypes extends BaseEvents> {
       },
       return: () => {
         ended = true;
+        // The consumer walked away; terminal failures recorded later must not
+        // resurface through this iterator.
+        failureDelivered = true;
         while (bufferedEventSizes.length) {
           deactivateBufferedEvent(bufferedEventSizes.dequeue()!);
         }
@@ -1896,6 +1920,43 @@ export class EventStream<EventTypes extends BaseEvents> {
     return Boolean(this.#listeners[event]?.some((listener) => !listener.removed));
   }
 
+  #settleTerminalEvent<Event extends keyof EventTypes>(
+    event: Event,
+    args: EventParameters<EventTypes, Event>,
+    hasListeners: boolean,
+  ): void {
+    if (event === 'abort') {
+      const error = args[0] as APIUserAbortError;
+      this.#terminalFailure ??= { kind: 'abort', error };
+      if (!this.#catchingPromiseCreated && !hasListeners) {
+        Promise.reject(error);
+      }
+      this.#rejectConnectedPromise(error);
+      this.#rejectEndPromise(error);
+      this._emit('end');
+      return;
+    }
+
+    if (event === 'error') {
+      // NOTE: _emit('error', error) should only be called from #handleError().
+
+      const error = args[0] as OpenAIError;
+      this.#terminalFailure ??= { kind: 'error', error };
+      if (!this.#catchingPromiseCreated && !hasListeners) {
+        // Trigger an unhandled rejection if the user hasn't registered any error handlers.
+        // If you are seeing stack traces here, make sure to handle errors via either:
+        // - runner.on('error', () => ...)
+        // - await runner.done()
+        // - await runner.finalChatCompletion()
+        // - etc.
+        Promise.reject(error);
+      }
+      this.#rejectConnectedPromise(error);
+      this.#rejectEndPromise(error);
+      this._emit('end');
+    }
+  }
+
   /** Dispatches a connection, failure, cancellation, or completion lifecycle event. */
   _emit<Event extends keyof BaseEvents>(event: Event, ...args: EventParameters<BaseEvents, Event>): void;
   /** Dispatches a typed stream event to all listeners registered for that event. */
@@ -1918,61 +1979,53 @@ export class EventStream<EventTypes extends BaseEvents> {
     }
 
     const listeners: EventListeners<EventTypes, Event> | undefined = this.#listeners[event];
-    if (listeners) {
-      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));
+    let dispatchError: unknown;
+    let dispatchThrew = false;
+    try {
+      if (listeners) {
+        this.#listeners[event] = listeners.filter((listener) => {
+          if (listener.once) {
+            listener.detached = true;
           }
-        }
-      } finally {
-        this.#listenerDispatchDepth -= 1;
-        if (this.#listenerDispatchDepth === 0) {
-          this.#cleanupEmittedListeners();
-          for (const check of this.#pendingBufferedEventChecks) {
-            this.#pendingBufferedEventChecks.delete(check);
-            if (!this.#ended) {
-              check();
+          return !listener.once && !listener.removed;
+        }) as any;
+        this.#listenerDispatchDepth += 1;
+        try {
+          for (const registration of listeners as any) {
+            if (!registration.removed) {
+              const { listener } = registration;
+              listener(...(args as any));
+            }
+          }
+        } finally {
+          this.#listenerDispatchDepth -= 1;
+          if (this.#listenerDispatchDepth === 0) {
+            this.#cleanupEmittedListeners();
+            for (const check of this.#pendingBufferedEventChecks) {
+              this.#pendingBufferedEventChecks.delete(check);
+              if (!this.#ended) {
+                check();
+              }
             }
           }
         }
       }
+    } catch (error) {
+      dispatchError = error;
+      dispatchThrew = true;
     }
 
-    if (event === 'abort') {
-      const error = args[0] as APIUserAbortError;
-      if (!this.#catchingPromiseCreated && !listeners?.length) {
-        Promise.reject(error);
+    try {
+      this.#settleTerminalEvent(event, args, Boolean(listeners?.length));
+    } catch (error) {
+      if (!dispatchThrew) {
+        dispatchError = error;
+        dispatchThrew = true;
       }
-      this.#rejectConnectedPromise(error);
-      this.#rejectEndPromise(error);
-      this._emit('end');
-      return;
     }
 
-    if (event === 'error') {
-      // NOTE: _emit('error', error) should only be called from #handleError().
-
-      const error = args[0] as OpenAIError;
-      if (!this.#catchingPromiseCreated && !listeners?.length) {
-        // Trigger an unhandled rejection if the user hasn't registered any error handlers.
-        // If you are seeing stack traces here, make sure to handle errors via either:
-        // - runner.on('error', () => ...)
-        // - await runner.done()
-        // - await runner.finalChatCompletion()
-        // - etc.
-        Promise.reject(error);
-      }
-      this.#rejectConnectedPromise(error);
-      this.#rejectEndPromise(error);
-      this._emit('end');
+    if (dispatchThrew) {
+      throw dispatchError;
     }
   }
 

package/src/lib/ResponsesParser.ts

@@ -2,6 +2,7 @@ import { OpenAIError } from '../error';
 import type { ChatCompletionTool } from '../resources/chat/completions';
 import type {
   FunctionTool,
+  NamespaceTool,
   ParsedContent,
   ParsedResponse,
   ParsedResponseFunctionToolCall,
@@ -97,7 +98,8 @@ export function maybeParseResponse<
 }
 
 /**
- * Parses completed response text and strict function-tool arguments.
+ * Parses completed response text and strict function-tool arguments, matching
+ * namespaced functions by both namespace and name.
  *
  * Incomplete or nonterminal responses keep their parsed values as `null`, and
  * `output_parsed` returns the first successfully parsed output-text item.
@@ -177,7 +179,13 @@ export function hasAutoParseableInput(params: ResponseCreateParamsWithTools): bo
   return (
     Array.isArray(params.tools) &&
     params.tools.some(
-      (tool) => isAutoParsableTool(tool) || (tool.type === 'function' && tool.strict === true),
+      (tool) =>
+        isAutoParsableTool(tool) ||
+        (tool.type === 'function' && tool.strict === true) ||
+        (tool.type === 'namespace' &&
+          tool.tools.some(
+            (nested) => nested.type === 'function' && (isAutoParsableTool(nested) || nested.strict === true),
+          )),
     )
   );
 }
@@ -220,9 +228,9 @@ export function makeParseableResponseTool<OptionsT extends ToolOptions>(
     /** Converts the raw JSON argument string into the function's typed argument value. */
     parser: (content: string) => OptionsT['arguments'];
     /** Optional callback available to helpers that execute the parsed function. */
-    callback: ((args: any) => any) | undefined;
+    callback: ((args: OptionsT['arguments']) => any) | undefined;
   },
-): AutoParseableResponseTool<OptionsT['arguments']> {
+): AutoParseableResponseTool<OptionsT> {
   const obj = { ...tool };
 
   Object.defineProperties(obj, {
@@ -240,7 +248,7 @@ export function makeParseableResponseTool<OptionsT extends ToolOptions>(
     },
   });
 
-  return obj as AutoParseableResponseTool<OptionsT['arguments']>;
+  return obj as AutoParseableResponseTool<OptionsT>;
 }
 
 /** Returns whether a Responses API tool carries the SDK's argument-parser marker. */
@@ -248,17 +256,30 @@ export function isAutoParsableTool(tool: any): tool is AutoParseableResponseTool
   return tool?.['$brand'] === 'auto-parseable-tool';
 }
 
-function getInputToolByName(input_tools: Tool[], name: string): FunctionTool | undefined {
-  return input_tools.find((tool) => tool.type === 'function' && tool.name === name) as
-    | FunctionTool
-    | undefined;
+function getInputToolByName(
+  input_tools: Tool[],
+  name: string,
+  namespace?: string,
+): FunctionTool | NamespaceTool.Function | undefined {
+  for (const tool of input_tools) {
+    if (namespace == null) {
+      if (tool.type === 'function' && tool.name === name) {
+        return tool;
+      }
+    } else if (tool.type === 'namespace' && tool.name === namespace) {
+      return tool.tools.find(
+        (nested): nested is NamespaceTool.Function => nested.type === 'function' && nested.name === name,
+      );
+    }
+  }
+  return undefined;
 }
 
 function parseToolCall<Params extends ResponseCreateParamsBase>(
   params: Params,
   toolCall: ResponseFunctionToolCall,
 ): ParsedResponseFunctionToolCall {
-  const inputTool = getInputToolByName(params.tools ?? [], toolCall.name);
+  const inputTool = getInputToolByName(params.tools ?? [], toolCall.name, toolCall.namespace);
 
   let parsedArguments: unknown = null;
   if (isAutoParsableTool(inputTool)) {
@@ -276,7 +297,7 @@ function parseToolCall<Params extends ResponseCreateParamsBase>(
   };
 }
 
-/** Returns whether a response function call matches a strict or auto-parseable request tool. */
+/** Matches a response function call to a strict or auto-parseable tool by namespace and name. */
 export function shouldParseToolCall(
   params: ResponseCreateParamsNonStreaming | null | undefined,
   toolCall: ResponseFunctionToolCall,
@@ -285,7 +306,7 @@ export function shouldParseToolCall(
     return false;
   }
 
-  const inputTool = getInputToolByName(params.tools ?? [], toolCall.name);
+  const inputTool = getInputToolByName(params.tools ?? [], toolCall.name, toolCall.namespace);
   return isAutoParsableTool(inputTool) || inputTool?.strict || false;
 }
 

package/src/lib/RunnableFunction.ts

@@ -140,7 +140,7 @@ export type RunnableFunctions<FunctionsArgs extends BaseFunctionsArgs, ToolConte
 ] extends [FunctionsArgs]
   ? readonly RunnableFunction<any, ToolContext>[]
   : {
-      [Index in keyof FunctionsArgs]: Index extends number
+      [Index in keyof FunctionsArgs]: FunctionsArgs[Index] extends object | string
         ? RunnableFunction<FunctionsArgs[Index], ToolContext>
         : FunctionsArgs[Index];
     };
@@ -151,7 +151,7 @@ export type RunnableTools<FunctionsArgs extends BaseFunctionsArgs, ToolContext =
 ]
   ? readonly RunnableToolFunction<any, ToolContext>[]
   : {
-      [Index in keyof FunctionsArgs]: Index extends number
+      [Index in keyof FunctionsArgs]: FunctionsArgs[Index] extends object | string
         ? RunnableToolFunction<FunctionsArgs[Index], ToolContext>
         : FunctionsArgs[Index];
     };

package/src/lib/embeddings.ts

@@ -28,34 +28,40 @@ export function createEmbedding(
     loggerFor(client).debug('embeddings/user defined encoding_format:', body.encoding_format);
   }
 
-  const response: APIPromise<CreateEmbeddingResponse> = client.post('/embeddings', {
-    body: {
-      ...body,
-      encoding_format: encodingFormat,
-    },
+  const optimizedBody = { ...body, encoding_format: encodingFormat };
+  const requestOptions: RequestOptions = {
+    body: optimizedBody,
     ...options,
     __security: { bearerAuth: true },
-  });
+  };
+  const response: APIPromise<CreateEmbeddingResponse> = client.post('/embeddings', requestOptions);
 
   // Explicit encodings return the original response promise unchanged.
   if (hasUserProvidedEncodingFormat) {
     return response;
   }
 
-  // The default request uses base64 on the wire, but returns the API's default
-  // numeric embedding representation to the caller.
+  // Preserve numeric output for default requests, including body overrides that
+  // change the encoding used on the wire.
   loggerFor(client).debug('embeddings/decoding base64 embeddings from base64');
 
   return response._thenUnwrap((data) => {
-    if (data && data.data) {
-      const embeddings = data.data;
+    const embeddings = data?.data;
+    if (embeddings !== undefined) {
+      if (!Array.isArray(embeddings)) {
+        throw new TypeError('Expected embeddings response data to be an array');
+      }
       const { length } = embeddings;
       // Preserve the original iteration length and skip sparse-array holes.
       for (let index = 0; index < length; index += 1) {
         if (index in embeddings) {
           const embeddingBase64Obj = embeddings[index] as Embedding;
-          const embeddingBase64Str = embeddingBase64Obj.embedding as unknown as string;
-          embeddingBase64Obj.embedding = toFloat32Array(embeddingBase64Str);
+          const { embedding } = embeddingBase64Obj;
+          // Request hooks and serialization can also select float embeddings.
+          if (Array.isArray(embedding)) {
+            continue;
+          }
+          embeddingBase64Obj.embedding = toFloat32Array(embedding as unknown as string);
         }
       }
     }

package/src/lib/file-processing.ts

@@ -3,8 +3,9 @@ import { sleep } from '../internal/utils/sleep';
 import type { FileObject, Files } from '../resources/files';
 
 /**
- * Waits for file processing through the resource's retrieve method. The timeout
- * is checked after each subsequent retrieval, preserving the existing behavior
+ * Waits for file processing through the resource's retrieve method. Elapsed time
+ * uses a monotonic clock so system clock changes do not affect the timeout,
+ * which is checked after each subsequent retrieval, preserving the existing behavior
  * for an initially terminal file and for a terminal response received too late.
  *
  * @internal
@@ -16,7 +17,7 @@ export async function waitForFileProcessing(
   maxWait: number,
 ): Promise<FileObject> {
   const terminalStates = new Set(['processed', 'error', 'deleted']);
-  const start = Date.now();
+  const start = performance.now();
   let file = await resource.retrieve(id);
 
   while (!file.status || !terminalStates.has(file.status)) {
@@ -25,7 +26,7 @@ export async function waitForFileProcessing(
 
     // oxlint-disable-next-line no-await-in-loop -- The timeout and next iteration depend on this response.
     file = await resource.retrieve(id);
-    if (Date.now() - start > maxWait) {
+    if (performance.now() - start > maxWait) {
       throw new APIConnectionTimeoutError({
         message: `Giving up on waiting for file ${id} to finish processing after ${maxWait} milliseconds.`,
       });

package/src/lib/parser.ts

@@ -214,19 +214,43 @@ export type AutoParseableTool<
   $parseRaw(args: string): OptionsT['arguments'];
 };
 
-/** Copies a function tool and attaches non-enumerable parsing and callback metadata. */
+/** Parser and optional callback supplied when creating a custom chat function tool. */
+type ToolParserOptions<OptionsT extends ToolOptions> = {
+  /** Converts the raw JSON argument string into the tool's typed argument value. */
+  parser: (content: string) => OptionsT['arguments'];
+  /** Optional callback invoked by a chat completion tool runner. */
+  callback: ((args: OptionsT['arguments']) => any) | undefined;
+};
+
+/** Creates a runnable function tool with a guaranteed execution callback. */
+export function makeParseableTool<OptionsT extends ToolOptions>(
+  tool: ChatCompletionFunctionTool,
+  options: ToolParserOptions<OptionsT> & {
+    /** Callback invoked with the parsed tool arguments. */
+    callback: (args: OptionsT['arguments']) => any;
+  },
+): AutoParseableTool<OptionsT, true>;
+
+/** Creates a parse-only function tool without an execution callback. */
 export function makeParseableTool<OptionsT extends ToolOptions>(
   tool: ChatCompletionFunctionTool,
-  {
-    parser,
-    callback,
-  }: {
-    /** Converts the raw JSON argument string into the tool's typed argument value. */
-    parser: (content: string) => OptionsT['arguments'];
-    /** Optional callback invoked by a chat completion tool runner. */
-    callback: ((args: any) => any) | undefined;
+  options: ToolParserOptions<OptionsT> & {
+    /** No execution callback is attached to this tool. */
+    callback: undefined;
   },
-): AutoParseableTool<OptionsT['arguments']> {
+): AutoParseableTool<OptionsT, false>;
+
+/** Creates a function tool whose execution callback may be unavailable. */
+export function makeParseableTool<OptionsT extends ToolOptions>(
+  tool: ChatCompletionFunctionTool,
+  options: ToolParserOptions<OptionsT>,
+): AutoParseableTool<OptionsT, boolean>;
+
+/** Copies a function tool and attaches non-enumerable parsing and callback metadata. */
+export function makeParseableTool<OptionsT extends ToolOptions>(
+  tool: ChatCompletionFunctionTool,
+  { parser, callback }: ToolParserOptions<OptionsT>,
+): AutoParseableTool<OptionsT, boolean> {
   const obj = { ...tool };
 
   Object.defineProperties(obj, {
@@ -244,7 +268,7 @@ export function makeParseableTool<OptionsT extends ToolOptions>(
     },
   });
 
-  return obj as AutoParseableTool<OptionsT['arguments']>;
+  return obj as AutoParseableTool<OptionsT, boolean>;
 }
 
 /** Returns whether a Chat Completions tool carries the SDK's argument-parser marker. */

package/src/lib/polling.ts

@@ -92,8 +92,8 @@ function sleepUntilAborted(milliseconds: number, signal: AbortSignal): Promise<v
 
 /**
  * Repeatedly retrieves a lifecycle resource using the existing polling-helper
- * headers. Intermediate states wait for the explicit interval, server interval,
- * or five-second default; terminal states return the same parsed object.
+ * headers. Intermediate states wait for the explicit interval (including zero),
+ * the server interval, or five-second default; terminal states return the same parsed object.
  * The caller's signal interrupts intermediate waits, unknown states retry
  * immediately, and retrieval errors propagate unchanged.
  *
@@ -120,9 +120,10 @@ export async function pollWithResponse<T extends { status: string }>(
 
     if (intermediateStatuses.includes(status)) {
       let sleepInterval = 5000;
+      const pollIntervalMs = options?.pollIntervalMs;
 
-      if (options?.pollIntervalMs) {
-        sleepInterval = options.pollIntervalMs;
+      if (pollIntervalMs || pollIntervalMs === 0) {
+        sleepInterval = pollIntervalMs;
       } else {
         const headerInterval = response.headers.get('openai-poll-after-ms');
         if (headerInterval) {

package/src/lib/responses/EventTypes.ts

@@ -1,40 +1,7 @@
 import type {
-  ResponseAudioDeltaEvent,
-  ResponseAudioDoneEvent,
-  ResponseAudioTranscriptDeltaEvent,
-  ResponseAudioTranscriptDoneEvent,
-  ResponseCodeInterpreterCallCodeDeltaEvent,
-  ResponseCodeInterpreterCallCodeDoneEvent,
-  ResponseCodeInterpreterCallCompletedEvent,
-  ResponseCodeInterpreterCallInProgressEvent,
-  ResponseCodeInterpreterCallInterpretingEvent,
-  ResponseCompletedEvent,
-  ResponseContentPartAddedEvent,
-  ResponseContentPartDoneEvent,
-  ResponseCreatedEvent,
-  ResponseErrorEvent,
-  ResponseFailedEvent,
-  ResponseFileSearchCallCompletedEvent,
-  ResponseFileSearchCallInProgressEvent,
-  ResponseFileSearchCallSearchingEvent,
   ResponseFunctionCallArgumentsDeltaEvent as RawResponseFunctionCallArgumentsDeltaEvent,
-  ResponseFunctionCallArgumentsDoneEvent,
-  ResponseInProgressEvent,
-  ResponseOutputItemAddedEvent,
-  ResponseOutputItemDoneEvent,
-  ResponseRefusalDeltaEvent,
-  ResponseRefusalDoneEvent,
-  ResponseShellCallCommandAddedEvent,
-  ResponseShellCallCommandDeltaEvent,
-  ResponseShellCallCommandDoneEvent,
-  ResponseShellCallOutputContentDeltaEvent,
-  ResponseShellCallOutputContentDoneEvent,
+  ResponseStreamEvent,
   ResponseTextDeltaEvent as RawResponseTextDeltaEvent,
-  ResponseTextDoneEvent,
-  ResponseIncompleteEvent,
-  ResponseWebSearchCallCompletedEvent,
-  ResponseWebSearchCallInProgressEvent,
-  ResponseWebSearchCallSearchingEvent,
 } from '../../resources/responses/responses';
 
 /** A function-argument delta enhanced with the argument JSON accumulated so far. */
@@ -51,39 +18,6 @@ export type ResponseTextDeltaEvent = RawResponseTextDeltaEvent & {
 
 /** A Responses API event, with accumulated snapshots attached to text and argument deltas. */
 export type ParsedResponseStreamEvent =
-  | ResponseAudioDeltaEvent
-  | ResponseAudioDoneEvent
-  | ResponseAudioTranscriptDeltaEvent
-  | ResponseAudioTranscriptDoneEvent
-  | ResponseCodeInterpreterCallCodeDeltaEvent
-  | ResponseCodeInterpreterCallCodeDoneEvent
-  | ResponseCodeInterpreterCallCompletedEvent
-  | ResponseCodeInterpreterCallInProgressEvent
-  | ResponseCodeInterpreterCallInterpretingEvent
-  | ResponseCompletedEvent
-  | ResponseContentPartAddedEvent
-  | ResponseContentPartDoneEvent
-  | ResponseCreatedEvent
-  | ResponseErrorEvent
-  | ResponseFileSearchCallCompletedEvent
-  | ResponseFileSearchCallInProgressEvent
-  | ResponseFileSearchCallSearchingEvent
+  | Exclude<ResponseStreamEvent, RawResponseFunctionCallArgumentsDeltaEvent | RawResponseTextDeltaEvent>
   | ResponseFunctionCallArgumentsDeltaEvent
-  | ResponseFunctionCallArgumentsDoneEvent
-  | ResponseInProgressEvent
-  | ResponseFailedEvent
-  | ResponseIncompleteEvent
-  | ResponseOutputItemAddedEvent
-  | ResponseOutputItemDoneEvent
-  | ResponseRefusalDeltaEvent
-  | ResponseRefusalDoneEvent
-  | ResponseShellCallCommandAddedEvent
-  | ResponseShellCallCommandDeltaEvent
-  | ResponseShellCallCommandDoneEvent
-  | ResponseShellCallOutputContentDeltaEvent
-  | ResponseShellCallOutputContentDoneEvent
-  | ResponseTextDeltaEvent
-  | ResponseTextDoneEvent
-  | ResponseWebSearchCallCompletedEvent
-  | ResponseWebSearchCallInProgressEvent
-  | ResponseWebSearchCallSearchingEvent;
+  | ResponseTextDeltaEvent;