openai 7.4.0 → 7.6.0

package/src/internal/decoders/line.ts

@@ -1,73 +1,151 @@
-import { concatBytes, decodeUTF8, encodeUTF8 } from '../utils/bytes';
+import { decodeUTF8, encodeUTF8 } from '../utils/bytes';
 
+/** Text or UTF-8 bytes accepted by the incremental line decoder. */
 export type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
 
+/** Maximum backing-buffer capacity retained when completed lines leave little active data. */
+const MAX_RETAINED_BUFFER_BYTES = 64 * 1024;
+
 /**
- * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally
- * reading lines from text.
+ * Incrementally decodes UTF-8 text into lines without losing partial characters
+ * or newline sequences that span multiple chunks.
+ *
+ * Supports `\n`, `\r`, and `\r\n` line endings. Call {@link flush} after the
+ * final chunk to emit a trailing line that does not end with a newline.
  *
+ * Based on the line decoder used by the Python `httpx` project:
  * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258
  */
 export class LineDecoder {
   // prettier-ignore
+  /** Individual characters recognized as possible line terminators. */
   static NEWLINE_CHARS = new Set(['\n', '\r']);
+
+  /** Matches complete CRLF terminators as well as standalone CR and LF characters. */
   static NEWLINE_REGEXP = /\r\n|[\n\r]/g;
 
   #buffer: Uint8Array;
-  #carriageReturnIndex: number | null;
+  #start: number;
+  #end: number;
+  #searchIndex: number;
+  #skipLeadingLF: boolean;
 
+  /** Creates a decoder with no buffered bytes or pending newline continuation. */
   constructor() {
     this.#buffer = new Uint8Array();
-    this.#carriageReturnIndex = null;
+    this.#start = 0;
+    this.#end = 0;
+    this.#searchIndex = 0;
+    this.#skipLeadingLF = false;
   }
 
+  /**
+   * Appends a text or UTF-8 byte chunk and returns every newly completed line.
+   *
+   * Incomplete lines remain buffered for the next call. A trailing `\r`
+   * completes its line immediately, and a following `\n` is consumed as its
+   * continuation. `null` and `undefined` are ignored and do not flush buffered
+   * content.
+   */
   decode(chunk: Bytes): string[] {
     if (chunk == null) {
       return [];
     }
 
-    const binaryChunk =
-      chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
-      : typeof chunk === 'string' ? encodeUTF8(chunk)
-      : chunk;
+    let binaryChunk: Uint8Array;
+    if (chunk instanceof ArrayBuffer) {
+      binaryChunk = new Uint8Array(chunk);
+    } else if (typeof chunk === 'string') {
+      binaryChunk = encodeUTF8(chunk);
+    } else {
+      binaryChunk = chunk;
+    }
+
+    if (binaryChunk.length === 0) {
+      return [];
+    }
 
-    this.#buffer = concatBytes([this.#buffer, binaryChunk]);
+    if (this.#skipLeadingLF) {
+      this.#skipLeadingLF = false;
+      if (binaryChunk[0] === 0x0a) {
+        binaryChunk = binaryChunk.subarray(1);
+      }
+      if (binaryChunk.length === 0) {
+        return [];
+      }
+    }
+
+    this.#append(binaryChunk);
 
     const lines: string[] = [];
     let patternIndex;
-    while ((patternIndex = findNewlineIndex(this.#buffer, this.#carriageReturnIndex)) != null) {
-      if (patternIndex.carriage && this.#carriageReturnIndex == null) {
-        // skip until we either get a corresponding `\n`, a new `\r` or nothing
-        this.#carriageReturnIndex = patternIndex.index;
-        continue;
+    while ((patternIndex = findNewlineIndex(this.#buffer, this.#searchIndex, this.#end)) != null) {
+      const line = decodeUTF8(this.#buffer.subarray(this.#start, patternIndex.preceding));
+      lines.push(line);
+
+      this.#start = patternIndex.index;
+      if (patternIndex.carriage) {
+        if (this.#start < this.#end && this.#buffer[this.#start] === 0x0a) {
+          this.#start += 1;
+        } else if (this.#start === this.#end) {
+          this.#skipLeadingLF = true;
+        }
       }
+      this.#searchIndex = this.#start;
+    }
 
-      // we got double \r or \rtext\n
-      if (
-        this.#carriageReturnIndex != null &&
-        (patternIndex.index !== this.#carriageReturnIndex + 1 || patternIndex.carriage)
-      ) {
-        lines.push(decodeUTF8(this.#buffer.subarray(0, this.#carriageReturnIndex - 1)));
-        this.#buffer = this.#buffer.subarray(this.#carriageReturnIndex);
-        this.#carriageReturnIndex = null;
-        continue;
+    this.#searchIndex = this.#end;
+    if (this.#start === this.#end) {
+      this.#start = 0;
+      this.#end = 0;
+      this.#searchIndex = 0;
+      if (this.#buffer.length > MAX_RETAINED_BUFFER_BYTES) {
+        this.#buffer = new Uint8Array();
+      }
+    } else if (lines.length > 0 && this.#buffer.length > MAX_RETAINED_BUFFER_BYTES) {
+      const length = this.#end - this.#start;
+      if (length <= MAX_RETAINED_BUFFER_BYTES || this.#buffer.length > length * 4) {
+        const capacity =
+          length <= MAX_RETAINED_BUFFER_BYTES
+            ? Math.min(Math.max(length * 2, 256), MAX_RETAINED_BUFFER_BYTES)
+            : length * 2;
+        const buffer = new Uint8Array(capacity);
+        buffer.set(this.#buffer.subarray(this.#start, this.#end));
+        this.#buffer = buffer;
+        this.#start = 0;
+        this.#end = length;
+        this.#searchIndex = length;
       }
+    }
 
-      const endIndex =
-        this.#carriageReturnIndex !== null ? patternIndex.preceding - 1 : patternIndex.preceding;
+    return lines;
+  }
 
-      const line = decodeUTF8(this.#buffer.subarray(0, endIndex));
-      lines.push(line);
+  #append(chunk: Uint8Array): void {
+    if (this.#end + chunk.length > this.#buffer.length) {
+      const length = this.#end - this.#start;
+      if (this.#start >= this.#buffer.length / 2 && length + chunk.length <= this.#buffer.length) {
+        this.#buffer.copyWithin(0, this.#start, this.#end);
+      } else {
+        const capacity = Math.max(this.#buffer.length * 2, length + chunk.length, 256);
+        const buffer = new Uint8Array(capacity);
+        buffer.set(this.#buffer.subarray(this.#start, this.#end));
+        this.#buffer = buffer;
+      }
 
-      this.#buffer = this.#buffer.subarray(patternIndex.index);
-      this.#carriageReturnIndex = null;
+      this.#searchIndex -= this.#start;
+      this.#end = length;
+      this.#start = 0;
     }
 
-    return lines;
+    this.#buffer.set(chunk, this.#end);
+    this.#end += chunk.length;
   }
 
+  /** Emits the remaining unterminated line, or returns an empty array when idle. */
   flush(): string[] {
-    if (!this.#buffer.length) {
+    this.#skipLeadingLF = false;
+    if (this.#start === this.#end) {
       return [];
     }
     return this.decode('\n');
@@ -75,22 +153,24 @@ export class LineDecoder {
 }
 
 /**
- * This function searches the buffer for the end patterns, (\r or \n)
- * and returns an object with the index preceding the matched newline and the
- * index after the newline char. `null` is returned if no new line is found.
+ * Searches the active buffer range for the next CR or LF byte and returns its
+ * zero-based position, the position immediately after it, and whether the byte
+ * was a carriage return. Returns `null` when the range contains no newline byte.
  *
  * ```ts
- * findNewLineIndex('abc\ndef') -> { preceding: 2, index: 3 }
+ * findNewlineIndex(new TextEncoder().encode('abc\ndef'), 0, 7)
+ * // => { preceding: 3, index: 4, carriage: false }
  * ```
  */
 function findNewlineIndex(
   buffer: Uint8Array,
-  startIndex: number | null,
+  start: number,
+  end: number,
 ): { preceding: number; index: number; carriage: boolean } | null {
   const newline = 0x0a; // \n
   const carriage = 0x0d; // \r
 
-  for (let i = startIndex ?? 0; i < buffer.length; i++) {
+  for (let i = start; i < end; i++) {
     if (buffer[i] === newline) {
       return { preceding: i, index: i + 1, carriage: false };
     }
@@ -103,33 +183,36 @@ function findNewlineIndex(
   return null;
 }
 
+/**
+ * Finds the first blank-line separator used to delimit streamed event records.
+ *
+ * @returns The byte offset immediately after the first pair of consecutive
+ * line endings, or `-1` when the buffer contains no complete separator.
+ */
 export function findDoubleNewlineIndex(buffer: Uint8Array): number {
-  // This function searches the buffer for the end patterns (\r\r, \n\n, \r\n\r\n)
-  // and returns the index right after the first occurrence of any pattern,
-  // or -1 if none of the patterns are found.
-  const newline = 0x0a; // \n
-  const carriage = 0x0d; // \r
-
   for (let i = 0; i < buffer.length - 1; i++) {
-    if (buffer[i] === newline && buffer[i + 1] === newline) {
-      // \n\n
-      return i + 2;
-    }
-    if (buffer[i] === carriage && buffer[i + 1] === carriage) {
-      // \r\r
-      return i + 2;
-    }
-    if (
-      buffer[i] === carriage &&
-      buffer[i + 1] === newline &&
-      i + 3 < buffer.length &&
-      buffer[i + 2] === carriage &&
-      buffer[i + 3] === newline
-    ) {
-      // \r\n\r\n
-      return i + 4;
+    const firstEndingLength = lineEndingLength(buffer, i);
+    if (firstEndingLength > 0) {
+      const secondEndingIndex = i + firstEndingLength;
+      const secondEndingLength = lineEndingLength(buffer, secondEndingIndex);
+      if (secondEndingLength > 0) {
+        return secondEndingIndex + secondEndingLength;
+      }
     }
   }
 
   return -1;
 }
+
+function lineEndingLength(buffer: Uint8Array, index: number): number {
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  if (buffer[index] === newline) {
+    return 1;
+  }
+  if (buffer[index] === carriage) {
+    return buffer[index + 1] === newline ? 2 : 1;
+  }
+  return 0;
+}

package/src/internal/detect-platform.ts

@@ -1,5 +1,3 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
 import { VERSION } from '../version';
 
 export const isRunningInBrowser = () => {
@@ -67,7 +65,7 @@ const getPlatformProperties = (): PlatformProperties => {
       'X-Stainless-Arch': normalizeArch(Deno.build.arch),
       'X-Stainless-Runtime': 'deno',
       'X-Stainless-Runtime-Version':
-        typeof Deno.version === 'string' ? Deno.version : Deno.version?.deno ?? 'unknown',
+        typeof Deno.version === 'string' ? Deno.version : (Deno.version?.deno ?? 'unknown'),
     };
   }
   if (typeof EdgeRuntime !== 'undefined') {

package/src/internal/errors.ts

@@ -1,5 +1,3 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
 export function isAbortError(err: unknown) {
   return (
     typeof err === 'object' &&

package/src/internal/headers.ts

@@ -1,5 +1,3 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
 import { isReadonlyArray } from './utils/values';
 
 type HeaderValue = string | undefined | null;

package/src/internal/multipart-encoding.ts

@@ -0,0 +1,53 @@
+// File generated from our OpenAPI spec by Castiron. See CONTRIBUTING.md for details.
+
+import { multipartFormRequestOptions, makeFile } from './uploads';
+import { buildHeaders } from './headers';
+import type { RequestOptions } from './request-options';
+
+/** Encode explicitly typed fields as single, filename-less multipart parts. */
+export async function encodedMultipartFormRequestOptions(
+  options: RequestOptions,
+  client: Parameters<typeof multipartFormRequestOptions>[1],
+  encodings: Record<string, { content_type: string; json: boolean }>,
+  rawBodyField: string | null = null,
+): Promise<RequestOptions> {
+  if (options.body === null || typeof options.body !== 'object' || Array.isArray(options.body)) {
+    throw new TypeError('Multipart request body must be an object');
+  }
+  const body = Object.fromEntries(Object.entries(options.body).filter(([, value]) => value !== undefined));
+  if (
+    rawBodyField !== null &&
+    Object.keys(body).length === 1 &&
+    Object.prototype.hasOwnProperty.call(body, rawBodyField)
+  ) {
+    const value = body[rawBodyField];
+    if (typeof value !== 'string') throw new TypeError('Raw multipart alternative must be a string');
+    return {
+      ...options,
+      body: value,
+      headers: buildHeaders([options.headers, { 'content-type': encodings[rawBodyField]!.content_type }]),
+    };
+  }
+  const encoded: [string, File][] = [];
+  for (const [name, encoding] of Object.entries(encodings)) {
+    if (!Object.prototype.hasOwnProperty.call(body, name)) continue;
+    const value = body[name];
+    const data = encoding.json ? JSON.stringify(value) : value;
+    if (typeof data !== 'string') throw new TypeError(`Multipart field ${name} must encode as a string`);
+    encoded.push([name, makeFile([data], '', { type: encoding.content_type })]);
+    delete body[name];
+  }
+  const multipart = await multipartFormRequestOptions({ ...options, body }, client);
+  const form = multipart.body;
+  // Declared upload fields are rejected during code generation. Defend against untyped body overrides.
+  if (!(form instanceof FormData)) {
+    await (form as ReadableStream).cancel();
+    throw new TypeError('Unexpected streaming upload in typed multipart request body');
+  }
+  for (const [name, part] of encoded) form.append(name, part, '');
+  return {
+    ...options,
+    body: form,
+    headers: buildHeaders([options.headers, { 'content-type': null }]),
+  };
+}

package/src/internal/parse.ts

@@ -1,8 +1,7 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
 import type { FinalRequestOptions } from './request-options';
 import { Stream } from '../core/streaming';
 import { type OpenAI } from '../client';
+import { isAbortError } from './errors';
 import { formatRequestDetails, loggerFor } from './utils/log';
 import type { AbstractPage } from '../pagination';
 
@@ -63,13 +62,24 @@ export async function defaultParseResponse<T>(
         return undefined as T;
       }
 
-      const json = await response.json();
+      const bodyText = await response.text();
+      if (!bodyText) {
+        // Some servers respond with an empty body and a JSON content-type but
+        // without a `content-length: 0` header (e.g. over HTTP/2 or with chunked
+        // transfer encoding). Treat this the same as an explicit `content-length: 0`
+        // instead of letting `JSON.parse` throw an opaque `SyntaxError`.
+        return undefined as T;
+      }
+
+      const json = JSON.parse(bodyText);
       return addRequestID(json as T, response);
     }
 
     const text = await response.text();
     return text as unknown as T;
-  })();
+  })().catch((error: unknown) => {
+    throw asAbortError(error, props.controller.signal);
+  });
   loggerFor(client).debug(
     `[${requestLogID}] response parsed`,
     formatRequestDetails({
@@ -83,10 +93,23 @@ export async function defaultParseResponse<T>(
   return body;
 }
 
-export type WithRequestID<T> =
-  T extends Array<any> | Response | AbstractPage<any> ? T
-  : T extends Record<string, any> ? T & { _request_id?: string | null }
-  : T;
+function asAbortError(error: unknown, signal: AbortSignal): unknown {
+  if (!signal.aborted || error !== signal.reason || isAbortError(error)) {
+    return error;
+  }
+
+  const message = 'This operation was aborted';
+  const DOMExceptionConstructor = (globalThis as any).DOMException;
+  return typeof DOMExceptionConstructor === 'function'
+    ? new DOMExceptionConstructor(message, 'AbortError')
+    : Object.assign(new Error(message), { name: 'AbortError' });
+}
+
+export type WithRequestID<T> = T extends Array<any> | Response | AbstractPage<any>
+  ? T
+  : T extends Record<string, any>
+    ? T & { _request_id?: string | null }
+    : T;
 
 export function addRequestID<T>(value: T, response: Response): WithRequestID<T> {
   if (!value || typeof value !== 'object' || Array.isArray(value)) {

package/src/internal/provider.ts

@@ -5,21 +5,39 @@ declare const providerBrand: unique symbol;
 
 /** An opaque provider configuration created by {@link createProvider}. */
 export interface Provider {
+  /** Prevents arbitrary objects from being treated as SDK-created providers. */
   readonly [providerBrand]: true;
 }
 
+/** Request details supplied to a provider immediately before each request attempt. */
 export interface ProviderRequestContext {
+  /** Absolute URL of the request being prepared. */
   url: string;
+
+  /** Final SDK request options, including the HTTP method and resource path. */
   options: FinalRequestOptions;
 }
 
+/** Provider configuration instantiated separately for each OpenAI client. */
 export interface ProviderRuntime {
+  /** Provider identifier used to distinguish the client's upstream service. */
   name: string;
+
+  /** Absolute API root used to resolve the client's resource paths. */
   baseURL: string;
+
+  /**
+   * Updates a request immediately before each attempt, including retries.
+   *
+   * Providers can refresh credentials or replace request headers in place. A
+   * rejected promise prevents that attempt from being sent.
+   */
   prepareRequest?(request: FinalizedRequestInit, context: ProviderRequestContext): void | Promise<void>;
 }
 
+/** Factory for the per-client runtime associated with an opaque provider. */
 export interface ProviderDefinition {
+  /** Creates a fresh runtime whenever the provider is attached to a client. */
   configure(): ProviderRuntime;
 }
 
@@ -45,12 +63,23 @@ if (!existingProviderDefinitions) {
   Object.defineProperty(providerGlobal, providerDefinitionsKey, { value: providerDefinitions });
 }
 
+/**
+ * Creates an opaque, immutable provider handle for a runtime definition.
+ *
+ * The definition is registered out of band and can be resolved by another
+ * installed copy of the SDK in the same JavaScript realm.
+ */
 export function createProvider(definition: ProviderDefinition): Provider {
   const provider = Object.freeze({}) as Provider;
   providerDefinitions.set(provider, definition);
   return provider;
 }
 
+/**
+ * Creates a new client-specific runtime from a previously registered provider.
+ *
+ * @throws {Error} If the value was not created with {@link createProvider}.
+ */
 export function configureProvider(provider: Provider): ProviderRuntime {
   const definition = providerDefinitions.get(provider);
   if (!definition) {

package/src/internal/qs/formats.ts

@@ -1,7 +1,7 @@
 import type { Format } from './types';
 
 export const default_format: Format = 'RFC3986';
-export const default_formatter = (v: PropertyKey) => String(v);
+export const default_formatter: (value: PropertyKey) => string = String;
 export const formatters: Record<Format, (str: PropertyKey) => string> = {
   RFC1738: (v: PropertyKey) => String(v).replace(/%20/g, '+'),
   RFC3986: default_formatter,