openai 6.44.0 → 6.46.0

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,
@@ -8,12 +9,17 @@ import type {
   ChatCompletionMessage,
   ChatCompletionMessageFunctionToolCall,
   ChatCompletionMessageParam,
+  ChatCompletionMessageToolCall,
   ChatCompletionTool,
+  ChatCompletionToolMessageParam,
   ParsedChatCompletion,
 } from '../resources/chat/completions';
 import type { CompletionUsage } from '../resources/completions';
-import type { ChatCompletionToolRunnerParams } from './ChatCompletionRunner';
-import type { ChatCompletionStreamingToolRunnerParams } from './ChatCompletionStreamingRunner';
+import type { ChatCompletionRunner, ChatCompletionToolRunnerParams } from './ChatCompletionRunner';
+import type {
+  ChatCompletionStreamingRunner,
+  ChatCompletionStreamingToolRunnerParams,
+} from './ChatCompletionStreamingRunner';
 import { isAssistantMessage, isToolMessage } from './chatCompletionUtils';
 import { BaseEvents, EventStream } from './EventStream';
 import {
@@ -24,9 +30,35 @@ import {
 } from './RunnableFunction';
 
 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;
+}
+
 export interface RunnerOptions extends RequestOptions {
   /** How many requests to make before canceling. Default 10. */
   maxChatCompletions?: number;
+  /**
+   * A callback that runs after each chat completion and after any tool calls from
+   * that completion have finished. The callback is awaited before the next
+   * request starts or before the runner ends. The runner's mutable `messages`
+   * array can be used to add context for the next request.
+   */
+  afterCompletion?: (completion: ChatCompletion, runner: ChatCompletionRunnerContext) => void | Promise<void>;
 }
 
 export class AbstractChatCompletionRunner<
@@ -40,6 +72,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;
@@ -113,7 +146,7 @@ export class AbstractChatCompletionRunner<
   }
 
   /**
-   * @returns a promise that resolves with the the final assistant ChatCompletionMessage response,
+   * @returns a promise that resolves with the final assistant ChatCompletionMessage response,
    * or rejects if an error occurred or the stream ended prematurely without producing a ChatCompletionMessage.
    */
   async finalMessage(): Promise<ChatCompletionMessage> {
@@ -230,11 +263,7 @@ export class AbstractChatCompletionRunner<
     params: ChatCompletionCreateParams,
     options?: RequestOptions,
   ): Promise<ParsedChatCompletion<ParsedT>> {
-    const signal = options?.signal;
-    if (signal) {
-      if (signal.aborted) this.controller.abort();
-      signal.addEventListener('abort', () => this.controller.abort());
-    }
+    this._listenForAbort(options?.signal);
     this.#validateParams(params);
 
     const chatCompletion = await client.chat.completions.create(
@@ -261,13 +290,14 @@ export class AbstractChatCompletionRunner<
     params:
       | ChatCompletionToolRunnerParams<FunctionsArgs>
       | ChatCompletionStreamingToolRunnerParams<FunctionsArgs>,
+    runner: ChatCompletionRunner<any> | ChatCompletionStreamingRunner<any>,
     options?: RunnerOptions,
   ) {
     const role = 'tool' as const;
     const { tool_choice = 'auto', stream, ...restParams } = params;
     const singleFunctionToCall =
       typeof tool_choice !== 'string' && tool_choice.type === 'function' && tool_choice?.function?.name;
-    const { maxChatCompletions = DEFAULT_MAX_CHAT_COMPLETIONS } = options || {};
+    const { maxChatCompletions = DEFAULT_MAX_CHAT_COMPLETIONS, afterCompletion } = options || {};
 
     // TODO(someday): clean this logic up
     const inputTools = params.tools.map((tool): RunnableToolFunction<any> => {
@@ -320,6 +350,54 @@ export class AbstractChatCompletionRunner<
       this._addMessage(message, false);
     }
 
+    type ToolCallResult = {
+      message: ChatCompletionToolMessageParam | undefined;
+      functionCalled: boolean;
+    };
+
+    const runToolCall = async (toolCall: ChatCompletionMessageToolCall): Promise<ToolCallResult> => {
+      if (toolCall.type !== 'function') return { message: undefined, functionCalled: false };
+
+      const tool_call_id = toolCall.id;
+      const { name, arguments: args } = toolCall.function;
+      const fn = functionsByName[name];
+
+      if (!fn) {
+        const content = `Invalid tool_call: ${JSON.stringify(name)}. Available options are: ${Object.keys(
+          functionsByName,
+        )
+          .map((name) => JSON.stringify(name))
+          .join(', ')}. Please try again`;
+
+        return { message: { role, tool_call_id, content }, functionCalled: false };
+      }
+
+      if (singleFunctionToCall && singleFunctionToCall !== name) {
+        const content = `Invalid tool_call: ${JSON.stringify(name)}. ${JSON.stringify(
+          singleFunctionToCall,
+        )} requested. Please try again`;
+
+        return { message: { role, tool_call_id, content }, functionCalled: false };
+      }
+
+      let rawContent: unknown;
+      if (isRunnableFunctionWithParse(fn)) {
+        let parsed;
+        try {
+          parsed = await fn.parse(args);
+        } catch (error) {
+          const content = error instanceof Error ? error.message : String(error);
+          return { message: { role, tool_call_id, content }, functionCalled: false };
+        }
+        rawContent = await fn.function(parsed, runner);
+      } else {
+        rawContent = await fn.function(args, runner);
+      }
+
+      const content = this.#stringifyFunctionCallResult(rawContent);
+      return { message: { role, tool_call_id, content }, functionCalled: true };
+    };
+
     for (let i = 0; i < maxChatCompletions; ++i) {
       const chatCompletion: ChatCompletion = await this._createChatCompletion(
         client,
@@ -336,51 +414,39 @@ export class AbstractChatCompletionRunner<
         throw new OpenAIError(`missing message in ChatCompletion response`);
       }
       if (!message.tool_calls?.length) {
+        await afterCompletion?.(chatCompletion, runner);
         return;
       }
 
-      for (const tool_call of message.tool_calls) {
-        if (tool_call.type !== 'function') continue;
-        const tool_call_id = tool_call.id;
-        const { name, arguments: args } = tool_call.function;
-        const fn = functionsByName[name];
-
-        if (!fn) {
-          const content = `Invalid tool_call: ${JSON.stringify(name)}. Available options are: ${Object.keys(
-            functionsByName,
-          )
-            .map((name) => JSON.stringify(name))
-            .join(', ')}. Please try again`;
-
-          this._addMessage({ role, tool_call_id, content });
-          continue;
-        } else if (singleFunctionToCall && singleFunctionToCall !== name) {
-          const content = `Invalid tool_call: ${JSON.stringify(name)}. ${JSON.stringify(
-            singleFunctionToCall,
-          )} requested. Please try again`;
-
-          this._addMessage({ role, tool_call_id, content });
-          continue;
-        }
+      if (singleFunctionToCall || params.parallel_tool_calls === false) {
+        for (const toolCall of message.tool_calls) {
+          const result = await runToolCall(toolCall);
+          if (result.message) this._addMessage(result.message);
 
-        let parsed;
-        try {
-          parsed = isRunnableFunctionWithParse(fn) ? await fn.parse(args) : args;
-        } catch (error) {
-          const content = error instanceof Error ? error.message : String(error);
-          this._addMessage({ role, tool_call_id, content });
-          continue;
+          if (singleFunctionToCall && result.functionCalled) {
+            await afterCompletion?.(chatCompletion, runner);
+            return;
+          }
         }
+      } else {
+        const results = await Promise.allSettled(message.tool_calls.map(runToolCall));
 
-        // @ts-expect-error it can't rule out `never` type.
-        const rawContent = await fn.function(parsed, this);
-        const content = this.#stringifyFunctionCallResult(rawContent);
-        this._addMessage({ role, tool_call_id, content });
+        // Wait for every concurrently running tool to settle before surfacing an
+        // error so tool side effects cannot continue after the runner has ended.
+        for (const result of results) {
+          if (result.status === 'rejected') throw result.reason;
+        }
 
-        if (singleFunctionToCall) {
-          return;
+        // Promise.allSettled preserves input order, so the next request receives
+        // tool result messages in the same order as the assistant's tool calls.
+        for (const result of results) {
+          if (result.status === 'fulfilled' && result.value.message) {
+            this._addMessage(result.value.message);
+          }
         }
       }
+
+      await afterCompletion?.(chatCompletion, runner);
     }
 
     return;

package/src/lib/AssistantStream.ts

@@ -165,11 +165,7 @@ export class AssistantStream
     readableStream: ReadableStream,
     options?: RequestOptions,
   ): Promise<Run> {
-    const signal = options?.signal;
-    if (signal) {
-      if (signal.aborted) this.controller.abort();
-      signal.addEventListener('abort', () => this.controller.abort());
-    }
+    this._listenForAbort(options?.signal);
     this._connected();
     const stream = Stream.fromReadableStream<AssistantStreamEvent>(readableStream, this.controller);
     for await (const event of stream) {
@@ -208,11 +204,7 @@ export class AssistantStream
     params: RunSubmitToolOutputsParamsStream,
     options?: RequestOptions,
   ): Promise<Run> {
-    const signal = options?.signal;
-    if (signal) {
-      if (signal.aborted) this.controller.abort();
-      signal.addEventListener('abort', () => this.controller.abort());
-    }
+    this._listenForAbort(options?.signal);
 
     const body: RunSubmitToolOutputsParamsStreaming = { ...params, stream: true };
     const stream = await run.submitToolOutputs(runId, body, {
@@ -303,11 +295,7 @@ export class AssistantStream
     params: ThreadCreateAndRunParamsBase,
     options?: RequestOptions,
   ): Promise<Run> {
-    const signal = options?.signal;
-    if (signal) {
-      if (signal.aborted) this.controller.abort();
-      signal.addEventListener('abort', () => this.controller.abort());
-    }
+    this._listenForAbort(options?.signal);
 
     const body: RunCreateParamsStreaming = { ...params, stream: true };
     const stream = await thread.createAndRun(body, { ...options, signal: this.controller.signal });
@@ -330,11 +318,7 @@ export class AssistantStream
     params: RunCreateParamsBase,
     options?: RequestOptions,
   ): Promise<Run> {
-    const signal = options?.signal;
-    if (signal) {
-      if (signal.aborted) this.controller.abort();
-      signal.addEventListener('abort', () => this.controller.abort());
-    }
+    this._listenForAbort(options?.signal);
 
     const body: RunCreateParamsStreaming = { ...params, stream: true };
     const stream = await run.create(threadId, body, { ...options, signal: this.controller.signal });
@@ -702,7 +686,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

@@ -37,7 +37,7 @@ export class ChatCompletionRunner<ParsedT = null> extends AbstractChatCompletion
       ...options,
       headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'runTools' },
     };
-    runner._run(() => runner._runTools(client, params, opts));
+    runner._run(() => runner._runTools(client, params, runner, opts));
     return runner;
   }
 

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,
@@ -373,11 +374,7 @@ export class ChatCompletionStream<ParsedT = null>
     options?: RequestOptions,
   ): Promise<ParsedChatCompletion<ParsedT>> {
     super._createChatCompletion;
-    const signal = options?.signal;
-    if (signal) {
-      if (signal.aborted) this.controller.abort();
-      signal.addEventListener('abort', () => this.controller.abort());
-    }
+    this._listenForAbort(options?.signal);
     this.#beginRequest();
 
     const stream = await client.chat.completions.create(
@@ -398,11 +395,7 @@ export class ChatCompletionStream<ParsedT = null>
     readableStream: ReadableStream,
     options?: RequestOptions,
   ): Promise<ChatCompletion> {
-    const signal = options?.signal;
-    if (signal) {
-      if (signal.aborted) this.controller.abort();
-      signal.addEventListener('abort', () => this.controller.abort());
-    }
+    this._listenForAbort(options?.signal);
     this.#beginRequest();
     this._connected();
     const stream = Stream.fromReadableStream<ChatCompletionChunk>(readableStream, this.controller);
@@ -511,7 +504,8 @@ export class ChatCompletionStream<ParsedT = null>
         choice.message.content = (choice.message.content || '') + content;
 
         if (!choice.message.refusal && this.#getAutoParseableResponseFormat()) {
-          choice.message.parsed = partialParse(choice.message.content);
+          // The partial parser does not accept whitespace-only input.
+          choice.message.parsed = choice.message.content.trim() ? partialParse(choice.message.content) : null;
         }
       }
 
@@ -664,9 +658,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)}`);
                 }
@@ -681,7 +672,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 },
+                };
               }),
             },
           };

package/src/lib/ChatCompletionStreamingRunner.ts

@@ -44,7 +44,7 @@ export class ChatCompletionStreamingRunner<ParsedT = null>
       ...options,
       headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'runTools' },
     };
-    runner._run(() => runner._runTools(client, params, opts));
+    runner._run(() => runner._runTools(client, params, runner, opts));
     return runner;
   }
 }

package/src/lib/EventEmitter.ts

@@ -74,8 +74,17 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
     : EventParameters<EventTypes, Event>
   > {
     return new Promise((resolve, reject) => {
-      // TODO: handle errors
-      this.once(event, resolve as any);
+      const onError = (error: unknown) => {
+        this.off(event, onEvent as any);
+        reject(error);
+      };
+      const onEvent = (value: unknown) => {
+        if (event !== 'error') this.off('error', onError as any);
+        resolve(value as any);
+      };
+
+      if (event !== 'error') this.once('error', onError as any);
+      this.once(event, onEvent as any);
     });
   }
 

package/src/lib/EventStream.ts

@@ -14,6 +14,7 @@ export class EventStream<EventTypes extends BaseEvents> {
   #listeners: {
     [Event in keyof EventTypes]?: EventListeners<EventTypes, Event>;
   } = {};
+  #abortListeners: Array<{ signal: AbortSignal; listener: () => void }> = [];
 
   #ended = false;
   #errored = false;
@@ -72,6 +73,24 @@ export class EventStream<EventTypes extends BaseEvents> {
     this.controller.abort();
   }
 
+  protected _listenForAbort(signal: AbortSignal | null | undefined) {
+    if (!signal || this.ended) return;
+    if (signal.aborted) {
+      this.controller.abort();
+      return;
+    }
+
+    const listener = () => this.controller.abort();
+    signal.addEventListener('abort', listener, { once: true });
+    this.#abortListeners.push({ signal, listener });
+  }
+
+  #removeAbortListeners() {
+    for (const { signal, listener } of this.#abortListeners.splice(0)) {
+      signal.removeEventListener('abort', listener);
+    }
+  }
+
   /**
    * Adds the listener function to the end of the listeners array for the event.
    * No checks are made to see if the listener has already been added. Multiple calls passing
@@ -177,6 +196,7 @@ export class EventStream<EventTypes extends BaseEvents> {
     }
 
     if (event === 'end') {
+      this.#removeAbortListeners();
       this.#ended = true;
       this.#resolveEndPromise();
     }

package/src/lib/ResponsesParser.ts

@@ -31,7 +31,7 @@ export function maybeParseResponse<
   ParsedT = Params extends null ? null : ExtractParsedContentFromParams<NonNullable<Params>>,
 >(response: Response, params: Params): ParsedResponse<ParsedT> {
   if (!params || !hasAutoParseableInput(params)) {
-    return {
+    const parsed = {
       ...response,
       output_parsed: null,
       output: response.output.map((item) => {
@@ -55,6 +55,12 @@ export function maybeParseResponse<
         }
       }),
     };
+
+    if (needsOutputText(response, parsed)) {
+      addOutputText(parsed as Response);
+    }
+
+    return parsed;
   }
 
   return parseResponse(response, params);
@@ -64,12 +70,13 @@ export function parseResponse<
   Params extends ResponseCreateParamsBase,
   ParsedT = ExtractParsedContentFromParams<Params>,
 >(response: Response, params: Params): ParsedResponse<ParsedT> {
+  const shouldParse = !response.status || response.status === 'completed';
   const output: Array<ParsedResponseOutputItem<ParsedT>> = response.output.map(
     (item): ParsedResponseOutputItem<ParsedT> => {
       if (item.type === 'function_call') {
         return {
           ...item,
-          parsed_arguments: parseToolCall(params, item),
+          parsed_arguments: shouldParse ? parseToolCall(params, item) : null,
         };
       }
       if (item.type === 'message') {
@@ -77,7 +84,7 @@ export function parseResponse<
           if (content.type === 'output_text') {
             return {
               ...content,
-              parsed: parseTextFormat(params, content.text),
+              parsed: shouldParse ? parseTextFormat(params, content.text) : null,
             };
           }
 
@@ -95,7 +102,7 @@ export function parseResponse<
   );
 
   const parsed: Omit<ParsedResponse<ParsedT>, 'output_parsed'> = Object.assign({}, response, { output });
-  if (!Object.getOwnPropertyDescriptor(response, 'output_text')) {
+  if (needsOutputText(response, parsed)) {
     addOutputText(parsed);
   }
 
@@ -247,6 +254,13 @@ export function validateInputTools(tools: ChatCompletionTool[] | undefined) {
   }
 }
 
+function needsOutputText(
+  response: Response,
+  target: { output_text?: Response['output_text'] | null },
+): boolean {
+  return !Object.getOwnPropertyDescriptor(response, 'output_text') || target.output_text == null;
+}
+
 export function addOutputText(rsp: Response): void {
   const texts: string[] = [];
   for (const output of rsp.output) {