openai 7.4.0 → 7.6.0

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

package/src/lib/webhook-signature.ts

@@ -0,0 +1,164 @@
+import { InvalidWebhookSignatureError } from '../error';
+import { fromBase64 } from '../internal/utils/base64';
+import { encodeUTF8 } from '../internal/utils/bytes';
+
+const MAX_DIRECT_WEBHOOK_VERIFICATIONS = 32;
+const SHA256_SIGNATURE_LENGTH = 32;
+
+/**
+ * Checks whether a webhook header requires constant-work HMAC signing without
+ * retaining an unbounded number of signature candidates.
+ *
+ * @internal
+ */
+export function webhookSignatureRequiresSigning(signatureHeader: string): boolean {
+  return (
+    signatureHeader.split(' ', MAX_DIRECT_WEBHOOK_VERIFICATIONS + 1).length > MAX_DIRECT_WEBHOOK_VERIFICATIONS
+  );
+}
+
+function* signatureCandidates(signatureHeader: string): Generator<string> {
+  let start = 0;
+
+  while (start <= signatureHeader.length) {
+    const separator = signatureHeader.indexOf(' ', start);
+    const candidate = signatureHeader.slice(start, separator === -1 ? undefined : separator);
+    yield candidate.startsWith('v1,') ? candidate.slice(3) : candidate;
+
+    if (separator === -1) {
+      break;
+    }
+    start = separator + 1;
+  }
+}
+
+function decodeSignature(signature: string): Uint8Array | undefined {
+  try {
+    const signatureBytes = fromBase64(signature);
+    return signatureBytes.byteLength === SHA256_SIGNATURE_LENGTH ? signatureBytes : undefined;
+  } catch {
+    // Invalid base64 does not prevent trying the next value.
+    return undefined;
+  }
+}
+
+function firstValidLengthSignature(signatureHeader: string): Uint8Array | undefined {
+  for (const signature of signatureCandidates(signatureHeader)) {
+    const signatureBytes = decodeSignature(signature);
+    if (signatureBytes) {
+      return signatureBytes;
+    }
+  }
+
+  return undefined;
+}
+
+function selectMatchingSignature(
+  signatureHeader: string,
+  expectedSignature: Uint8Array,
+  firstSignature: Uint8Array,
+): Uint8Array {
+  let matchingSignature = firstSignature;
+
+  for (const signature of signatureCandidates(signatureHeader)) {
+    const signatureBytes = decodeSignature(signature);
+    if (!signatureBytes) {
+      continue;
+    }
+
+    let difference = 0;
+    for (const [index, byte] of signatureBytes.entries()) {
+      // oxlint-disable-next-line no-bitwise -- Compare every HMAC byte without short-circuiting on shared prefixes.
+      difference |= byte ^ (expectedSignature[index] ?? 0);
+    }
+    if (difference === 0) {
+      matchingSignature = signatureBytes;
+    }
+  }
+
+  return matchingSignature;
+}
+
+/**
+ * Checks the timestamp and HMAC signatures after the resource has validated its
+ * crypto capabilities, secret, and required headers.
+ *
+ * @internal
+ */
+export async function verifyWebhookSignature(
+  payload: string,
+  signatureHeader: string,
+  timestamp: string,
+  webhookId: string,
+  secret: string,
+  tolerance: number,
+): Promise<void> {
+  // oxlint-disable-next-line unicorn/prefer-number-coercion -- Preserve numeric-prefix parsing while signing the original timestamp text.
+  const timestampSeconds = Number.parseInt(timestamp, 10);
+  if (Number.isNaN(timestampSeconds)) {
+    throw new InvalidWebhookSignatureError('Invalid webhook timestamp format');
+  }
+
+  const nowSeconds = Math.floor(Date.now() / 1000);
+  if (nowSeconds - timestampSeconds > tolerance) {
+    throw new InvalidWebhookSignatureError('Webhook timestamp is too old');
+  }
+  if (timestampSeconds > nowSeconds + tolerance) {
+    throw new InvalidWebhookSignatureError('Webhook timestamp is too new');
+  }
+
+  // Multiple signatures are space-separated; accept a matching value at any position.
+  const useBoundedVerification = webhookSignatureRequiresSigning(signatureHeader);
+  const firstSignature = useBoundedVerification ? firstValidLengthSignature(signatureHeader) : undefined;
+
+  if (useBoundedVerification && !firstSignature) {
+    throw new InvalidWebhookSignatureError(
+      'The given webhook signature does not match the expected signature',
+    );
+  }
+
+  const decodedSecret = Uint8Array.from(
+    secret.startsWith('whsec_') ? fromBase64(secret.slice('whsec_'.length)) : encodeUTF8(secret),
+  );
+  const signedPayload = webhookId ? `${webhookId}.${timestamp}.${payload}` : `${timestamp}.${payload}`;
+  const signedPayloadBytes = Uint8Array.from(encodeUTF8(signedPayload));
+  const key = await crypto.subtle.importKey(
+    'raw',
+    decodedSecret,
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    useBoundedVerification ? ['sign', 'verify'] : ['verify'],
+  );
+
+  if (useBoundedVerification && firstSignature) {
+    const expectedSignature = new Uint8Array(await crypto.subtle.sign('HMAC', key, signedPayloadBytes));
+    const signatureToVerify = selectMatchingSignature(signatureHeader, expectedSignature, firstSignature);
+
+    try {
+      if (await crypto.subtle.verify('HMAC', key, Uint8Array.from(signatureToVerify), signedPayloadBytes)) {
+        return;
+      }
+    } catch {
+      // Provider verification failures have the same typed mismatch as the direct path.
+    }
+
+    throw new InvalidWebhookSignatureError(
+      'The given webhook signature does not match the expected signature',
+    );
+  }
+
+  for (const signature of signatureCandidates(signatureHeader)) {
+    try {
+      const signatureBytes = Uint8Array.from(fromBase64(signature));
+      // oxlint-disable-next-line no-await-in-loop -- Check signatures in order and stop at the first match.
+      const isValid = await crypto.subtle.verify('HMAC', key, signatureBytes, signedPayloadBytes);
+      if (isValid) {
+        return;
+      }
+    } catch {
+      // Invalid base64 or signature format does not prevent trying the next value.
+    }
+  }
+
+  throw new InvalidWebhookSignatureError('The given webhook signature does not match the expected signature');
+}

package/src/providers/bedrock/aws.ts

@@ -5,43 +5,62 @@ import { SignatureV4 } from '@smithy/signature-v4';
 import * as Errors from '../../error';
 import type { BodyInit } from '../../internal/builtin-types';
 import {
+  assertBedrockRequestOrigin,
   assertProviderOwnsAuthorization,
   errorWithCause,
   normalizeOptionalString,
+  parseBedrockEndpointHostname,
   resolveBedrockBearerAuth,
   resolveBedrockEndpoint,
-  type BedrockBearerOptions,
-  type BedrockEndpointOptions,
-  type BedrockRequestAuth,
 } from '../../internal/bedrock';
-import { createProvider, type Provider, type ProviderRequestContext } from '../../internal/provider';
+import type {
+  BedrockBearerOptions,
+  BedrockEndpoint,
+  BedrockEndpointOptions,
+  BedrockRequestAuth,
+} from '../../internal/bedrock';
+import { createProvider } from '../../internal/provider';
+import type { Provider, ProviderRequestContext } from '../../internal/provider';
 import type { FinalizedRequestInit } from '../../internal/types';
 
-const BEDROCK_SERVICE = 'bedrock-mantle';
-
+/** AWS credentials used to sign an Amazon Bedrock request with Signature Version 4. */
 export interface AwsCredentialIdentity {
+  /** AWS access-key identifier associated with the signing identity. */
   accessKeyId: string;
+
+  /** Secret access key paired with the AWS access-key identifier. */
   secretAccessKey: string;
+
+  /** Session token required by temporary AWS credentials, when present. */
   sessionToken?: string;
+
+  /** Expiration timestamp supplied by a refreshable temporary-credential provider. */
   expiration?: Date;
 }
 
+/** Resolves current AWS signing credentials before a Bedrock request attempt. */
 export type AwsCredentialsProvider = () => AwsCredentialIdentity | Promise<AwsCredentialIdentity>;
 
+/**
+ * Configures a Bedrock endpoint and exactly one explicit bearer or AWS credential mode.
+ *
+ * When no explicit credential mode is supplied, `AWS_BEARER_TOKEN_BEDROCK` is
+ * preferred, followed by the default AWS credential-provider chain.
+ */
 export interface BedrockProviderOptions extends BedrockEndpointOptions, BedrockBearerOptions {
-  /** Explicit AWS access key ID. Must be paired with secretAccessKey. */
+  /** Explicit AWS access-key identifier; must be paired with `secretAccessKey`. */
   accessKeyId?: string | undefined;
 
-  /** Explicit AWS secret access key. Must be paired with accessKeyId. */
+  /** Explicit AWS secret access key; must be paired with `accessKeyId`. */
   secretAccessKey?: string | undefined;
 
-  /** Optional session token for explicit temporary AWS credentials. */
+  /** Session token for explicit temporary AWS credentials; requires both access-key fields. */
   sessionToken?: string | undefined;
 
-  /** Explicit AWS shared-config profile. */
+  /** AWS shared-config profile; cannot be combined with another explicit credential mode. */
   profile?: string | undefined;
 
-  /** A refreshable provider returning AWS credentials. */
+  /** Refreshable signing-credential provider invoked for each request attempt, including retries. */
   credentialProvider?: AwsCredentialsProvider | undefined;
 }
 
@@ -53,7 +72,9 @@ function validateStaticCredentials(options: BedrockProviderOptions): AwsCredenti
       'The `accessKeyId` and `secretAccessKey` options must be provided together. A `sessionToken` may only be used with both.',
     );
   }
-  if (!hasAccessKey) return undefined;
+  if (!hasAccessKey) {
+    return undefined;
+  }
 
   if (
     typeof options.accessKeyId !== 'string' ||
@@ -80,20 +101,33 @@ function validateStaticCredentials(options: BedrockProviderOptions): AwsCredenti
 }
 
 function requestTarget(parsedURL: URL): { path: string; query: Record<string, string | string[]> } {
-  const query: Record<string, string | string[]> = {};
+  const query: Record<string, string | string[]> = Object.create(null);
   for (const [name, value] of parsedURL.searchParams) {
+    if (name === '__proto__') {
+      throw new Errors.OpenAIError(
+        'The Bedrock SigV4 signer cannot safely sign a `__proto__` query parameter.',
+      );
+    }
+
     const existing = query[name];
-    query[name] =
-      existing === undefined ? value
-      : typeof existing === 'string' ? [existing, value]
-      : [...existing, value];
+    if (existing === undefined) {
+      query[name] = value;
+    } else if (typeof existing === 'string') {
+      query[name] = [existing, value];
+    } else {
+      query[name] = [...existing, value];
+    }
   }
   return { path: parsedURL.pathname, query };
 }
 
 function signableBody(body: BodyInit | null | undefined): string | ArrayBuffer | ArrayBufferView | undefined {
-  if (body === undefined || body === null) return undefined;
-  if (typeof body === 'string' || body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return body;
+  if (body === undefined || body === null) {
+    return undefined;
+  }
+  if (typeof body === 'string' || body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+    return body;
+  }
   throw new Errors.OpenAIError(
     "The SDK's Bedrock SigV4 mode requires a replayable request body. Buffer the body before sending or use bearer authentication.",
   );
@@ -115,22 +149,28 @@ function validateCredentialIdentity(identity: AwsCredentialIdentity): AwsCredent
   return identity;
 }
 
+type BedrockSigV4AuthOptions = {
+  endpoint: BedrockEndpoint;
+  region: string;
+  staticCredentials?: AwsCredentialIdentity | undefined;
+  profile?: string | undefined;
+  credentialProvider?: AwsCredentialsProvider | undefined;
+  usesDefaultChain: boolean;
+};
+
 class BedrockSigV4Auth implements BedrockRequestAuth {
   private signer: SignatureV4 | undefined;
   private resolvedCredentialsProvider: (() => Promise<AwsCredentialIdentity>) | undefined;
+  private readonly options: BedrockSigV4AuthOptions;
 
-  constructor(
-    private readonly options: {
-      region: string;
-      staticCredentials?: AwsCredentialIdentity | undefined;
-      profile?: string | undefined;
-      credentialProvider?: AwsCredentialsProvider | undefined;
-      usesDefaultChain: boolean;
-    },
-  ) {}
+  constructor(options: BedrockSigV4AuthOptions) {
+    this.options = options;
+  }
 
   private credentialsProvider(): () => Promise<AwsCredentialIdentity> {
-    if (this.resolvedCredentialsProvider) return this.resolvedCredentialsProvider;
+    if (this.resolvedCredentialsProvider) {
+      return this.resolvedCredentialsProvider;
+    }
 
     if (this.options.staticCredentials) {
       const credentials = this.options.staticCredentials;
@@ -149,7 +189,7 @@ class BedrockSigV4Auth implements BedrockRequestAuth {
     return (this.signer ??= new SignatureV4({
       credentials: this.credentialsProvider(),
       region: this.options.region,
-      service: BEDROCK_SERVICE,
+      service: this.options.endpoint === 'runtime' ? 'bedrock' : 'bedrock-mantle',
       sha256: Hash.bind(null, 'sha256'),
     }));
   }
@@ -162,10 +202,15 @@ class BedrockSigV4Auth implements BedrockRequestAuth {
     }
 
     const parsedURL = new URL(url);
-    const canonicalRegion = /^bedrock-mantle\.([a-z0-9-]+)\.api\.aws$/i.exec(parsedURL.hostname)?.[1];
-    if (canonicalRegion && canonicalRegion !== this.options.region) {
+    const canonicalEndpoint = parseBedrockEndpointHostname(parsedURL.hostname);
+    if (canonicalEndpoint && canonicalEndpoint.endpoint !== this.options.endpoint) {
       throw new Errors.OpenAIError(
-        `The Bedrock endpoint region \`${canonicalRegion}\` does not match the SigV4 region \`${this.options.region}\`.`,
+        `The Bedrock ${canonicalEndpoint.endpoint} hostname does not match the selected \`${this.options.endpoint}\` endpoint.`,
+      );
+    }
+    if (canonicalEndpoint && canonicalEndpoint.region !== this.options.region) {
+      throw new Errors.OpenAIError(
+        `The Bedrock endpoint region \`${canonicalEndpoint.region}\` does not match the SigV4 region \`${this.options.region}\`.`,
       );
     }
 
@@ -178,6 +223,7 @@ class BedrockSigV4Auth implements BedrockRequestAuth {
 
     const method = (request.method ?? 'GET').toUpperCase();
     const body = signableBody(request.body);
+    const target = requestTarget(parsedURL);
 
     let signed: { headers: Record<string, string> };
     try {
@@ -186,14 +232,13 @@ class BedrockSigV4Auth implements BedrockRequestAuth {
         hostname: parsedURL.hostname,
         ...(parsedURL.port ? { port: Number(parsedURL.port) } : {}),
         method,
-        ...requestTarget(parsedURL),
+        ...target,
         headers: Object.fromEntries(headers.entries()),
-        ...(body !== undefined ? { body } : {}),
+        ...(body === undefined ? {} : { body }),
       });
     } catch (cause) {
-      const message =
-        this.options.usesDefaultChain ?
-          'Could not find credentials for Bedrock. Pass AWS credentials to `bedrock(...)` or configure the default AWS credential chain.'
+      const message = this.options.usesDefaultChain
+        ? 'Could not find credentials for Bedrock. Pass AWS credentials to `bedrock(...)` or configure the default AWS credential chain.'
         : 'Failed to resolve AWS credentials for Bedrock. Verify your AWS profile, environment variables, or runtime identity configuration and try again.';
       throw errorWithCause(message, cause);
     }
@@ -204,7 +249,22 @@ class BedrockSigV4Auth implements BedrockRequestAuth {
   }
 }
 
-/** Configure the standard OpenAI client for Amazon Bedrock using bearer or AWS authentication. */
+/**
+ * Configures the standard OpenAI client for Amazon Bedrock bearer or AWS SigV4 authentication.
+ *
+ * Explicit bearer credentials, static AWS credentials, a shared-config profile,
+ * and a credential provider are mutually exclusive. Without explicit
+ * credentials, `AWS_BEARER_TOKEN_BEDROCK` takes precedence over the default AWS
+ * credential chain. The region defaults to `AWS_REGION` or `AWS_DEFAULT_REGION`.
+ *
+ * This entrypoint requires `@aws-sdk/credential-provider-node`,
+ * `@smithy/hash-node`, and `@smithy/signature-v4`. AWS signing is available in
+ * Node.js-compatible server runtimes and requires replayable request bodies.
+ *
+ * @param options Bedrock endpoint and optional explicit authentication settings.
+ * @returns A provider accepted by `new OpenAI({ provider })`.
+ * @throws {OpenAIError} If endpoint settings or credential modes are invalid or ambiguous.
+ */
 export function bedrock(options: BedrockProviderOptions = {}): Provider {
   const staticCredentials = validateStaticCredentials(options);
   const profile = normalizeOptionalString(options.profile);
@@ -226,12 +286,21 @@ export function bedrock(options: BedrockProviderOptions = {}): Provider {
     );
   }
 
-  const { region, baseURL } = resolveBedrockEndpoint(options);
+  const { endpoint, region, baseURL } = resolveBedrockEndpoint(options);
   if (!bearerAuth.factory && !region) {
     throw new Errors.OpenAIError(
       'Bedrock requires an AWS region. Pass `region` to `bedrock(...)`, or set `AWS_REGION` or `AWS_DEFAULT_REGION`.',
     );
   }
+  if (
+    !bearerAuth.factory &&
+    options.endpoint === undefined &&
+    !parseBedrockEndpointHostname(new URL(baseURL).hostname)
+  ) {
+    throw new Errors.OpenAIError(
+      'A custom Bedrock endpoint requires an explicit `endpoint` option when using AWS credential authentication.',
+    );
+  }
   const credentialProvider = options.credentialProvider;
 
   return createProvider({
@@ -239,6 +308,7 @@ export function bedrock(options: BedrockProviderOptions = {}): Provider {
       const auth =
         bearerAuth.factory?.() ??
         new BedrockSigV4Auth({
+          endpoint,
           region: region!,
           staticCredentials,
           profile,
@@ -248,7 +318,10 @@ export function bedrock(options: BedrockProviderOptions = {}): Provider {
       return {
         name: 'bedrock',
         baseURL,
-        prepareRequest: auth.prepareRequest.bind(auth),
+        async prepareRequest(request, context) {
+          assertBedrockRequestOrigin(baseURL, context.url);
+          await auth.prepareRequest(request, context);
+        },
       };
     },
   });

package/src/providers/bedrock.ts

@@ -2,15 +2,30 @@ import * as Errors from '../error';
 import type { Provider } from '../internal/provider';
 import { createProvider } from '../internal/provider';
 import {
+  assertBedrockRequestOrigin,
   resolveBedrockBearerAuth,
   resolveBedrockEndpoint,
-  type BedrockBearerOptions,
-  type BedrockEndpointOptions,
 } from '../internal/bedrock';
+import type { BedrockBearerOptions, BedrockEndpointOptions } from '../internal/bedrock';
 
+/** Endpoint and bearer-credential settings for the dependency-free Amazon Bedrock provider. */
 export interface BedrockProviderOptions extends BedrockEndpointOptions, BedrockBearerOptions {}
 
-/** Configure the standard OpenAI client for Amazon Bedrock using bearer authentication. */
+/**
+ * Configures the standard OpenAI client for Amazon Bedrock bearer authentication.
+ *
+ * Supply `apiKey` or `tokenProvider`, or set `AWS_BEARER_TOKEN_BEDROCK`.
+ * The endpoint defaults to Mantle; pass `endpoint: 'runtime'` to use Bedrock
+ * Runtime. The region defaults to `AWS_REGION` or `AWS_DEFAULT_REGION`, and a
+ * custom endpoint can be supplied with `baseURL` or `AWS_BEDROCK_BASE_URL`.
+ *
+ * This entrypoint has no AWS SDK dependencies. To use AWS credentials or
+ * Signature Version 4, import `bedrock` from `openai/providers/bedrock/aws`.
+ *
+ * @param options Bedrock endpoint and mutually exclusive bearer-credential settings.
+ * @returns A provider accepted by `new OpenAI({ provider })`.
+ * @throws {OpenAIError} If no usable endpoint or bearer credential is configured.
+ */
 export function bedrock(options: BedrockProviderOptions = {}): Provider {
   const { baseURL } = resolveBedrockEndpoint(options);
   const { factory } = resolveBedrockBearerAuth(options);
@@ -26,7 +41,10 @@ export function bedrock(options: BedrockProviderOptions = {}): Provider {
       return {
         name: 'bedrock',
         baseURL,
-        prepareRequest: auth.prepareRequest.bind(auth),
+        async prepareRequest(request, context) {
+          assertBedrockRequestOrigin(baseURL, context.url);
+          await auth.prepareRequest(request, context);
+        },
       };
     },
   });