openai 6.45.0 → 6.47.0

package/src/internal/uploads.ts

@@ -1,16 +1,61 @@
 import { type RequestOptions } from './request-options';
 import type { FilePropertyBag, Fetch } from './builtin-types';
 import type { OpenAI } from '../client';
-import { ReadableStreamFrom } from './shims';
+import { buildHeaders } from './headers';
+import { ReadableStreamFrom, ReadableStreamToAsyncIterable } from './shims';
+import type { ReadableStream } from './shim-types';
+import { encodeUTF8 } from './utils/bytes';
 
 export type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob | DataView;
 type FsReadStream = AsyncIterable<Uint8Array> & { path: string | { toString(): string } };
 
+export type StreamingFileInput = AsyncIterable<BlobPart> | ReadableStream<BlobPart>;
+
+const brand_privateStreamingFile = /* @__PURE__ */ Symbol('brand.privateStreamingFile');
+
+/**
+ * A file whose contents are read lazily while the multipart request is sent.
+ * Create one with {@link toStreamingFile} when buffering an upload into a `File` is undesirable.
+ */
+export interface StreamingFile {
+  /** Brand check, prevent users from creating a StreamingFile without a filename. */
+  readonly [brand_privateStreamingFile]: true;
+  readonly data: StreamingFileInput;
+  readonly name: string;
+  readonly type?: string | undefined;
+}
+
+/**
+ * Wrap a stream as an uploadable file without reading it into memory.
+ *
+ * Unlike {@link toFile}, this helper does not create a web `File`, because the `File` constructor
+ * must consume all of its contents up front. The stream is instead encoded lazily as multipart
+ * form data when the request is sent.
+ */
+export function toStreamingFile(
+  data: StreamingFileInput,
+  name: string,
+  options?: Pick<FilePropertyBag, 'type'>,
+): StreamingFile {
+  if (!name) {
+    throw new TypeError('toStreamingFile requires a non-empty file name');
+  }
+
+  return {
+    [brand_privateStreamingFile]: true,
+    data,
+    name,
+    ...(options?.type ? { type: options.type } : {}),
+  };
+}
+
 // https://github.com/oven-sh/bun/issues/5980
 interface BunFile extends Blob {
   readonly name?: string | undefined;
 }
 
+type NamedBlob = Blob & { readonly name?: string | undefined };
+
 export const checkFileSupport = () => {
   if (typeof File === 'undefined') {
     const { process } = globalThis as any;
@@ -34,7 +79,15 @@ export const checkFileSupport = () => {
  * For convenience, you can also pass a fetch Response, or in Node,
  * the result of fs.createReadStream().
  */
-export type Uploadable = File | Response | FsReadStream | BunFile;
+export type Uploadable =
+  | File
+  | Response
+  | FsReadStream
+  | BunFile
+  | NamedBlob
+  | AsyncIterable<BlobPart>
+  | ReadableStream<BlobPart>
+  | StreamingFile;
 
 /**
  * Construct a `File` instance. This is used to ensure a helpful error is thrown
@@ -78,6 +131,10 @@ export const maybeMultipartFormRequestOptions = async (
 ): Promise<RequestOptions> => {
   if (!hasUploadableValue(opts.body)) return opts;
 
+  if (hasStreamingUploadableValue(opts.body)) {
+    return createStreamingFormRequestOptions(opts);
+  }
+
   return { ...opts, body: await createForm(opts.body, fetch) };
 };
 
@@ -87,6 +144,10 @@ export const multipartFormRequestOptions = async (
   opts: MultipartFormRequestOptions,
   fetch: OpenAI | Fetch,
 ): Promise<RequestOptions> => {
+  if (hasStreamingUploadableValue(opts.body)) {
+    return createStreamingFormRequestOptions(opts);
+  }
+
   return { ...opts, body: await createForm(opts.body, fetch) };
 };
 
@@ -138,12 +199,36 @@ export const createForm = async <T = Record<string, unknown>>(
 
 // We check for Blob not File because Bun.File doesn't inherit from File,
 // but they both inherit from Blob and have a `name` property at runtime.
-const isNamedBlob = (value: unknown) => value instanceof Blob && 'name' in value;
+const isNamedBlob = (value: unknown): value is NamedBlob => value instanceof Blob && 'name' in value;
+
+const isReadableStream = (value: unknown): value is ReadableStream<BlobPart> =>
+  typeof value === 'object' &&
+  value !== null &&
+  'getReader' in value &&
+  typeof value.getReader === 'function';
+
+const isStreamingFile = (value: unknown): value is StreamingFile =>
+  typeof value === 'object' && value !== null && brand_privateStreamingFile in value;
 
 const isUploadable = (value: unknown) =>
   typeof value === 'object' &&
   value !== null &&
-  (value instanceof Response || isAsyncIterable(value) || isNamedBlob(value));
+  (value instanceof Response ||
+    isAsyncIterable(value) ||
+    isReadableStream(value) ||
+    isStreamingFile(value) ||
+    isNamedBlob(value));
+
+const hasStreamingUploadableValue = (value: unknown): boolean => {
+  if (isStreamingFile(value) || isAsyncIterable(value) || isReadableStream(value)) return true;
+  if (Array.isArray(value)) return value.some(hasStreamingUploadableValue);
+  if (value && typeof value === 'object' && !isNamedBlob(value) && !(value instanceof Response)) {
+    for (const k in value) {
+      if (hasStreamingUploadableValue((value as Record<string, unknown>)[k])) return true;
+    }
+  }
+  return false;
+};
 
 const hasUploadableValue = (value: unknown): boolean => {
   if (isUploadable(value)) return true;
@@ -156,6 +241,131 @@ const hasUploadableValue = (value: unknown): boolean => {
   return false;
 };
 
+type FormEntry = { key: string; value: unknown };
+
+const createStreamingFormRequestOptions = (opts: RequestOptions): RequestOptions => {
+  const boundary = `openai-${Math.random().toString(36).slice(2)}`;
+  const body = ReadableStreamFrom(iterateMultipartBody(opts.body, boundary));
+
+  return {
+    ...opts,
+    body,
+    headers: buildHeaders([{ 'content-type': `multipart/form-data; boundary=${boundary}` }, opts.headers]),
+  };
+};
+
+async function* iterateMultipartBody(body: unknown, boundary: string): AsyncGenerator<Uint8Array> {
+  for await (const { key, value } of iterateFormEntries(body)) {
+    yield encodeUTF8(`--${boundary}\r\n`);
+    if (isUploadable(value)) {
+      const filename = getStreamingFileName(value);
+      const type = getStreamingFileType(value);
+      yield encodeUTF8(
+        `Content-Disposition: form-data; name="${escapeHeaderValue(key)}"; filename="${escapeHeaderValue(
+          filename,
+        )}"\r\n` + `Content-Type: ${type}\r\n\r\n`,
+      );
+      yield* iterateBytes(getStreamingFileData(value));
+    } else {
+      yield encodeUTF8(
+        `Content-Disposition: form-data; name="${escapeHeaderValue(key)}"\r\n\r\n${String(value)}`,
+      );
+    }
+    yield encodeUTF8('\r\n');
+  }
+  yield encodeUTF8(`--${boundary}--\r\n`);
+}
+
+async function* iterateFormEntries(body: unknown): AsyncGenerator<FormEntry> {
+  if (!body || typeof body !== 'object') return;
+
+  for (const [key, value] of Object.entries(body)) {
+    yield* iterateFormValue(key, value);
+  }
+}
+
+async function* iterateFormValue(key: string, value: unknown): AsyncGenerator<FormEntry> {
+  if (value === undefined) return;
+  if (value == null) {
+    throw new TypeError(
+      `Received null for "${key}"; to pass null in FormData, you must use the string 'null'`,
+    );
+  }
+
+  if (
+    typeof value === 'string' ||
+    typeof value === 'number' ||
+    typeof value === 'boolean' ||
+    isUploadable(value)
+  ) {
+    yield { key, value };
+  } else if (Array.isArray(value)) {
+    for (const entry of value) {
+      yield* iterateFormValue(key + '[]', entry);
+    }
+  } else if (typeof value === 'object') {
+    for (const [name, prop] of Object.entries(value)) {
+      yield* iterateFormValue(`${key}[${name}]`, prop);
+    }
+  } else {
+    throw new TypeError(
+      `Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`,
+    );
+  }
+}
+
+function getStreamingFileName(value: Uploadable): string {
+  return isStreamingFile(value) ? value.name : getName(value) ?? 'unknown_file';
+}
+
+function getStreamingFileType(value: Uploadable): string {
+  if (isStreamingFile(value)) return value.type || 'application/octet-stream';
+  if (isNamedBlob(value) && value.type) return value.type;
+  if (value instanceof Response) return value.headers.get('content-type') || 'application/octet-stream';
+  return 'application/octet-stream';
+}
+
+function getStreamingFileData(value: Uploadable): unknown {
+  if (isStreamingFile(value)) return value.data;
+  return value;
+}
+
+async function* iterateBytes(value: unknown): AsyncGenerator<Uint8Array> {
+  if (typeof value === 'string') {
+    yield encodeUTF8(value);
+  } else if (ArrayBuffer.isView(value)) {
+    yield new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  } else if (value instanceof ArrayBuffer) {
+    yield new Uint8Array(value);
+  } else if (value instanceof Response) {
+    if (value.body) {
+      yield* iterateBytes(value.body);
+    } else {
+      yield* iterateBytes(await value.blob());
+    }
+  } else if (value instanceof Blob) {
+    if (typeof value.stream === 'function') {
+      yield* iterateBytes(value.stream());
+    } else {
+      yield new Uint8Array(await value.arrayBuffer());
+    }
+  } else if (isReadableStream(value)) {
+    for await (const chunk of ReadableStreamToAsyncIterable<unknown>(value)) {
+      yield* iterateBytes(chunk);
+    }
+  } else if (isAsyncIterable(value)) {
+    for await (const chunk of value) {
+      yield* iterateBytes(chunk);
+    }
+  } else {
+    throw new TypeError(`Invalid streaming file chunk: ${String(value)}`);
+  }
+}
+
+function escapeHeaderValue(value: string): string {
+  return value.replace(/["\\\r\n]/g, (character) => encodeURIComponent(character));
+}
+
 const addFormValue = async (form: FormData, key: string, value: unknown): Promise<void> => {
   if (value === undefined) return;
   if (value == null) {

package/src/lib/AbstractChatCompletionRunner.ts

@@ -1,6 +1,7 @@
 import { OpenAIError } from '../error';
 import type OpenAI from '../index';
 import type { RequestOptions } from '../internal/request-options';
+import { uuid4 } from '../internal/utils/uuid';
 import { isAutoParsableTool, parseChatCompletion } from '../lib/parser';
 import type {
   ChatCompletion,
@@ -14,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';
@@ -30,6 +36,19 @@ import {
 
 const DEFAULT_MAX_CHAT_COMPLETIONS = 10;
 
+function normalizeToolCallIds(chatCompletion: ChatCompletion): void {
+  for (const choice of chatCompletion.choices) {
+    for (const toolCall of choice.message.tool_calls ?? []) {
+      // Some OpenAI-compatible providers omit tool call IDs or return an empty string.
+      // Generate a unique ID before the completion is stored or emitted so the assistant
+      // tool call and its result message always reference the same value.
+      if (!toolCall.id) {
+        toolCall.id = `call_${uuid4()}`;
+      }
+    }
+  }
+}
+
 export interface ChatCompletionRunnerContext {
   messages: ChatCompletionMessageParam[];
   abort(): void;
@@ -58,6 +77,7 @@ export class AbstractChatCompletionRunner<
     this: AbstractChatCompletionRunner<AbstractChatCompletionRunnerEvents, ParsedT>,
     chatCompletion: ParsedChatCompletion<ParsedT>,
   ): ParsedChatCompletion<ParsedT> {
+    normalizeToolCallIds(chatCompletion);
     this._chatCompletions.push(chatCompletion);
     this._emit('chatCompletion', chatCompletion);
     const message = chatCompletion.choices[0]?.message;
@@ -270,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 || {};
@@ -307,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;
@@ -374,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);
       }
     });
 
@@ -686,7 +687,7 @@ export class AssistantStream
 
           const accEntry = accValue[index];
           if (accEntry == null) {
-            accValue.push(deltaEntry);
+            accValue[index] = deltaEntry;
           } else {
             accValue[index] = this.accumulateDelta(accEntry, deltaEntry);
           }

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

@@ -8,6 +8,7 @@ import {
 import OpenAI from '../index';
 import { RequestOptions } from '../internal/request-options';
 import { type ReadableStream } from '../internal/shim-types';
+import { uuid4 } from '../internal/utils/uuid';
 import {
   AutoParseableResponseFormat,
   hasAutoParseableInput,
@@ -25,6 +26,7 @@ import {
   type ChatCompletionCreateParams,
   type ChatCompletionCreateParamsBase,
   type ChatCompletionCreateParamsStreaming,
+  type ChatCompletionMessageParam,
   type ChatCompletionRole,
 } from '../resources/chat/completions/completions';
 import { Stream } from '../streaming';
@@ -117,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;
@@ -204,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,
         });
       }
@@ -253,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);
 
@@ -266,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;
@@ -397,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 {
@@ -431,7 +527,7 @@ export class ChatCompletionStream<ParsedT = null>
         ...rest,
         choices: [],
       };
-    } else {
+    } else if (chunk.id) {
       Object.assign(snapshot, rest);
     }
 
@@ -657,9 +753,6 @@ function finalizeChatCompletion<ParsedT>(
               tool_calls: tool_calls.map((tool_call, i) => {
                 const { function: fn, type, id, ...toolRest } = tool_call;
                 const { arguments: args, name, ...fnRest } = fn || {};
-                if (id == null) {
-                  throw new OpenAIError(`missing choices[${index}].tool_calls[${i}].id\n${str(snapshot)}`);
-                }
                 if (type == null) {
                   throw new OpenAIError(`missing choices[${index}].tool_calls[${i}].type\n${str(snapshot)}`);
                 }
@@ -674,7 +767,12 @@ function finalizeChatCompletion<ParsedT>(
                   );
                 }
 
-                return { ...toolRest, id, type, function: { ...fnRest, name, arguments: args } };
+                return {
+                  ...toolRest,
+                  id: id || `call_${uuid4()}`,
+                  type,
+                  function: { ...fnRest, name, arguments: args },
+                };
               }),
             },
           };