openai 7.9.0 → 7.12.1

package/src/internal/bedrock.ts

@@ -290,7 +290,7 @@ export function assertValidBedrockBearerCredential(credential: string): void {
   }
 }
 
-interface BedrockBearerSignalFailure {
+interface BedrockAuthSignalFailure {
   error?: { value: unknown };
   removeListeners?: () => void;
 }
@@ -313,13 +313,13 @@ function removeBedrockAbortListener(signal: AbortSignal, listener: () => void):
   }
 }
 
-function resolveAbortableBedrockBearerToken(
-  tokenProvider: ApiKeySetter,
+function resolveAbortableBedrockAuth<T>(
+  operation: () => Promise<T>,
   signals: readonly AbortSignal[],
-  failure: BedrockBearerSignalFailure,
-): Promise<string> {
+  failure: BedrockAuthSignalFailure,
+): Promise<T> {
   // oxlint-disable-next-line promise/avoid-new -- AbortSignal events require a Promise callback bridge.
-  return new Promise<string>((resolve, reject) => {
+  return new Promise<T>((resolve, reject) => {
     let settled = false;
     const listeners: { signal: AbortSignal; listener: () => void }[] = [];
 
@@ -333,13 +333,13 @@ function resolveAbortableBedrockBearerToken(
     };
     failure.removeListeners = removeListeners;
 
-    const settle = (result: { token: string } | { error: unknown }) => {
+    const settle = (result: { value: T } | { error: unknown }) => {
       if (settled) {
         return;
       }
       settled = true;
-      if ('token' in result) {
-        resolve(result.token);
+      if ('value' in result) {
+        resolve(result.value);
       } else {
         removeListeners();
         reject(result.error);
@@ -399,26 +399,75 @@ function resolveAbortableBedrockBearerToken(
       }
     }
 
-    let token: Promise<string>;
+    let pending: Promise<T>;
     try {
-      token = tokenProvider();
+      pending = operation();
     } catch (error) {
       settle({ error });
       return;
     }
 
-    const observeToken = async () => {
+    const observeResult = async () => {
       try {
-        settle({ token: await token });
+        settle({ value: await pending });
       } catch (error) {
         settle({ error });
       }
     };
     // Observe the result even if the provider synchronously triggered cancellation.
-    void observeToken();
+    void observeResult();
   });
 }
 
+/**
+ * Resolves Bedrock authentication work with caller cancellation, then applies
+ * its result synchronously after the final cancellation checks.
+ *
+ * @internal
+ */
+export async function prepareBedrockAuth<T>(
+  request: FinalizedRequestInit,
+  context: ProviderRequestContext,
+  operation: {
+    resolve: () => Promise<T>;
+    failureMessage: string;
+    apply: (value: T) => void;
+  },
+): Promise<void> {
+  const signals: AbortSignal[] = [];
+  for (const signal of [context.options.signal, request.signal]) {
+    if (signal != null && !signals.includes(signal)) {
+      signals.push(signal);
+    }
+  }
+  const signalFailure: BedrockAuthSignalFailure = {};
+  let value: T;
+  try {
+    try {
+      value =
+        signals.length > 0
+          ? await resolveAbortableBedrockAuth(operation.resolve, signals, signalFailure)
+          : await operation.resolve();
+    } catch (cause) {
+      if (signalFailure.error && Object.is(cause, signalFailure.error.value)) {
+        throw cause;
+      }
+      throw errorWithCause(operation.failureMessage, cause);
+    }
+    if (signalFailure.error) {
+      throw signalFailure.error.value;
+    }
+    for (const signal of signals) {
+      if (signal.aborted) {
+        throw createBedrockUserAbortError(signal);
+      }
+    }
+  } finally {
+    signalFailure.removeListeners?.();
+  }
+  operation.apply(value);
+}
+
 class BedrockBearerAuth implements BedrockRequestAuth {
   private readonly tokenProvider: ApiKeySetter;
 
@@ -430,52 +479,29 @@ class BedrockBearerAuth implements BedrockRequestAuth {
     const headers = new Headers(request.headers);
     assertProviderOwnsAuthorization(headers);
 
-    const signals: AbortSignal[] = [];
-    for (const signal of [context.options.signal, request.signal]) {
-      if (signal != null && !signals.includes(signal)) {
-        signals.push(signal);
-      }
-    }
-    const signalFailure: BedrockBearerSignalFailure = {};
-    let token: unknown;
-    try {
-      try {
-        token =
-          signals.length > 0
-            ? await resolveAbortableBedrockBearerToken(() => this.tokenProvider(), signals, signalFailure)
-            : await this.tokenProvider();
-      } catch (cause) {
-        if (signalFailure.error && Object.is(cause, signalFailure.error.value)) {
-          throw cause;
+    await prepareBedrockAuth(request, context, {
+      resolve: () => this.tokenProvider(),
+      failureMessage: 'Failed to resolve a bearer credential for Bedrock.',
+      apply: (token) => {
+        if (typeof token !== 'string' || !token.trim()) {
+          throw new Errors.OpenAIError(
+            'The Bedrock bearer credential provider must return a non-empty string.',
+          );
         }
-        throw errorWithCause('Failed to resolve a bearer credential for Bedrock.', cause);
-      }
-      if (signalFailure.error) {
-        throw signalFailure.error.value;
-      }
-      for (const signal of signals) {
-        if (signal.aborted) {
-          throw createBedrockUserAbortError(signal);
+        assertValidBedrockBearerCredential(token);
+        try {
+          headers.set('authorization', `Bearer ${token}`);
+        } catch (error) {
+          if (error instanceof TypeError) {
+            // oxlint-disable-next-line eslint/preserve-caught-error -- The original error contains the bearer credential.
+            throw new TypeError('Bedrock bearer credential contains an invalid HTTP header value.');
+          }
+          throw error;
         }
-      }
-    } finally {
-      signalFailure.removeListeners?.();
-    }
-    if (typeof token !== 'string' || !token.trim()) {
-      throw new Errors.OpenAIError('The Bedrock bearer credential provider must return a non-empty string.');
-    }
-    assertValidBedrockBearerCredential(token);
-    try {
-      headers.set('authorization', `Bearer ${token}`);
-    } catch (error) {
-      if (error instanceof TypeError) {
-        // oxlint-disable-next-line eslint/preserve-caught-error -- The original error contains the bearer credential.
-        throw new TypeError('Bedrock bearer credential contains an invalid HTTP header value.');
-      }
-      throw error;
-    }
-    request.redirect = 'manual';
-    request.headers = headers;
+        request.redirect = 'manual';
+        request.headers = headers;
+      },
+    });
   }
 }
 

package/src/internal/detect-platform.ts

@@ -75,7 +75,7 @@ const getPlatformProperties = (): PlatformProperties => {
       'X-Stainless-OS': 'Unknown',
       'X-Stainless-Arch': `other:${EdgeRuntime}`,
       'X-Stainless-Runtime': 'edge',
-      'X-Stainless-Runtime-Version': (globalThis as any).process.version,
+      'X-Stainless-Runtime-Version': (globalThis as any).process?.version ?? 'unknown',
     };
   }
   // Check if Node.js
@@ -128,7 +128,7 @@ function getBrowserInfo(): BrowserInfo | null {
 
   // NOTE: The order matters here!
   const browserPatterns = [
-    { key: 'edge' as const, pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: 'edge' as const, pattern: /\bEdg(?:e|A|iOS)?\b(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
     { key: 'ie' as const, pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
     { key: 'ie' as const, pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ },
     { key: 'chrome' as const, pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },

package/src/internal/errors.ts

@@ -14,11 +14,12 @@ export const castToError = (err: any): Error => {
   if (typeof err === 'object' && err !== null) {
     try {
       if (Object.prototype.toString.call(err) === '[object Error]') {
+        const hasCause = 'cause' in err;
         // @ts-ignore - not all envs have native support for cause yet
-        const error = new Error(err.message, err.cause ? { cause: err.cause } : {});
+        const error = new Error(err.message, hasCause ? { cause: err.cause } : {});
         if (err.stack) error.stack = err.stack;
         // @ts-ignore - not all envs have native support for cause yet
-        if (err.cause && !error.cause) error.cause = err.cause;
+        if (hasCause && !Object.prototype.hasOwnProperty.call(error, 'cause')) error.cause = err.cause;
         if (err.name) error.name = err.name;
         return error;
       }

package/src/internal/headers.ts

@@ -1,6 +1,7 @@
 import { isReadonlyArray } from './utils/values';
 
 type HeaderValue = string | undefined | null;
+type HeaderEntry = readonly (HeaderValue | readonly HeaderValue[])[];
 export type HeadersLike =
   | Headers
   | readonly HeaderValue[][]
@@ -39,11 +40,12 @@ function* iterateHeaders(headers: HeadersLike): IterableIterator<readonly [strin
   }
 
   let shouldClear = false;
-  let iter: Iterable<readonly (HeaderValue | readonly HeaderValue[])[]>;
-  if (headers instanceof Headers) {
-    iter = headers.entries();
-  } else if (isReadonlyArray(headers)) {
-    iter = headers;
+  let iter: Iterable<HeaderEntry>;
+  // Snapshot the iterable protocol across realms without rereading a caller-controlled getter.
+  const iterator: (() => Iterator<HeaderEntry>) | undefined =
+    Symbol.iterator in headers ? headers[Symbol.iterator] : undefined;
+  if (typeof iterator === 'function') {
+    iter = { [Symbol.iterator]: () => iterator.call(headers) };
   } else {
     shouldClear = true;
     iter = Object.entries(headers ?? {});

package/src/internal/parse.ts

@@ -53,7 +53,7 @@ export async function defaultParseResponse<T>(
     }
 
     const contentType = response.headers.get('content-type');
-    const mediaType = contentType?.split(';')[0]?.trim();
+    const mediaType = contentType?.split(';')[0]?.trim().toLowerCase();
     const isJSON = mediaType?.includes('application/json') || mediaType?.endsWith('+json');
     if (isJSON) {
       const contentLength = response.headers.get('content-length');

package/src/internal/realtime-credentials.ts

@@ -0,0 +1,27 @@
+import type { OpenAI } from '../client';
+
+/** Selects a captured credential without treating an explicit null as absent. @internal */
+export function getRealtimeAPIKey(
+  client: Pick<OpenAI, 'apiKey'> | undefined,
+  captured: string | null | undefined,
+): string | null | undefined {
+  return captured === undefined ? client?.apiKey : captured;
+}
+
+/**
+ * Captures the key belonging to this factory invocation while retaining the
+ * existing boolean credential-hook contract. Legacy overrides that do not
+ * capture a key keep their shared-property behavior and remain responsible for
+ * synchronizing concurrent credential updates.
+ * @internal
+ */
+export async function resolveRealtimeAPIKey(client: Pick<OpenAI, 'apiKey' | '_callApiKey'>): Promise<{
+  apiKey: string | null;
+  isProvider: boolean;
+}> {
+  let apiKey: string | null | undefined;
+  const isProvider = await client._callApiKey((resolved) => {
+    apiKey = resolved;
+  });
+  return { apiKey: apiKey === undefined ? client.apiKey : apiKey, isProvider };
+}

package/src/internal/responses/response-accumulator.ts

@@ -153,6 +153,7 @@ function validateArrayIndex(
   allowAppend = false,
 ): void {
   if (
+    !Array.isArray(collection) ||
     !Number.isSafeInteger(index) ||
     index < 0 ||
     index > collection.length ||

package/src/internal/to-file.ts

@@ -1,5 +1,5 @@
 import type { BlobPart } from './uploads';
-import { getName, makeFile, isAsyncIterable, checkFileSupport } from './uploads';
+import { getName, makeFile, isAsyncIterable, isArrayBuffer, checkFileSupport } from './uploads';
 import type { FilePropertyBag } from './builtin-types';
 
 /** Text, binary content, or a Blob-compatible value accepted inside a file stream. */
@@ -106,7 +106,8 @@ export type ToFileInput =
  * filename and metadata are unchanged. Renamed native files reuse the original
  * file contents without buffering and retain their MIME type and modification
  * time unless explicitly overridden. Other filenames are inferred from response
- * URLs or input metadata when omitted, falling back to `unknown_file`. Responses,
+ * URLs or input metadata when omitted or null, falling back to `unknown_file`.
+ * An explicit empty filename is preserved. Responses,
  * native or compatible `Blob` values, and compatible non-native files supply
  * their MIME type unless `options.type` provides an explicit override.
  *
@@ -148,7 +149,7 @@ export async function toFile(
 
   if (isResponseLike(value)) {
     const blob = await value.blob();
-    name ||= getName(value);
+    name ??= getName(value);
 
     const responseOptions =
       options?.type === undefined && blob.type ? { ...options, type: blob.type } : options;
@@ -157,7 +158,7 @@ export async function toFile(
 
   const parts = await getBytes(value);
 
-  name ||= getName(value);
+  name ??= getName(value);
 
   if (options?.type === undefined) {
     const typedPart = parts.find(
@@ -176,7 +177,7 @@ async function getBytes(value: BlobLikePart | AsyncIterable<BlobLikePart>): Prom
   if (
     typeof value === 'string' ||
     ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc.
-    value instanceof ArrayBuffer
+    isArrayBuffer(value)
   ) {
     parts.push(value);
   } else if (isBlobLike(value)) {

package/src/internal/uploads.ts

@@ -196,6 +196,17 @@ function normalizeFilenamePath(value: string): string {
   return normalized;
 }
 
+const arrayBufferByteLengthGetter = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength')?.get;
+
+/** Recognizes native ArrayBuffers across realms without trusting their prototype or string tag. */
+export function isArrayBuffer(value: unknown): value is ArrayBuffer {
+  try {
+    return arrayBufferByteLengthGetter?.call(value) !== undefined;
+  } catch {
+    return false;
+  }
+}
+
 /** Identifies objects that expose a callable `Symbol.asyncIterator` method. */
 export const isAsyncIterable = (value: any): value is AsyncIterable<any> =>
   value != null && typeof value === 'object' && typeof value[Symbol.asyncIterator] === 'function';
@@ -538,7 +549,7 @@ async function* iterateBytes(value: unknown): AsyncGenerator<Uint8Array> {
     yield encodeUTF8(value);
   } else if (ArrayBuffer.isView(value)) {
     yield new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-  } else if (value instanceof ArrayBuffer) {
+  } else if (isArrayBuffer(value)) {
     yield new Uint8Array(value);
   } else if (value instanceof Response) {
     yield* iterateBytes(value.body || (await value.blob()));

package/src/internal/utils/base64.ts

@@ -46,6 +46,9 @@ export const toFloat32Array = (base64Str: string): Array<number> => {
   if (typeof Buffer !== 'undefined') {
     // for Node.js environment
     const buf = Buffer.from(base64Str, 'base64');
+    if (buf.length % Float32Array.BYTES_PER_ELEMENT !== 0) {
+      throw new RangeError('Invalid base64-encoded float32 array: byte length must be a multiple of 4');
+    }
     return Array.from(
       new Float32Array(buf.buffer, buf.byteOffset, buf.length / Float32Array.BYTES_PER_ELEMENT),
     );

package/src/lib/AbstractChatCompletionRunner.ts

@@ -128,6 +128,7 @@ export class AbstractChatCompletionRunner<
 > extends EventStream<EventTypes> {
   protected _chatCompletions: ParsedChatCompletion<ParsedT>[] = [];
   #completionArrivedBeforeAbort = false;
+  #afterCompletionInvoked = false;
   /** Mutable conversation history, including initial input, assistant replies, and tool results. */
   messages: ChatCompletionMessageParam[] = [];
 
@@ -150,8 +151,9 @@ export class AbstractChatCompletionRunner<
     this: AbstractChatCompletionRunner<AbstractChatCompletionRunnerEvents, ParsedT>,
     message: ChatCompletionMessageParam,
     emit = true,
+    normalizeContent = true,
   ) {
-    if (!('content' in message)) {
+    if (normalizeContent && !('content' in message)) {
       message.content = null;
     }
 
@@ -305,6 +307,9 @@ export class AbstractChatCompletionRunner<
   protected override _emitFinal(
     this: AbstractChatCompletionRunner<AbstractChatCompletionRunnerEvents, ParsedT>,
   ) {
+    if (this.#afterCompletionInvoked) {
+      this.#throwIfAborted();
+    }
     const completion = this._chatCompletions[this._chatCompletions.length - 1];
     if (completion) {
       this._emit('finalChatCompletion', completion);
@@ -333,6 +338,18 @@ export class AbstractChatCompletionRunner<
     }
   }
 
+  #throwIfAborted() {
+    if (this.controller.signal.aborted) {
+      const error = new APIUserAbortError();
+      Object.defineProperty(error, 'cause', {
+        value: this.controller.signal.reason,
+        writable: true,
+        configurable: true,
+      });
+      throw error;
+    }
+  }
+
   static #validateParams(params: ChatCompletionCreateParams): void {
     if (params.n != null && params.n > 1) {
       throw new OpenAIError(
@@ -363,7 +380,7 @@ export class AbstractChatCompletionRunner<
     options?: RequestOptions,
   ): Promise<ChatCompletion> {
     for (const message of params.messages) {
-      this._addMessage(message, false);
+      this._addMessage(message, false, false);
     }
     return await this._createChatCompletion(client, params, options);
   }
@@ -384,6 +401,14 @@ export class AbstractChatCompletionRunner<
     const singleFunctionToCall =
       typeof tool_choice !== 'string' && tool_choice.type === 'function' && tool_choice?.function?.name;
     const { maxChatCompletions = DEFAULT_MAX_CHAT_COMPLETIONS, afterCompletion } = options || {};
+    const runAfterCompletion = async (completion: ChatCompletion) => {
+      if (afterCompletion == null) {
+        return;
+      }
+      this.#afterCompletionInvoked = true;
+      await afterCompletion(completion, runner);
+      this.#throwIfAborted();
+    };
 
     // Normalize tool definitions before invoking callbacks.
     const inputTools = params.tools.map((tool): RunnableToolFunction<any> => {
@@ -433,7 +458,7 @@ export class AbstractChatCompletionRunner<
         : (undefined as any);
 
     for (const message of params.messages) {
-      this._addMessage(message, false);
+      this._addMessage(message, false, false);
     }
 
     type ToolCallResult = {
@@ -519,7 +544,7 @@ export class AbstractChatCompletionRunner<
         throw new OpenAIError(`missing message in ChatCompletion response`);
       }
       if (!message.tool_calls?.length) {
-        await afterCompletion?.(chatCompletion, runner);
+        await runAfterCompletion(chatCompletion);
         return;
       }
 
@@ -534,7 +559,7 @@ export class AbstractChatCompletionRunner<
           }
 
           if (singleFunctionToCall && result.functionCalled) {
-            await afterCompletion?.(chatCompletion, runner);
+            await runAfterCompletion(chatCompletion);
             return;
           }
         }
@@ -563,7 +588,7 @@ export class AbstractChatCompletionRunner<
         }
       }
 
-      await afterCompletion?.(chatCompletion, runner);
+      await runAfterCompletion(chatCompletion);
     }
   }
 

package/src/lib/AssistantStream.ts

@@ -20,7 +20,7 @@ import type {
 } from '../resources/beta/threads/runs/runs';
 import type { ReadableStream } from '../internal/shim-types';
 import { Stream } from '../streaming';
-import { APIUserAbortError, OpenAIError } from '../error';
+import { APIError, APIUserAbortError, OpenAIError } from '../error';
 import type {
   AssistantStreamEvent,
   MessageStreamEvent,
@@ -322,7 +322,10 @@ export class AssistantStream
     return Object.values(this.#runStepSnapshots);
   }
 
-  /** Waits for successful completion and returns the final snapshot of every observed message. */
+  /**
+   * Waits for successful completion and returns the final snapshot of every observed message.
+   * Terminal message events replace accumulated snapshots without mutating earlier snapshots.
+   */
   async finalMessages(): Promise<Message[]> {
     await this.done();
 
@@ -479,6 +482,9 @@ export class AssistantStream
       case 'thread.message.delta':
       case 'thread.message.completed':
       case 'thread.message.incomplete': {
+        if (messageID !== undefined && this.#messageSnapshot) {
+          this.#reserveMessageAlias(this.#messageSnapshot, messageID);
+        }
         this.#handleMessage(stableEvent);
         if (messageID !== undefined) {
           this.#reserveMessageAlias(stableEvent.data, messageID);
@@ -491,10 +497,7 @@ export class AssistantStream
       }
 
       case 'error': {
-        //This is included for completeness, but errors are processed in the SSE event processing so this should not occur
-        throw new Error(
-          'Encountered an error event in event processing - errors should be processed earlier',
-        );
+        throw new APIError(undefined, stableEvent.data, undefined, undefined);
       }
       default: {
         assertNever(stableEvent);
@@ -522,6 +525,13 @@ export class AssistantStream
       throw new OpenAIError('Received assistant run-step event with an invalid run-step ID');
     }
 
+    if (event.event === 'thread.run.step.delta') {
+      const delta = event.data.delta;
+      if (delta && hasOwn(delta, 'id')) {
+        throw new OpenAIError('Run-step deltas must not contain an id field');
+      }
+    }
+
     if (event.event === 'thread.run.step.created') {
       if (this.#activeRunStepID !== undefined) {
         throw new OpenAIError(
@@ -839,10 +849,14 @@ export class AssistantStream
           throw new Error('Received a RunStepDelta before creation of a snapshot');
         }
 
-        const data = event.data;
+        const delta = event.data.delta;
 
-        if (data.delta) {
-          const accumulated = accumulateAssistantStreamDelta(snapshot, data.delta, true) as Runs.RunStep;
+        if (delta) {
+          // Raw-event listeners can replace or modify the delta after initial validation.
+          if (hasOwn(delta, 'id')) {
+            throw new OpenAIError('Run-step deltas must not contain an id field');
+          }
+          const accumulated = accumulateAssistantStreamDelta(snapshot, delta, true) as Runs.RunStep;
           this.#runStepSnapshots[runStepID] = accumulated;
         }
 
@@ -921,9 +935,9 @@ export class AssistantStream
       case 'thread.message.in_progress':
       case 'thread.message.completed':
       case 'thread.message.incomplete': {
-        //No changes on other thread events
+        //Terminal events provide the authoritative message snapshot.
         if (snapshot) {
-          return [snapshot, newContent];
+          return [event.event === 'thread.message.in_progress' ? snapshot : event.data, newContent];
         }
         throw new Error('Received thread message event with no existing snapshot');
       }

package/src/lib/ChatCompletionRunner.ts

@@ -11,7 +11,7 @@ import type { AutoParseableTool } from '../lib/parser';
 
 /** Events emitted while executing a non-streaming chat completion tool run. */
 export interface ChatCompletionRunnerEvents extends AbstractChatCompletionRunnerEvents {
-  /** Called when an assistant message with nonempty text content is received. */
+  /** Called when a new assistant message with nonempty text is received; input history is not emitted. */
   content: (content: string) => void;
 }
 
@@ -88,14 +88,18 @@ export class ChatCompletionRunner<ParsedT = null> extends AbstractChatCompletion
     return runner;
   }
 
-  /** Appends a conversation message and emits text content for assistant replies. */
+  /**
+   * Appends a conversation message and emits text content for assistant replies.
+   * @param normalizeContent Defaults to true; initial history passes false to preserve caller-owned messages.
+   */
   override _addMessage(
     this: ChatCompletionRunner<ParsedT>,
     message: ChatCompletionMessageParam,
     emit = true,
+    normalizeContent = true,
   ) {
-    super._addMessage(message, emit);
-    if (isAssistantMessage(message) && message.content) {
+    super._addMessage(message, emit, normalizeContent);
+    if (emit && isAssistantMessage(message) && message.content) {
       this._emit('content', message.content as string);
     }
   }

package/src/lib/ChatCompletionStream.ts

@@ -1,5 +1,6 @@
 import { MalformedJSON, partialParse } from '../_vendor/partial-json-parser/parser';
 import {
+  APIError,
   APIUserAbortError,
   ContentFilterFinishReasonError,
   LengthFinishReasonError,
@@ -1517,6 +1518,9 @@ export class ChatCompletionStream<ParsedT = null>
         );
       }
 
+      if (choiceSnapshot.finish_reason) {
+        state.done_tool_calls.add(toolCallIndex);
+      }
       this._emit('tool_calls.function.arguments.done', {
         name: toolCallSnapshot.function.name,
         index: toolCallIndex,
@@ -1771,6 +1775,10 @@ export class ChatCompletionStream<ParsedT = null>
     );
     let chatId;
     for await (const item of stream) {
+      if ('error' in item && hasOwn(item, 'error') && typeof item.error === 'object' && item.error !== null) {
+        throw new APIError(undefined, item.error, undefined, undefined);
+      }
+
       if (isChatCompletionReadableStreamMessage(item)) {
         const message = getChatCompletionReadableStreamMessage(item);
         if (this.#currentChatCompletionSnapshot) {

package/src/lib/ChatCompletionStreamingRunner.ts

@@ -96,6 +96,7 @@ export class ChatCompletionStreamingRunner<ParsedT = null>
               throw new OpenAIError('cannot serialize a tool message before receiving any chunks');
             }
             push(makeChatCompletionReadableStreamMessageChunk(lastChunk, message, toolCallIds));
+            toolCallIds = undefined;
           }
         };
         this.on('chunk', onChunk);