openai 7.10.0 → 7.12.1

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

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;