openai 7.4.0 → 7.6.0

package/src/lib/ResponsesParser.ts

@@ -1,31 +1,62 @@
 import { OpenAIError } from '../error';
 import type { ChatCompletionTool } from '../resources/chat/completions';
-import {
+import type {
+  FunctionTool,
+  ParsedContent,
+  ParsedResponse,
+  ParsedResponseFunctionToolCall,
+  ParsedResponseOutputItem,
+  Response,
+  ResponseCreateParamsBase,
+  ResponseCreateParamsNonStreaming,
+  ResponseFormatTextJSONSchemaConfig,
+  ResponseFunctionToolCall,
   ResponseTextConfig,
-  type FunctionTool,
-  type ParsedContent,
-  type ParsedResponse,
-  type ParsedResponseFunctionToolCall,
-  type ParsedResponseOutputItem,
-  type Response,
-  type ResponseCreateParamsBase,
-  type ResponseCreateParamsNonStreaming,
-  type ResponseFunctionToolCall,
-  type Tool,
+  Tool,
 } from '../resources/responses/responses';
-import { type AutoParseableTextFormat, isAutoParsableResponseFormat } from '../lib/parser';
+import { isParseableResponseFormat, parseResponseFormatContent } from '../lib/parser';
+import type { AutoParseableTextFormat } from '../lib/parser';
 
-export type ParseableToolsParams = Array<Tool> | ChatCompletionTool | null;
+/** Response tools, a compatible chat completion tool, or no tools. */
+export type ParseableToolsParams = Tool[] | ChatCompletionTool | null;
 
+/** Response-creation parameters that may include tools recognized by parsing helpers. */
 export type ResponseCreateParamsWithTools = ResponseCreateParamsBase & {
+  /** Tools available to the model while producing the response. */
   tools?: ParseableToolsParams;
 };
 
-type TextConfigParams = { text?: ResponseTextConfig };
-
-export type ExtractParsedContentFromParams<Params extends TextConfigParams> =
-  NonNullable<Params['text']>['format'] extends AutoParseableTextFormat<infer P> ? P : null;
+/** Request fields that can select a plain-text or structured Responses API output format. */
+type TextConfigParams = {
+  /** Optional text output configuration, including its structured JSON format. */
+  text?: ResponseTextConfig;
+};
 
+/** Infers parsed output for each member of a possibly optional text-format union. */
+type ParsedTextFormat<Format> = [Format] extends [never]
+  ? null
+  : Format extends AutoParseableTextFormat<infer ParsedT>
+    ? ParsedT
+    : Format extends ResponseFormatTextJSONSchemaConfig
+      ? unknown
+      : null;
+
+/**
+ * Resolves the type of `output_parsed` / `content[].parsed` for the given params.
+ *
+ * This must stay in sync with `isParseableResponseFormat()` and
+ * `parseResponseFormatContent()`: formats built by an SDK helper carry their parsed
+ * type in the brand, while a raw `{ type: 'json_schema' }` format is parsed with
+ * `JSON.parse()` and so can only be described as `unknown`.
+ */
+export type ExtractParsedContentFromParams<Params extends TextConfigParams> = ParsedTextFormat<
+  NonNullable<Params['text']>['format']
+>;
+
+/**
+ * Adds parsed-output fields to a response, invoking parsers only when its request
+ * includes an auto-parseable text format or strict function tool.
+ */
 export function maybeParseResponse<
   Params extends ResponseCreateParamsBase | null,
   ParsedT = Params extends null ? null : ExtractParsedContentFromParams<NonNullable<Params>>,
@@ -50,9 +81,8 @@ export function maybeParseResponse<
               parsed: null,
             })),
           };
-        } else {
-          return item;
         }
+        return item;
       }),
     };
 
@@ -66,18 +96,24 @@ export function maybeParseResponse<
   return parseResponse(response, params);
 }
 
+/**
+ * Parses completed response text and strict function-tool arguments.
+ *
+ * Incomplete or nonterminal responses keep their parsed values as `null`, and
+ * `output_parsed` returns the first successfully parsed output-text item.
+ */
 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(
+  const output: ParsedResponseOutputItem<ParsedT>[] = response.output.map(
     (item): ParsedResponseOutputItem<ParsedT> => {
       if (item.type === 'function_call') {
         return shouldParse ? parseToolCall(params, item) : { ...item, parsed_arguments: null };
       }
       if (item.type === 'message') {
-        const content: Array<ParsedContent<ParsedT>> = item.content.map((content) => {
+        const content: ParsedContent<ParsedT>[] = item.content.map((content) => {
           if (content.type === 'output_text') {
             return {
               ...content,
@@ -98,7 +134,7 @@ export function parseResponse<
     },
   );
 
-  const parsed: Omit<ParsedResponse<ParsedT>, 'output_parsed'> = Object.assign({}, response, { output });
+  const parsed: Omit<ParsedResponse<ParsedT>, 'output_parsed'> = { ...response, output };
   if (needsOutputText(response, parsed)) {
     addOutputText(parsed);
   }
@@ -129,20 +165,12 @@ function parseTextFormat<
   Params extends ResponseCreateParamsBase,
   ParsedT = ExtractParsedContentFromParams<Params>,
 >(params: Params, content: string): ParsedT | null {
-  if (params.text?.format?.type !== 'json_schema') {
-    return null;
-  }
-
-  if ('$parseRaw' in params.text?.format) {
-    const text_format = params.text?.format as unknown as AutoParseableTextFormat<ParsedT>;
-    return text_format.$parseRaw(content);
-  }
-
-  return JSON.parse(content);
+  return parseResponseFormatContent<ParsedT>(params.text?.format, content);
 }
 
+/** Returns whether the request includes an auto-parseable text format or strict function tool. */
 export function hasAutoParseableInput(params: ResponseCreateParamsWithTools): boolean {
-  if (isAutoParsableResponseFormat(params.text?.format)) {
+  if (isParseableResponseFormat(params.text?.format)) {
     return true;
   }
 
@@ -154,31 +182,44 @@ export function hasAutoParseableInput(params: ResponseCreateParamsWithTools): bo
   );
 }
 
+/** Type-level details used to infer a Responses API function tool's parser and callback. */
 type ToolOptions = {
+  /** Model-visible function name used to match generated tool calls. */
   name: string;
+  /** Parsed argument value accepted by the optional execution callback. */
   arguments: any;
+  /** Optional callback metadata associated with the parsed function tool. */
   function?: ((args: any) => any) | undefined;
 };
 
+/** A Responses API function tool with an argument parser and optional executable callback. */
 export type AutoParseableResponseTool<
   OptionsT extends ToolOptions,
-  HasFunction = OptionsT['function'] extends Function ? true : false,
+  HasFunction = OptionsT['function'] extends (...args: never[]) => unknown ? true : false,
 > = FunctionTool & {
+  /** Type-only marker for parsed tool arguments; this property does not exist at runtime. */
   __arguments: OptionsT['arguments']; // type-level only
+  /** Type-only marker for the function name; this property does not exist at runtime. */
   __name: OptionsT['name']; // type-level only
 
+  /** Non-enumerable SDK marker identifying a tool with an attached argument parser. */
   $brand: 'auto-parseable-tool';
+  /** Optional callback available to helpers that execute parsed function tools. */
   $callback: ((args: OptionsT['arguments']) => any) | undefined;
+  /** Parses the raw JSON argument string into the function's typed argument value. */
   $parseRaw(args: string): OptionsT['arguments'];
 };
 
+/** Copies a Responses API function tool and attaches non-enumerable parser and callback metadata. */
 export function makeParseableResponseTool<OptionsT extends ToolOptions>(
   tool: FunctionTool,
   {
     parser,
     callback,
   }: {
+    /** Converts the raw JSON argument string into the function's typed argument value. */
     parser: (content: string) => OptionsT['arguments'];
+    /** Optional callback available to helpers that execute the parsed function. */
     callback: ((args: any) => any) | undefined;
   },
 ): AutoParseableResponseTool<OptionsT['arguments']> {
@@ -202,11 +243,12 @@ export function makeParseableResponseTool<OptionsT extends ToolOptions>(
   return obj as AutoParseableResponseTool<OptionsT['arguments']>;
 }
 
+/** Returns whether a Responses API tool carries the SDK's argument-parser marker. */
 export function isAutoParsableTool(tool: any): tool is AutoParseableResponseTool<any> {
   return tool?.['$brand'] === 'auto-parseable-tool';
 }
 
-function getInputToolByName(input_tools: Array<Tool>, name: string): FunctionTool | undefined {
+function getInputToolByName(input_tools: Tool[], name: string): FunctionTool | undefined {
   return input_tools.find((tool) => tool.type === 'function' && tool.name === name) as
     | FunctionTool
     | undefined;
@@ -218,16 +260,23 @@ function parseToolCall<Params extends ResponseCreateParamsBase>(
 ): ParsedResponseFunctionToolCall {
   const inputTool = getInputToolByName(params.tools ?? [], toolCall.name);
 
+  let parsedArguments: unknown = null;
+  if (isAutoParsableTool(inputTool)) {
+    parsedArguments = inputTool.$parseRaw(toolCall.arguments);
+  } else if (inputTool?.strict) {
+    parsedArguments = parseResponseFormatContent(
+      { type: 'json_schema', $parseRaw: undefined },
+      toolCall.arguments,
+    );
+  }
+
   return {
     ...toolCall,
-    ...toolCall,
-    parsed_arguments:
-      isAutoParsableTool(inputTool) ? inputTool.$parseRaw(toolCall.arguments)
-      : inputTool?.strict ? JSON.parse(toolCall.arguments)
-      : null,
+    parsed_arguments: parsedArguments,
   };
 }
 
+/** Returns whether a response function call matches a strict or auto-parseable request tool. */
 export function shouldParseToolCall(
   params: ResponseCreateParamsNonStreaming | null | undefined,
   toolCall: ResponseFunctionToolCall,
@@ -240,6 +289,11 @@ export function shouldParseToolCall(
   return isAutoParsableTool(inputTool) || inputTool?.strict || false;
 }
 
+/**
+ * Validates that compatible chat completion tools can be automatically parsed.
+ *
+ * @throws {OpenAIError} If a tool is not a function or is missing `strict: true`.
+ */
 export function validateInputTools(tools: ChatCompletionTool[] | undefined) {
   for (const tool of tools ?? []) {
     if (tool.type !== 'function') {
@@ -263,6 +317,7 @@ function needsOutputText(
   return !Object.getOwnPropertyDescriptor(response, 'output_text') || target.output_text == null;
 }
 
+/** Replaces `output_text` with the concatenated text from every response output message. */
 export function addOutputText(rsp: Response): void {
   const texts: string[] = [];
   for (const output of rsp.output) {

package/src/lib/RunnableFunction.ts

@@ -1,15 +1,17 @@
-import { type ChatCompletionRunner } from './ChatCompletionRunner';
-import { type ChatCompletionStreamingRunner } from './ChatCompletionStreamingRunner';
-import { JSONSchema } from './jsonschema';
+import type { ChatCompletionRunner } from './ChatCompletionRunner';
+import type { ChatCompletionStreamingRunner } from './ChatCompletionStreamingRunner';
+import type { JSONSchema } from './jsonschema';
 
+/** A synchronous callback result or a promise that resolves to the same result. */
 type PromiseOrValue<T> = T | Promise<T>;
 
+/** A function tool that parses raw JSON arguments before invoking its callback. */
 export type RunnableFunctionWithParse<Args extends object, ToolContext = unknown> = {
   /**
    * @param args the return value from `parse`.
    * @param runner the runner evaluating this callback.
    * @param toolContext the context passed to `.runTools()`.
-   * @returns a string to send back to OpenAI.
+   * @returns A value that the runner serializes into a tool-result message.
    */
   function: (
     args: Args,
@@ -22,7 +24,7 @@ export type RunnableFunctionWithParse<Args extends object, ToolContext = unknown
    */
   parse: (input: string) => PromiseOrValue<Args>;
   /**
-   * The parameters the function accepts, describes as a JSON Schema object.
+   * The parameters the function accepts, described as a JSON Schema object.
    */
   parameters: JSONSchema;
   /**
@@ -33,15 +35,17 @@ export type RunnableFunctionWithParse<Args extends object, ToolContext = unknown
    * The name of the function to be called. Will default to function.name if omitted.
    */
   name?: string | undefined;
+  /** Whether the tool's parameters use strict Structured Outputs validation. */
   strict?: boolean | undefined;
 };
 
+/** A function tool whose callback receives the model's raw JSON argument string. */
 export type RunnableFunctionWithoutParse<ToolContext = unknown> = {
   /**
    * @param args the raw args from the OpenAI function call.
    * @param runner the runner evaluating this callback.
    * @param toolContext the context passed to `.runTools()`.
-   * @returns a string to send back to OpenAI
+   * @returns A value that the runner serializes into a tool-result message.
    */
   function: (
     args: string,
@@ -49,7 +53,7 @@ export type RunnableFunctionWithoutParse<ToolContext = unknown> = {
     toolContext: ToolContext,
   ) => PromiseOrValue<unknown>;
   /**
-   * The parameters the function accepts, describes as a JSON Schema object.
+   * The parameters the function accepts, described as a JSON Schema object.
    */
   parameters: JSONSchema;
   /**
@@ -60,25 +64,36 @@ export type RunnableFunctionWithoutParse<ToolContext = unknown> = {
    * The name of the function to be called. Will default to function.name if omitted.
    */
   name?: string | undefined;
+  /** Whether the tool's parameters use strict Structured Outputs validation. */
   strict?: boolean | undefined;
 };
 
-export type RunnableFunction<Args extends object | string, ToolContext = unknown> = Args extends string ?
-  RunnableFunctionWithoutParse<ToolContext>
-: Args extends object ? RunnableFunctionWithParse<Args, ToolContext>
-: never;
+/** Selects a raw-argument or parsed-argument runnable function from its argument type. */
+export type RunnableFunction<Args extends object | string, ToolContext = unknown> = Args extends string
+  ? RunnableFunctionWithoutParse<ToolContext>
+  : Args extends object
+    ? RunnableFunctionWithParse<Args, ToolContext>
+    : never;
 
-export type RunnableToolFunction<Args extends object | string, ToolContext = unknown> = Args extends string ?
-  RunnableToolFunctionWithoutParse<ToolContext>
-: Args extends object ? RunnableToolFunctionWithParse<Args, ToolContext>
-: never;
+/** Wraps a raw-argument or parsed-argument runnable function in an API function-tool shape. */
+export type RunnableToolFunction<Args extends object | string, ToolContext = unknown> = Args extends string
+  ? RunnableToolFunctionWithoutParse<ToolContext>
+  : Args extends object
+    ? RunnableToolFunctionWithParse<Args, ToolContext>
+    : never;
 
+/** An executable API function tool whose callback receives raw JSON arguments. */
 export type RunnableToolFunctionWithoutParse<ToolContext = unknown> = {
+  /** Identifies this tool as a callable function. */
   type: 'function';
+  /** The function definition, callback, and raw-argument configuration. */
   function: RunnableFunctionWithoutParse<ToolContext>;
 };
+/** An executable API function tool whose callback receives parsed arguments. */
 export type RunnableToolFunctionWithParse<Args extends object, ToolContext = unknown> = {
+  /** Identifies this tool as a callable function. */
   type: 'function';
+  /** The function definition, argument parser, and callback. */
   function: RunnableFunctionWithParse<Args, ToolContext>;
 };
 
@@ -86,58 +101,73 @@ export type RunnableToolFunctionWithParse<Args extends object, ToolContext = unk
  * A broad tool shape for contextually typing callbacks when the argument type is inferred.
  */
 export type RunnableToolFunctionWithContext<ToolContext> = {
+  /** Identifies this tool as a callable function. */
   type: 'function';
+  /** The function definition whose callback receives the runner's context value. */
   function: {
+    /** Invokes the tool with its arguments, active runner, and supplied context. */
     function: (
       args: any,
       runner: ChatCompletionRunner<unknown> | ChatCompletionStreamingRunner<unknown>,
       toolContext: ToolContext,
     ) => PromiseOrValue<unknown>;
+    /** Optionally converts raw JSON arguments into the callback's argument value. */
     parse?: (input: string) => PromiseOrValue<any>;
+    /** JSON Schema describing the arguments accepted by the function. */
     parameters: JSONSchema;
+    /** Model-facing explanation of what the function does and when to call it. */
     description: string;
+    /** Explicit function name; defaults to the JavaScript callback's name. */
     name?: string | undefined;
+    /** Whether the tool's parameters use strict Structured Outputs validation. */
     strict?: boolean | undefined;
   };
 };
 
+/** Returns whether a runnable function provides a parser for its raw argument string. */
 export function isRunnableFunctionWithParse<Args extends object, ToolContext = unknown>(
   fn: any,
 ): fn is RunnableFunctionWithParse<Args, ToolContext> {
   return typeof (fn as any).parse === 'function';
 }
 
+/** The ordered raw-string or parsed-object argument types accepted by runnable functions. */
 export type BaseFunctionsArgs = readonly (object | string)[];
 
+/** Runnable function definitions whose callback arguments correspond to an argument-type tuple. */
 export type RunnableFunctions<FunctionsArgs extends BaseFunctionsArgs, ToolContext = unknown> = [
   any[],
-] extends [FunctionsArgs] ?
-  readonly RunnableFunction<any, ToolContext>[]
-: {
-    [Index in keyof FunctionsArgs]: Index extends number ? RunnableFunction<FunctionsArgs[Index], ToolContext>
-    : FunctionsArgs[Index];
-  };
+] extends [FunctionsArgs]
+  ? readonly RunnableFunction<any, ToolContext>[]
+  : {
+      [Index in keyof FunctionsArgs]: Index extends number
+        ? RunnableFunction<FunctionsArgs[Index], ToolContext>
+        : FunctionsArgs[Index];
+    };
 
-export type RunnableTools<FunctionsArgs extends BaseFunctionsArgs, ToolContext = unknown> = [any[]] extends (
-  [FunctionsArgs]
-) ?
-  readonly RunnableToolFunction<any, ToolContext>[]
-: {
-    [Index in keyof FunctionsArgs]: Index extends number ?
-      RunnableToolFunction<FunctionsArgs[Index], ToolContext>
-    : FunctionsArgs[Index];
-  };
+/** Runnable function tools whose callback arguments correspond to an argument-type tuple. */
+export type RunnableTools<FunctionsArgs extends BaseFunctionsArgs, ToolContext = unknown> = [any[]] extends [
+  FunctionsArgs,
+]
+  ? readonly RunnableToolFunction<any, ToolContext>[]
+  : {
+      [Index in keyof FunctionsArgs]: Index extends number
+        ? RunnableToolFunction<FunctionsArgs[Index], ToolContext>
+        : FunctionsArgs[Index];
+    };
 
 /**
  * This is helper class for passing a `function` and `parse` where the `function`
  * argument type matches the `parse` return type.
  */
 export class ParsingToolFunction<Args extends object, ToolContext = unknown> {
-  type: 'function';
+  /** Identifies the wrapped tool as a callable function. */
+  type = 'function' as const;
+  /** The wrapped function definition, argument parser, and callback. */
   function: RunnableFunctionWithParse<Args, ToolContext>;
 
+  /** Wraps a parsed-argument function definition in the function-tool shape. */
   constructor(input: RunnableFunctionWithParse<Args, ToolContext>) {
-    this.type = 'function';
     this.function = input;
   }
 }

package/src/lib/Util.ts

@@ -1,15 +1,17 @@
 /**
  * Like `Promise.allSettled()` but throws an error if any promises are rejected.
+ * Rejection reasons remain available on the thrown error's non-enumerable `rejections`
+ * property without being written to the global console.
  */
 export const allSettledWithThrow = async <R>(promises: Promise<R>[]): Promise<R[]> => {
   const results = await Promise.allSettled(promises);
   const rejected = results.filter((result): result is PromiseRejectedResult => result.status === 'rejected');
   if (rejected.length) {
-    for (const result of rejected) {
-      console.error(result.reason);
-    }
-
-    throw new Error(`${rejected.length} promise(s) failed - see the above errors`);
+    throw Object.defineProperty(new Error(`${rejected.length} promise(s) failed`), 'rejections', {
+      configurable: true,
+      value: rejected.map(({ reason }) => reason),
+      writable: true,
+    });
   }
 
   // Note: TS was complaining about using `.filter().map()` here for some reason

package/src/lib/assistant-run-polling.ts

@@ -0,0 +1,27 @@
+import type { RequestOptions } from '../internal/request-options';
+import type { Run, RunRetrieveParams, Runs } from '../resources/beta/threads/runs/runs';
+import { pollWithResponse } from './polling';
+
+/**
+ * Polls an assistant run through the resource's retrieve method, preserving the
+ * original params object, request-header merge, and terminal run states.
+ *
+ * @internal
+ */
+export function pollAssistantRun(
+  resource: Pick<Runs, 'retrieve'>,
+  runID: string,
+  params: RunRetrieveParams,
+  options?: RequestOptions & { pollIntervalMs?: number },
+): Promise<Run> {
+  return pollWithResponse(
+    (headers) =>
+      resource.retrieve(runID, params, {
+        ...options,
+        headers: { ...options?.headers, ...headers },
+      }),
+    ['queued', 'in_progress', 'cancelling'],
+    ['requires_action', 'incomplete', 'cancelled', 'completed', 'failed', 'expired'],
+    options,
+  );
+}

package/src/lib/chatCompletionUtils.ts

@@ -1,21 +1,20 @@
-import {
-  type ChatCompletionAssistantMessageParam,
-  type ChatCompletionMessageParam,
-  type ChatCompletionToolMessageParam,
+import type {
+  ChatCompletionAssistantMessageParam,
+  ChatCompletionMessageParam,
+  ChatCompletionToolMessageParam,
 } from '../resources';
 
+/** Returns whether a conversation message was produced by the assistant. */
 export const isAssistantMessage = (
   message: ChatCompletionMessageParam | null | undefined,
-): message is ChatCompletionAssistantMessageParam => {
-  return message?.role === 'assistant';
-};
+): message is ChatCompletionAssistantMessageParam => message?.role === 'assistant';
 
+/** Returns whether a conversation message contains the result of a tool call. */
 export const isToolMessage = (
   message: ChatCompletionMessageParam | null | undefined,
-): message is ChatCompletionToolMessageParam => {
-  return message?.role === 'tool';
-};
+): message is ChatCompletionToolMessageParam => message?.role === 'tool';
 
+/** Narrows a value by excluding both `null` and `undefined`. */
 export function isPresent<T>(obj: T | null | undefined): obj is T {
   return obj != null;
 }

package/src/lib/embeddings.ts

@@ -0,0 +1,65 @@
+import type { OpenAI } from '../client';
+import type { APIPromise } from '../core/api-promise';
+import type { RequestOptions } from '../internal/request-options';
+import { loggerFor, toFloat32Array } from '../internal/utils';
+import type { CreateEmbeddingResponse, Embedding, EmbeddingCreateParams } from '../resources/embeddings';
+
+type Base64EmbeddingResponse = Omit<CreateEmbeddingResponse, 'data'> & {
+  data: (Omit<Embedding, 'embedding'> & { embedding: string })[];
+};
+
+/**
+ * Sends the optimized embeddings request while preserving explicit encodings and
+ * the original APIPromise response accessors.
+ *
+ * @internal
+ */
+export function createEmbedding(
+  client: OpenAI,
+  body: EmbeddingCreateParams,
+  options?: RequestOptions,
+): APIPromise<CreateEmbeddingResponse | Base64EmbeddingResponse> {
+  const hasUserProvidedEncodingFormat = !!body.encoding_format;
+  // No encoding_format specified, defaulting to base64 for performance reasons.
+  // See https://github.com/openai/openai-node/pull/1312.
+  const encodingFormat = hasUserProvidedEncodingFormat ? body.encoding_format : 'base64';
+
+  if (hasUserProvidedEncodingFormat) {
+    loggerFor(client).debug('embeddings/user defined encoding_format:', body.encoding_format);
+  }
+
+  const response: APIPromise<CreateEmbeddingResponse> = client.post('/embeddings', {
+    body: {
+      ...body,
+      encoding_format: encodingFormat,
+    },
+    ...options,
+    __security: { bearerAuth: true },
+  });
+
+  // Explicit encodings return the original response promise unchanged.
+  if (hasUserProvidedEncodingFormat) {
+    return response;
+  }
+
+  // The default request uses base64 on the wire, but returns the API's default
+  // numeric embedding representation to the caller.
+  loggerFor(client).debug('embeddings/decoding base64 embeddings from base64');
+
+  return response._thenUnwrap((data) => {
+    if (data && data.data) {
+      const embeddings = data.data;
+      const { length } = embeddings;
+      // Preserve the original iteration length and skip sparse-array holes.
+      for (let index = 0; index < length; index += 1) {
+        if (index in embeddings) {
+          const embeddingBase64Obj = embeddings[index] as Embedding;
+          const embeddingBase64Str = embeddingBase64Obj.embedding as unknown as string;
+          embeddingBase64Obj.embedding = toFloat32Array(embeddingBase64Str);
+        }
+      }
+    }
+
+    return data;
+  });
+}

package/src/lib/file-processing.ts

@@ -0,0 +1,36 @@
+import { APIConnectionTimeoutError } from '../error';
+import { sleep } from '../internal/utils/sleep';
+import type { FileObject, Files } from '../resources/files';
+
+/**
+ * Waits for file processing through the resource's retrieve method. The timeout
+ * is checked after each subsequent retrieval, preserving the existing behavior
+ * for an initially terminal file and for a terminal response received too late.
+ *
+ * @internal
+ */
+export async function waitForFileProcessing(
+  resource: Pick<Files, 'retrieve'>,
+  id: string,
+  pollInterval: number,
+  maxWait: number,
+): Promise<FileObject> {
+  const terminalStates = new Set(['processed', 'error', 'deleted']);
+  const start = Date.now();
+  let file = await resource.retrieve(id);
+
+  while (!file.status || !terminalStates.has(file.status)) {
+    // oxlint-disable-next-line no-await-in-loop -- Wait before issuing the next processing-status request.
+    await sleep(pollInterval);
+
+    // oxlint-disable-next-line no-await-in-loop -- The timeout and next iteration depend on this response.
+    file = await resource.retrieve(id);
+    if (Date.now() - start > maxWait) {
+      throw new APIConnectionTimeoutError({
+        message: `Giving up on waiting for file ${id} to finish processing after ${maxWait} milliseconds.`,
+      });
+    }
+  }
+
+  return file;
+}