openai 7.3.0 → 7.5.0

package/src/internal/bedrock.ts

@@ -4,37 +4,65 @@ import type { FinalizedRequestInit } from './types';
 import type { ProviderRequestContext } from './provider';
 import { readEnv } from './utils';
 
+/** Identifies legacy Bedrock clients without importing the client class into WebSocket modules. */
+export const brand_privateBedrockClient = Symbol.for('openai.privateBedrockClient');
+
+/** Selects the regional Amazon Bedrock endpoint and its matching SigV4 service. */
+export type BedrockEndpoint = 'mantle' | 'runtime';
+
+/** Endpoint and region settings shared by the Bedrock provider variants. */
 export interface BedrockEndpointOptions {
-  /** AWS region used to derive the default Mantle endpoint. */
+  /**
+   * Amazon Bedrock endpoint family. Recognized AWS endpoint overrides select
+   * their own family; otherwise defaults to `mantle` for compatibility.
+   */
+  endpoint?: BedrockEndpoint | undefined;
+
+  /**
+   * AWS region used to derive the selected endpoint and sign AWS requests.
+   * Defaults to `AWS_REGION`, then `AWS_DEFAULT_REGION`.
+   */
   region?: string | undefined;
 
-  /** Bedrock API root. Defaults to AWS_BEDROCK_BASE_URL or the regional Mantle endpoint. */
+  /**
+   * Bedrock API root. Defaults to `AWS_BEDROCK_BASE_URL`, then the regional
+   * selected endpoint. Set to `null` to bypass the environment override.
+   */
   baseURL?: string | null | undefined;
 }
 
+/** Mutually exclusive sources for a Bedrock bearer credential. */
 export interface BedrockBearerOptions {
-  /** Explicit Bedrock bearer credential. Set to null to skip the environment bearer fallback. */
+  /**
+   * Explicit Bedrock bearer credential. Set to `null` to disable the
+   * `AWS_BEARER_TOKEN_BEDROCK` fallback.
+   */
   apiKey?: string | null | undefined;
 
-  /** A function that resolves a Bedrock bearer credential before every request attempt. */
+  /** Resolves a fresh bearer credential before every request attempt and retry. */
   tokenProvider?: ApiKeySetter | undefined;
 }
 
+/** Per-client authentication handler invoked before each Bedrock request. */
 export interface BedrockRequestAuth {
+  /** Adds provider-owned authentication headers or rejects invalid credentials. */
   prepareRequest(request: FinalizedRequestInit, context: ProviderRequestContext): void | Promise<void>;
 }
 
+/** Creates an authentication handler with independent per-client state. */
 export type BedrockAuthFactory = () => BedrockRequestAuth;
 
+/** Wraps a provider failure in an SDK error while preserving its original cause. */
 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;
 }
 
+/** Trims a configuration string, treating missing and whitespace-only values as absent. */
 export function normalizeOptionalString(value: string | null | undefined): string | undefined {
   const normalized = typeof value === 'string' ? value.trim() : undefined;
-  return normalized ? normalized : undefined;
+  return normalized || undefined;
 }
 
 function normalizeBaseURL(baseURL: string): string {
@@ -46,10 +74,109 @@ function normalizeBaseURL(baseURL: string): string {
   return url.toString().replace(/\/$/, '');
 }
 
+function resolveRuntimeDnsSuffixes(region: string): readonly [standard: string, dualStack: string] {
+  if (region.startsWith('cn-')) {
+    return ['amazonaws.com.cn', 'api.amazonwebservices.com.cn'];
+  }
+  if (region.startsWith('eusc-')) {
+    return ['amazonaws.eu', 'api.amazonwebservices.eu'];
+  }
+  if (region.startsWith('us-iso-')) {
+    return ['c2s.ic.gov', 'api.aws.ic.gov'];
+  }
+  if (region.startsWith('us-isob-')) {
+    return ['sc2s.sgov.gov', 'api.aws.scloud'];
+  }
+  if (region.startsWith('eu-isoe-')) {
+    return ['cloud.adc-e.uk', 'api.cloud-aws.adc-e.uk'];
+  }
+  if (region.startsWith('us-isof-')) {
+    return ['csp.hci.ic.gov', 'api.aws.hci.ic.gov'];
+  }
+  return ['amazonaws.com', 'api.aws'];
+}
+
+/** Identifies a canonical Amazon Bedrock hostname and its embedded AWS region. */
+export function parseBedrockEndpointHostname(hostname: string):
+  | {
+      /** Endpoint family identified by the canonical AWS hostname. */
+      endpoint: BedrockEndpoint;
+
+      /** AWS region embedded in the canonical endpoint hostname. */
+      region: string;
+    }
+  | undefined {
+  const canonicalHostname = hostname.endsWith('.') ? hostname.slice(0, -1) : hostname;
+  const [service, region, ...suffixParts] = canonicalHostname.toLowerCase().split('.');
+  const suffix = suffixParts.join('.');
+
+  if (service === 'bedrock-mantle' && region && /^[a-z0-9-]+$/.test(region) && suffix === 'api.aws') {
+    return { endpoint: 'mantle', region };
+  }
+
+  if ((service === 'bedrock-runtime' || service === 'bedrock-runtime-fips') && region) {
+    const [standardSuffix, dualStackSuffix] = resolveRuntimeDnsSuffixes(region);
+    if (suffix === standardSuffix || suffix === dualStackSuffix) {
+      return { endpoint: 'runtime', region };
+    }
+  }
+
+  return undefined;
+}
+
+/** Rejects insecure or mismatched canonical Amazon Bedrock endpoint overrides. */
+function validateCanonicalBedrockEndpoint(
+  baseURL: string,
+  endpoint: BedrockEndpoint,
+  region: string | undefined,
+): void {
+  const parsedBaseURL = new URL(baseURL);
+  const canonicalEndpoint = parseBedrockEndpointHostname(parsedBaseURL.hostname);
+  if (canonicalEndpoint && parsedBaseURL.protocol !== 'https:') {
+    throw new Errors.OpenAIError('Canonical Amazon Bedrock endpoints require HTTPS.');
+  }
+  if (canonicalEndpoint && canonicalEndpoint.endpoint !== endpoint) {
+    throw new Errors.OpenAIError(
+      `The Bedrock ${canonicalEndpoint.endpoint} hostname does not match the selected \`${endpoint}\` endpoint. Set \`endpoint: '${canonicalEndpoint.endpoint}'\` to use this hostname.`,
+    );
+  }
+  if (canonicalEndpoint && region && canonicalEndpoint.region !== region) {
+    throw new Errors.OpenAIError(
+      `The Bedrock endpoint region \`${canonicalEndpoint.region}\` does not match the configured AWS region \`${region}\`.`,
+    );
+  }
+}
+
+function validateBedrockEndpointSelection(endpoint: BedrockEndpoint | undefined): void {
+  if (endpoint !== undefined && endpoint !== 'mantle' && endpoint !== 'runtime') {
+    throw new Errors.OpenAIError('The Bedrock `endpoint` must be either `mantle` or `runtime`.');
+  }
+}
+
+/**
+ * Resolves the Bedrock endpoint family, region, and API root from configuration.
+ *
+ * Region precedence is `region`, `AWS_REGION`, then `AWS_DEFAULT_REGION`.
+ * Endpoint precedence is `baseURL`, `AWS_BEDROCK_BASE_URL`, then the regional
+ * selected endpoint; an explicit `null` base URL skips the environment override.
+ * Existing `/responses` suffixes and trailing slashes are removed. Canonical
+ * AWS hostnames infer the endpoint family when none is selected explicitly.
+ * Other configured URLs and derived endpoints default to Mantle.
+ *
+ * @throws {Errors.OpenAIError} If an option is invalid, a canonical hostname
+ * conflicts with the endpoint family, or the default endpoint needs a region.
+ */
 export function resolveBedrockEndpoint(options: BedrockEndpointOptions): {
+  /** Resolved endpoint family, defaulting to Mantle for backwards compatibility. */
+  endpoint: BedrockEndpoint;
+
+  /** Resolved AWS region, when explicitly configured or available in the environment. */
   region: string | undefined;
+
+  /** Canonical Bedrock API root with no trailing slash or `/responses` suffix. */
   baseURL: string;
 } {
+  validateBedrockEndpointSelection(options.endpoint);
   if (options.region !== undefined && !normalizeOptionalString(options.region)) {
     throw new Errors.OpenAIError('The Bedrock AWS `region` must not be empty.');
   }
@@ -65,20 +192,82 @@ export function resolveBedrockEndpoint(options: BedrockEndpointOptions): {
     normalizeOptionalString(options.region) ??
     normalizeOptionalString(readEnv('AWS_REGION')) ??
     normalizeOptionalString(readEnv('AWS_DEFAULT_REGION'));
+  if (region && !/^[a-z]{2,8}(?:-[a-z0-9]+)+-\d+$/.test(region)) {
+    throw new Errors.OpenAIError(
+      'The Bedrock AWS `region` is invalid. Use a standard AWS region such as `us-east-1`.',
+    );
+  }
   const configuredBaseURL =
-    options.baseURL === undefined ? normalizeOptionalString(readEnv('AWS_BEDROCK_BASE_URL'))
-    : options.baseURL === null ? undefined
-    : normalizeOptionalString(options.baseURL);
+    options.baseURL === undefined
+      ? normalizeOptionalString(readEnv('AWS_BEDROCK_BASE_URL'))
+      : normalizeOptionalString(options.baseURL);
 
-  if (configuredBaseURL) return { region, baseURL: normalizeBaseURL(configuredBaseURL) };
+  if (configuredBaseURL) {
+    const baseURL = normalizeBaseURL(configuredBaseURL);
+    const endpoint =
+      options.endpoint ?? parseBedrockEndpointHostname(new URL(baseURL).hostname)?.endpoint ?? 'mantle';
+    validateCanonicalBedrockEndpoint(baseURL, endpoint, region);
+    return { endpoint, region, baseURL };
+  }
+  const endpoint = options.endpoint ?? 'mantle';
   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` };
+
+  const hostname =
+    endpoint === 'runtime'
+      ? `bedrock-runtime.${region}.${resolveRuntimeDnsSuffixes(region)[0]}`
+      : `bedrock-mantle.${region}.api.aws`;
+  return { endpoint, region, baseURL: `https://${hostname}/openai/v1` };
+}
+
+/**
+ * Ensures Bedrock credentials are only attached to the configured endpoint origin.
+ *
+ * @throws {Errors.OpenAIError} If either URL is not HTTP(S) or the request targets a different origin.
+ */
+export function assertBedrockRequestOrigin(baseURL: string, requestURL: string): void {
+  const expectedURL = new URL(baseURL);
+  const request = new URL(requestURL);
+  const expectedOrigin = expectedURL.origin;
+  const requestOrigin = request.origin;
+  if (
+    (expectedURL.protocol !== 'http:' && expectedURL.protocol !== 'https:') ||
+    (request.protocol !== 'http:' && request.protocol !== 'https:') ||
+    requestOrigin !== expectedOrigin
+  ) {
+    throw new Errors.OpenAIError(
+      `Bedrock request origin \`${requestOrigin}\` does not match the configured base URL origin \`${expectedOrigin}\`.`,
+    );
+  }
+}
+
+/** Validates a final WebSocket URL before a legacy Bedrock client resolves or attaches credentials. */
+export function assertBedrockWebSocketOrigin(client: unknown, requestURL: URL): void {
+  if (typeof client !== 'object' || client === null || !(brand_privateBedrockClient in client)) {
+    return;
+  }
+
+  const normalizedRequestURL = new URL(requestURL);
+  if (normalizedRequestURL.protocol === 'wss:') {
+    normalizedRequestURL.protocol = 'https:';
+  } else if (normalizedRequestURL.protocol === 'ws:') {
+    normalizedRequestURL.protocol = 'http:';
+  }
+
+  assertBedrockRequestOrigin(
+    (client as unknown as { baseURL: string }).baseURL,
+    normalizedRequestURL.toString(),
+  );
 }
 
+/**
+ * Rejects caller-provided authorization headers that conflict with provider authentication.
+ *
+ * @throws {Errors.OpenAIError} If an `Authorization` header is already present.
+ */
 export function assertProviderOwnsAuthorization(headers: Headers): void {
   if (headers.has('authorization')) {
     throw new Errors.OpenAIError(
@@ -88,7 +277,11 @@ export function assertProviderOwnsAuthorization(headers: Headers): void {
 }
 
 class BedrockBearerAuth implements BedrockRequestAuth {
-  constructor(private readonly tokenProvider: ApiKeySetter) {}
+  private readonly tokenProvider: ApiKeySetter;
+
+  constructor(tokenProvider: ApiKeySetter) {
+    this.tokenProvider = tokenProvider;
+  }
 
   async prepareRequest(request: FinalizedRequestInit, _context: ProviderRequestContext): Promise<void> {
     const headers = new Headers(request.headers);
@@ -104,14 +297,36 @@ class BedrockBearerAuth implements BedrockRequestAuth {
       throw new Errors.OpenAIError('The Bedrock bearer credential provider must return a non-empty string.');
     }
     headers.set('authorization', `Bearer ${token}`);
+    request.redirect = 'manual';
     request.headers = headers;
   }
 }
 
+/**
+ * Resolves a bearer-authentication factory without calling token providers eagerly.
+ *
+ * Explicit `tokenProvider` and `apiKey` options are mutually exclusive. When
+ * neither is set, `AWS_BEARER_TOKEN_BEDROCK` is used unless environment
+ * credentials are disabled or `apiKey` is explicitly `null`.
+ *
+ * @throws {Errors.OpenAIError} If an explicit key is empty or multiple bearer
+ * credential sources are configured.
+ */
 export function resolveBedrockBearerAuth(
   options: BedrockBearerOptions,
-  { allowEnvironment = true }: { allowEnvironment?: boolean } = {},
-): { factory: BedrockAuthFactory | undefined; explicit: boolean } {
+  {
+    allowEnvironment = true,
+  }: {
+    /** Whether `AWS_BEARER_TOKEN_BEDROCK` may provide a fallback credential. */
+    allowEnvironment?: boolean;
+  } = {},
+): {
+  /** Creates a request authenticator, or is absent when no bearer source is configured. */
+  factory: BedrockAuthFactory | undefined;
+
+  /** Whether authentication came from an explicit option rather than the environment. */
+  explicit: boolean;
+} {
   if (
     options.apiKey !== undefined &&
     options.apiKey !== null &&

package/src/internal/builtin-types.ts

@@ -1,5 +1,3 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
 export type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 
 /**

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;