openai 6.44.0 → 6.45.0

package/src/internal/bedrock.ts

@@ -0,0 +1,153 @@
+import * as Errors from '../error';
+import type { ApiKeySetter } from '../client';
+import type { FinalizedRequestInit } from './types';
+import type { ProviderRequestContext } from './provider';
+import { readEnv } from './utils';
+
+export interface BedrockEndpointOptions {
+  /** AWS region used to derive the default Mantle endpoint. */
+  region?: string | undefined;
+
+  /** Bedrock API root. Defaults to AWS_BEDROCK_BASE_URL or the regional Mantle endpoint. */
+  baseURL?: string | null | undefined;
+}
+
+export interface BedrockBearerOptions {
+  /** Explicit Bedrock bearer credential. Set to null to skip the environment bearer fallback. */
+  apiKey?: string | null | undefined;
+
+  /** A function that resolves a Bedrock bearer credential before every request attempt. */
+  tokenProvider?: ApiKeySetter | undefined;
+}
+
+export interface BedrockRequestAuth {
+  prepareRequest(request: FinalizedRequestInit, context: ProviderRequestContext): void | Promise<void>;
+}
+
+export type BedrockAuthFactory = () => BedrockRequestAuth;
+
+export function errorWithCause(message: string, cause: unknown): Errors.OpenAIError {
+  const error = new Errors.OpenAIError(message) as Errors.OpenAIError & { cause?: unknown };
+  error.cause = cause;
+  return error;
+}
+
+export function normalizeOptionalString(value: string | null | undefined): string | undefined {
+  const normalized = typeof value === 'string' ? value.trim() : undefined;
+  return normalized ? normalized : undefined;
+}
+
+function normalizeBaseURL(baseURL: string): string {
+  const url = new URL(baseURL);
+  const responsesMatch = url.pathname.match(/\/responses(?:\/.*)?$/);
+  if (responsesMatch?.index !== undefined) {
+    url.pathname = url.pathname.slice(0, responsesMatch.index) || '/';
+  }
+  return url.toString().replace(/\/$/, '');
+}
+
+export function resolveBedrockEndpoint(options: BedrockEndpointOptions): {
+  region: string | undefined;
+  baseURL: string;
+} {
+  if (options.region !== undefined && !normalizeOptionalString(options.region)) {
+    throw new Errors.OpenAIError('The Bedrock AWS `region` must not be empty.');
+  }
+  if (
+    options.baseURL !== undefined &&
+    options.baseURL !== null &&
+    !normalizeOptionalString(options.baseURL)
+  ) {
+    throw new Errors.OpenAIError('The Bedrock `baseURL` must not be empty.');
+  }
+
+  const region =
+    normalizeOptionalString(options.region) ??
+    normalizeOptionalString(readEnv('AWS_REGION')) ??
+    normalizeOptionalString(readEnv('AWS_DEFAULT_REGION'));
+  const configuredBaseURL =
+    options.baseURL === undefined ? normalizeOptionalString(readEnv('AWS_BEDROCK_BASE_URL'))
+    : options.baseURL === null ? undefined
+    : normalizeOptionalString(options.baseURL);
+
+  if (configuredBaseURL) return { region, baseURL: normalizeBaseURL(configuredBaseURL) };
+  if (!region) {
+    throw new Errors.OpenAIError(
+      'Bedrock requires an AWS region. Pass `region` to `bedrock(...)`, or set `AWS_REGION` or `AWS_DEFAULT_REGION`.',
+    );
+  }
+  return { region, baseURL: `https://bedrock-mantle.${region}.api.aws/openai/v1` };
+}
+
+export function assertProviderOwnsAuthorization(headers: Headers): void {
+  if (headers.has('authorization')) {
+    throw new Errors.OpenAIError(
+      'Bedrock provider authentication cannot be combined with a custom `Authorization` header.',
+    );
+  }
+}
+
+class BedrockBearerAuth implements BedrockRequestAuth {
+  constructor(private readonly tokenProvider: ApiKeySetter) {}
+
+  async prepareRequest(request: FinalizedRequestInit, _context: ProviderRequestContext): Promise<void> {
+    const headers = new Headers(request.headers);
+    assertProviderOwnsAuthorization(headers);
+
+    let token: unknown;
+    try {
+      token = await this.tokenProvider();
+    } catch (cause) {
+      throw errorWithCause('Failed to resolve a bearer credential for Bedrock.', cause);
+    }
+    if (typeof token !== 'string' || !token.trim()) {
+      throw new Errors.OpenAIError('The Bedrock bearer credential provider must return a non-empty string.');
+    }
+    headers.set('authorization', `Bearer ${token}`);
+    request.headers = headers;
+  }
+}
+
+export function resolveBedrockBearerAuth(
+  options: BedrockBearerOptions,
+  { allowEnvironment = true }: { allowEnvironment?: boolean } = {},
+): { factory: BedrockAuthFactory | undefined; explicit: boolean } {
+  if (
+    options.apiKey !== undefined &&
+    options.apiKey !== null &&
+    (typeof options.apiKey !== 'string' || !options.apiKey.trim())
+  ) {
+    throw new Errors.OpenAIError('The Bedrock bearer credential must not be empty.');
+  }
+  if (options.apiKey != null && options.tokenProvider) {
+    throw new Errors.OpenAIError(
+      'The `apiKey` and `tokenProvider` options are mutually exclusive. Configure only one.',
+    );
+  }
+
+  if (options.tokenProvider) {
+    const tokenProvider = options.tokenProvider;
+    return { factory: () => new BedrockBearerAuth(tokenProvider), explicit: true };
+  }
+  if (options.apiKey != null) {
+    const apiKey = options.apiKey;
+    return { factory: () => new BedrockBearerAuth(async () => apiKey), explicit: true };
+  }
+  if (allowEnvironment && options.apiKey !== null && readEnv('AWS_BEARER_TOKEN_BEDROCK')) {
+    return {
+      explicit: false,
+      factory: () =>
+        new BedrockBearerAuth(async () => {
+          const token = readEnv('AWS_BEARER_TOKEN_BEDROCK');
+          if (!token) {
+            throw new Errors.OpenAIError(
+              'Could not find credentials for Bedrock. Set `AWS_BEARER_TOKEN_BEDROCK` or configure AWS credential authentication.',
+            );
+          }
+          return token;
+        }),
+    };
+  }
+
+  return { factory: undefined, explicit: false };
+}

package/src/internal/provider.ts

@@ -0,0 +1,60 @@
+import type { FinalRequestOptions } from './request-options';
+import type { FinalizedRequestInit } from './types';
+
+declare const providerBrand: unique symbol;
+
+/** An opaque provider configuration created by {@link createProvider}. */
+export interface Provider {
+  readonly [providerBrand]: true;
+}
+
+export interface ProviderRequestContext {
+  url: string;
+  options: FinalRequestOptions;
+}
+
+export interface ProviderRuntime {
+  name: string;
+  baseURL: string;
+  prepareRequest?(request: FinalizedRequestInit, context: ProviderRequestContext): void | Promise<void>;
+}
+
+export interface ProviderDefinition {
+  configure(): ProviderRuntime;
+}
+
+/**
+ * A provider factory such as `bedrock(options)` captures configuration in a
+ * definition, while every OpenAI client receives a fresh runtime from
+ * `definition.configure()`. Keeping definitions out of the provider object
+ * makes providers opaque and prevents arbitrary objects from imitating one.
+ * It also leaves provider-specific dependencies outside the core SDK.
+ *
+ * The registry lives on `globalThis` under a global symbol so a provider made
+ * by one copy of the package still works with another copy, including mixed
+ * CommonJS and ESM installations. The WeakMap avoids retaining discarded
+ * provider configurations.
+ */
+const providerDefinitionsKey = Symbol.for('openai.node.providerDefinitions.v1');
+const providerGlobal = globalThis as any;
+const existingProviderDefinitions = providerGlobal[providerDefinitionsKey] as
+  | WeakMap<Provider, ProviderDefinition>
+  | undefined;
+const providerDefinitions = existingProviderDefinitions ?? new WeakMap<Provider, ProviderDefinition>();
+if (!existingProviderDefinitions) {
+  Object.defineProperty(providerGlobal, providerDefinitionsKey, { value: providerDefinitions });
+}
+
+export function createProvider(definition: ProviderDefinition): Provider {
+  const provider = Object.freeze({}) as Provider;
+  providerDefinitions.set(provider, definition);
+  return provider;
+}
+
+export function configureProvider(provider: Provider): ProviderRuntime {
+  const definition = providerDefinitions.get(provider);
+  if (!definition) {
+    throw new Error('Invalid provider. Providers must be created with createProvider().');
+  }
+  return definition.configure();
+}

package/src/internal/utils/log.ts

@@ -109,6 +109,7 @@ export const formatRequestDetails = (details: {
             name.toLowerCase() === 'authorization' ||
             name.toLowerCase() === 'api-key' ||
             name.toLowerCase() === 'x-api-key' ||
+            name.toLowerCase() === 'x-amz-security-token' ||
             name.toLowerCase() === 'cookie' ||
             name.toLowerCase() === 'set-cookie'
           ) ?

package/src/lib/AbstractChatCompletionRunner.ts

@@ -8,12 +8,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 +29,22 @@ import {
 } from './RunnableFunction';
 
 const DEFAULT_MAX_CHAT_COMPLETIONS = 10;
+
+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<
@@ -113,7 +131,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 +248,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 +275,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 +335,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 +399,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 });

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

@@ -373,11 +373,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 +394,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 +503,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;
         }
       }
 

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