openai 7.5.0 → 7.7.0

package/src/lib/ResponsesParser.ts

@@ -264,7 +264,10 @@ function parseToolCall<Params extends ResponseCreateParamsBase>(
   if (isAutoParsableTool(inputTool)) {
     parsedArguments = inputTool.$parseRaw(toolCall.arguments);
   } else if (inputTool?.strict) {
-    parsedArguments = JSON.parse(toolCall.arguments);
+    parsedArguments = parseResponseFormatContent(
+      { type: 'json_schema', $parseRaw: undefined },
+      toolCall.arguments,
+    );
   }
 
   return {

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/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;
+}

package/src/lib/parser.ts

@@ -75,7 +75,10 @@ export function makeParseableResponseFormat<ParsedT>(
   response_format: ResponseFormatJSONSchema,
   parser: (content: string) => ParsedT,
 ): AutoParseableResponseFormat<ParsedT> {
-  const obj = { ...response_format };
+  const obj = { ...response_format, type: 'json_schema' as const };
+  obj.json_schema = { ...obj.json_schema };
+  delete (obj as { toJSON?: unknown }).toJSON;
+  delete (obj.json_schema as { toJSON?: unknown }).toJSON;
 
   Object.defineProperties(obj, {
     $brand: {
@@ -107,7 +110,8 @@ export function makeParseableTextFormat<ParsedT>(
   response_format: ResponseFormatTextJSONSchemaConfig,
   parser: (content: string) => ParsedT,
 ): AutoParseableTextFormat<ParsedT> {
-  const obj = { ...response_format };
+  const obj = { ...response_format, type: 'json_schema' as const };
+  delete (obj as { toJSON?: unknown }).toJSON;
 
   Object.defineProperties(obj, {
     $brand: {
@@ -169,7 +173,15 @@ export function parseResponseFormatContent<ParsedT>(format: unknown, content: st
     return format.$parseRaw(content) as ParsedT;
   }
 
-  return JSON.parse(content) as ParsedT;
+  try {
+    return JSON.parse(content) as ParsedT;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new SyntaxError('Error reading response: invalid structured output JSON.');
+    }
+
+    throw error;
+  }
 }
 
 /** Type-level details used to infer a chat function tool's parser and execution callback. */
@@ -344,7 +356,10 @@ function parseToolCall<Params extends ChatCompletionCreateParams>(
   if (isAutoParsableTool(inputTool)) {
     parsedArguments = inputTool.$parseRaw(toolCall.function.arguments);
   } else if (inputTool?.function.strict) {
-    parsedArguments = JSON.parse(toolCall.function.arguments);
+    parsedArguments = parseResponseFormatContent(
+      { type: 'json_schema', $parseRaw: undefined },
+      toolCall.function.arguments,
+    );
   }
 
   return {

package/src/lib/polling.ts

@@ -0,0 +1,144 @@
+import type { APIPromise } from '../core/api-promise';
+import { APIUserAbortError } from '../core/error';
+import { buildHeaders } from '../internal/headers';
+import type { NullableHeaders } from '../internal/headers';
+import type { RequestOptions } from '../internal/request-options';
+import { sleep } from '../internal/utils/sleep';
+
+type PollOptions = RequestOptions & { pollIntervalMs?: number };
+
+function sleepUntilAborted(milliseconds: number, signal: AbortSignal): Promise<void> {
+  // oxlint-disable-next-line promise/avoid-new -- Timer and abort callbacks need a portable Promise bridge.
+  return new Promise((resolve, reject) => {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let registered: (() => void) | undefined;
+    let settled = false;
+
+    const removeAbortListener = (listener: () => void) => {
+      try {
+        signal.removeEventListener('abort', listener);
+      } catch {
+        // Caller-controlled cleanup must never prevent the polling promise from settling.
+      }
+    };
+
+    const cleanup = () => {
+      if (timer !== undefined) {
+        clearTimeout(timer);
+        timer = undefined;
+      }
+      if (registered) {
+        const listener = registered;
+        registered = undefined;
+        removeAbortListener(listener);
+      }
+    };
+
+    const abort = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+
+      try {
+        const error = new APIUserAbortError();
+        Object.defineProperty(error, 'cause', {
+          value: signal.reason,
+          writable: true,
+          configurable: true,
+        });
+        reject(error);
+      } catch (error) {
+        reject(error);
+      }
+    };
+
+    if (signal.aborted) {
+      abort();
+      return;
+    }
+
+    timer = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve();
+    }, milliseconds);
+
+    registered = abort;
+
+    try {
+      signal.addEventListener('abort', abort, { once: true });
+
+      if (settled) {
+        removeAbortListener(abort);
+      } else if (signal.aborted) {
+        abort();
+      }
+    } catch (error) {
+      if (settled) {
+        removeAbortListener(abort);
+      } else {
+        settled = true;
+        cleanup();
+        reject(error);
+      }
+    }
+  });
+}
+
+/**
+ * Repeatedly retrieves a lifecycle resource using the existing polling-helper
+ * headers. Intermediate states wait for the explicit interval, server interval,
+ * or five-second default; terminal states return the same parsed object.
+ * The caller's signal interrupts intermediate waits, unknown states retry
+ * immediately, and retrieval errors propagate unchanged.
+ *
+ * @internal
+ */
+export async function pollWithResponse<T extends { status: string }>(
+  retrieve: (headers: NullableHeaders) => APIPromise<T>,
+  intermediateStatuses: readonly T['status'][],
+  terminalStatuses: readonly T['status'][],
+  options?: PollOptions,
+): Promise<T> {
+  const headers = buildHeaders([
+    options?.headers,
+    {
+      'X-Stainless-Poll-Helper': 'true',
+      'X-Stainless-Custom-Poll-Interval': options?.pollIntervalMs?.toString() ?? undefined,
+    },
+  ]);
+
+  while (true) {
+    // oxlint-disable-next-line no-await-in-loop -- Each poll depends on the previous response.
+    const { data, response } = await retrieve(headers).withResponse();
+    const { status } = data;
+
+    if (intermediateStatuses.includes(status)) {
+      let sleepInterval = 5000;
+
+      if (options?.pollIntervalMs) {
+        sleepInterval = options.pollIntervalMs;
+      } else {
+        const headerInterval = response.headers.get('openai-poll-after-ms');
+        if (headerInterval) {
+          // oxlint-disable-next-line radix -- Preserve the existing decimal and hexadecimal header parsing.
+          const headerIntervalMs = Number.parseInt(headerInterval);
+          if (!Number.isNaN(headerIntervalMs)) {
+            sleepInterval = headerIntervalMs;
+          }
+        }
+      }
+      const signal =
+        options && Object.prototype.propertyIsEnumerable.call(options, 'signal') ? options.signal : undefined;
+      // oxlint-disable-next-line no-await-in-loop -- Each poll waits or aborts before the next request.
+      await (signal ? sleepUntilAborted(sleepInterval, signal) : sleep(sleepInterval));
+    } else if (terminalStatuses.includes(status)) {
+      return data;
+    }
+  }
+}

package/src/lib/responses/ResponseStream.ts

@@ -154,51 +154,63 @@ export class ResponseStream<ParsedT = null>
       throw new APIError(undefined, error, event.message, undefined);
     }
 
+    let dispatchEvent: ResponseStreamEvent = event;
     const response = accumulateResponseWithContext(
       event,
       this.#currentResponseSnapshot,
       this.#accumulatorContext,
+      true,
+      (sanitizedEvent) => {
+        dispatchEvent = sanitizedEvent;
+      },
     );
     this.#currentResponseSnapshot = response;
     maybeEmit('event', event);
 
-    switch (event.type) {
+    switch (dispatchEvent.type) {
       case 'response.output_text.delta': {
-        const output = response.output[event.output_index];
+        const output = response.output[dispatchEvent.output_index];
         if (!output) {
-          throw new OpenAIError(`missing output at index ${event.output_index}`);
+          throw new OpenAIError(`missing output at index ${dispatchEvent.output_index}`);
         }
         if (output.type === 'message') {
-          const content = output.content[event.content_index];
+          const content = output.content[dispatchEvent.content_index];
           if (!content) {
-            throw new OpenAIError(`missing content at index ${event.content_index}`);
+            throw new OpenAIError(`missing content at index ${dispatchEvent.content_index}`);
           }
           if (content.type !== 'output_text') {
             throw new OpenAIError(`expected content to be 'output_text', got ${content.type}`);
           }
 
           maybeEmit('response.output_text.delta', {
-            ...event,
+            ...dispatchEvent,
+            type: dispatchEvent.type,
+            item_id: dispatchEvent.item_id,
+            output_index: dispatchEvent.output_index,
+            content_index: dispatchEvent.content_index,
             snapshot: content.text,
           });
         }
         break;
       }
       case 'response.function_call_arguments.delta': {
-        const output = response.output[event.output_index];
+        const output = response.output[dispatchEvent.output_index];
         if (!output) {
-          throw new OpenAIError(`missing output at index ${event.output_index}`);
+          throw new OpenAIError(`missing output at index ${dispatchEvent.output_index}`);
         }
         if (output.type === 'function_call') {
           maybeEmit('response.function_call_arguments.delta', {
-            ...event,
+            ...dispatchEvent,
+            type: dispatchEvent.type,
+            item_id: dispatchEvent.item_id,
+            output_index: dispatchEvent.output_index,
             snapshot: output.arguments,
           });
         }
         break;
       }
       default: {
-        maybeEmit(event.type, event);
+        maybeEmit(dispatchEvent.type, event);
         break;
       }
     }

package/src/lib/vector-store-polling.ts

@@ -0,0 +1,46 @@
+import type { RequestOptions } from '../internal/request-options';
+import type { FileBatches, VectorStoreFileBatch } from '../resources/vector-stores/file-batches';
+import type { Files, VectorStoreFile } from '../resources/vector-stores/files';
+import { pollWithResponse } from './polling';
+
+type PollOptions = RequestOptions & { pollIntervalMs?: number };
+
+/**
+ * Polls an attached file through the resource's retrieve method. Failed files are
+ * returned to the caller, and cancelled files retain their existing retry behavior.
+ *
+ * @internal
+ */
+export function pollVectorStoreFile(
+  resource: Pick<Files, 'retrieve'>,
+  vectorStoreID: string,
+  fileID: string,
+  options?: PollOptions,
+): Promise<VectorStoreFile> {
+  return pollWithResponse(
+    (headers) => resource.retrieve(fileID, { vector_store_id: vectorStoreID }, { ...options, headers }),
+    ['in_progress'],
+    ['failed', 'completed'],
+    options,
+  );
+}
+
+/**
+ * Polls a file batch through the resource's retrieve method until it completes,
+ * fails, or is cancelled. Retrieval errors are propagated unchanged.
+ *
+ * @internal
+ */
+export function pollVectorStoreFileBatch(
+  resource: Pick<FileBatches, 'retrieve'>,
+  vectorStoreID: string,
+  batchID: string,
+  options?: PollOptions,
+): Promise<VectorStoreFileBatch> {
+  return pollWithResponse(
+    (headers) => resource.retrieve(batchID, { vector_store_id: vectorStoreID }, { ...options, headers }),
+    ['in_progress'],
+    ['failed', 'cancelled', 'completed'],
+    options,
+  );
+}

package/src/lib/vector-store-upload.ts

@@ -0,0 +1,53 @@
+import type { OpenAI } from '../client';
+import type { RequestOptions } from '../internal/request-options';
+import type { FileBatches, VectorStoreFileBatch } from '../resources/vector-stores/file-batches';
+import type { Uploadable } from '../uploads';
+import { allSettledWithThrow } from './Util';
+
+type UploadOptions = RequestOptions & { pollIntervalMs?: number; maxConcurrency?: number };
+
+/**
+ * Uploads files with a shared iterator, then creates and polls the batch. Every
+ * worker settles before upload failures are propagated.
+ *
+ * @internal
+ */
+export async function uploadAndPollVectorStoreFileBatch(
+  resource: Pick<FileBatches, 'createAndPoll'>,
+  client: Pick<OpenAI, 'files'>,
+  vectorStoreId: string,
+  files: Uploadable[],
+  fileIds: string[],
+  options?: UploadOptions,
+): Promise<VectorStoreFileBatch> {
+  if (files === null || files === undefined || files.length === 0) {
+    throw new Error(
+      "No `files` provided to process. If you've already uploaded files you should use `.createAndPoll()` instead",
+    );
+  }
+
+  const configuredConcurrency = options?.maxConcurrency ?? 5;
+  const concurrencyLimit = Math.min(configuredConcurrency, files.length);
+  const fileIterator = files.values();
+  const allFileIds = [...fileIds];
+
+  // This code is based on this design. The libraries don't accommodate our environment limits.
+  // https://stackoverflow.com/questions/40639432/what-is-the-best-way-to-limit-concurrency-when-using-es6s-promise-all
+  async function processFiles(iterator: IterableIterator<Uploadable>) {
+    for (const item of iterator) {
+      // oxlint-disable-next-line no-await-in-loop -- Each worker uploads one file at a time.
+      const fileObj = await client.files.create({ file: item, purpose: 'assistants' }, options);
+      allFileIds.push(fileObj.id);
+    }
+  }
+
+  // Assigning length preserves native validation of invalid concurrency values.
+  const workers: Promise<void>[] = [];
+  workers.length = concurrencyLimit;
+  for (let index = 0; index < workers.length; index += 1) {
+    workers[index] = processFiles(fileIterator);
+  }
+  await allSettledWithThrow(workers);
+
+  return await resource.createAndPoll(vectorStoreId, { file_ids: allFileIds }, options);
+}