openai 6.40.0 → 6.42.0

package/src/bedrock.ts

@@ -0,0 +1,191 @@
+import * as Errors from './error';
+import { OpenAI } from './client';
+import type { ApiKeySetter, ClientOptions } from './client';
+import type { NullableHeaders } from './internal/headers';
+import { buildHeaders } from './internal/headers';
+import type { FinalRequestOptions, RequestOptions } from './internal/request-options';
+import { readEnv } from './internal/utils';
+import { addOutputText } from './lib/ResponsesParser';
+import type { ResponseStreamParams } from './lib/responses/ResponseStream';
+import * as API from './resources/index';
+import type * as ResponsesAPI from './resources/responses/responses';
+
+export interface BedrockClientOptions
+  extends Omit<ClientOptions, 'apiKey' | 'adminAPIKey' | 'baseURL' | 'workloadIdentity'> {
+  /**
+   * Bedrock bearer token used for authentication.
+   *
+   * Defaults to process.env['AWS_BEARER_TOKEN_BEDROCK'].
+   */
+  apiKey?: string | null | undefined;
+
+  /**
+   * Bedrock API root.
+   *
+   * Defaults to process.env['AWS_BEDROCK_BASE_URL'], or derives
+   * `https://bedrock-mantle.<region>.api.aws/openai/v1` from `awsRegion`,
+   * process.env['AWS_REGION'], or process.env['AWS_DEFAULT_REGION'].
+   */
+  baseURL?: string | null | undefined;
+
+  /**
+   * BedrockOpenAI only supports Bedrock bearer token authentication.
+   */
+  adminAPIKey?: never;
+
+  /**
+   * BedrockOpenAI only supports Bedrock bearer token authentication.
+   */
+  workloadIdentity?: never;
+
+  /**
+   * AWS region used to derive the default Bedrock Mantle endpoint.
+   *
+   * Defaults to process.env['AWS_REGION'] or process.env['AWS_DEFAULT_REGION'].
+   */
+  awsRegion?: string | undefined;
+
+  /**
+   * A function that returns a Bedrock bearer token and is invoked before each request.
+   */
+  bedrockTokenProvider?: ApiKeySetter | undefined;
+}
+
+/** Resolve the default Bedrock Mantle API root from the configured AWS region. */
+function deriveBedrockBaseURL(awsRegion: string | undefined): string {
+  const region = awsRegion?.trim();
+  if (!region) {
+    throw new Errors.OpenAIError(
+      'Must provide one of the `baseURL` or `awsRegion` arguments, or set the `AWS_BEDROCK_BASE_URL`, `AWS_REGION`, or `AWS_DEFAULT_REGION` environment variable.',
+    );
+  }
+
+  return `https://bedrock-mantle.${region}.api.aws/openai/v1`;
+}
+
+/** Normalize a Bedrock Responses URL variant back to the provider API root. */
+function normalizeBedrockBaseURL(baseURL: string): string {
+  const url = new URL(baseURL);
+  const responsesMatch = url.pathname.match(/\/responses(?:\/.*)?$/);
+  if (responsesMatch?.index !== undefined) {
+    url.pathname = url.pathname.slice(0, responsesMatch.index) || '/';
+  }
+
+  return url.toString().replace(/\/$/, '');
+}
+
+/** Restore the SDK convenience property when Bedrock omits it from a streamed final response. */
+function addBedrockOutputText<ResponseT extends ResponsesAPI.Response>(response: ResponseT): ResponseT {
+  if (!Object.getOwnPropertyDescriptor(response, 'output_text')) {
+    addOutputText(response);
+  }
+
+  return response;
+}
+
+/** Keep the standard Responses surface while repairing Bedrock streamed final responses. */
+function restoreBedrockStreamOutputText(responses: API.Responses): API.Responses {
+  const stream = responses.stream.bind(responses);
+
+  responses.stream = ((body: ResponseStreamParams, options?: RequestOptions) => {
+    const responseStream = stream(body, options);
+    const finalResponse = responseStream.finalResponse.bind(responseStream);
+    responseStream.finalResponse = async () => addBedrockOutputText(await finalResponse());
+
+    return responseStream;
+  }) as API.Responses['stream'];
+
+  return responses;
+}
+
+/** API Client for interfacing with Amazon Bedrock's OpenAI-compatible endpoint. */
+export class BedrockOpenAI extends OpenAI {
+  private readonly bedrockTokenProvider: ApiKeySetter | undefined;
+
+  /**
+   * API Client for interfacing with Amazon Bedrock's OpenAI-compatible endpoint.
+   *
+   * @param {string | null | undefined} [opts.apiKey=process.env['AWS_BEARER_TOKEN_BEDROCK'] ?? null]
+   * @param {string | null | undefined} [opts.baseURL=process.env['AWS_BEDROCK_BASE_URL'] ?? derived from opts.awsRegion or AWS_REGION/AWS_DEFAULT_REGION]
+   * @param {string | undefined} [opts.awsRegion=process.env['AWS_REGION'] ?? process.env['AWS_DEFAULT_REGION'] ?? undefined]
+   * @param {ApiKeySetter | undefined} opts.bedrockTokenProvider - A function that returns a Bedrock bearer token and is invoked before each request.
+   */
+  constructor({
+    baseURL = readEnv('AWS_BEDROCK_BASE_URL'),
+    apiKey,
+    awsRegion = readEnv('AWS_REGION') ?? readEnv('AWS_DEFAULT_REGION'),
+    bedrockTokenProvider,
+    adminAPIKey,
+    workloadIdentity,
+    ...opts
+  }: BedrockClientOptions = {}) {
+    if (adminAPIKey || workloadIdentity) {
+      throw new Errors.OpenAIError('BedrockOpenAI only supports Bedrock bearer token authentication.');
+    }
+
+    if (apiKey === undefined && !bedrockTokenProvider) {
+      apiKey = readEnv('AWS_BEARER_TOKEN_BEDROCK') ?? null;
+    }
+
+    if (typeof (apiKey as unknown) === 'function') {
+      throw new Errors.OpenAIError(
+        'Pass refreshable Bedrock credentials via `bedrockTokenProvider`, not `apiKey`.',
+      );
+    }
+
+    if (apiKey && bedrockTokenProvider) {
+      throw new Errors.OpenAIError(
+        'The `apiKey` and `bedrockTokenProvider` arguments are mutually exclusive; only one can be passed at a time.',
+      );
+    }
+
+    if (!apiKey && !bedrockTokenProvider) {
+      throw new Errors.OpenAIError(
+        'Missing credentials. Please pass an `apiKey` or `bedrockTokenProvider`, or set the `AWS_BEARER_TOKEN_BEDROCK` environment variable.',
+      );
+    }
+
+    const configuredBaseURL = baseURL?.trim() ? baseURL : deriveBedrockBaseURL(awsRegion);
+
+    super({
+      apiKey: bedrockTokenProvider ?? apiKey,
+      adminAPIKey: null,
+      baseURL: normalizeBedrockBaseURL(configuredBaseURL),
+      ...opts,
+    });
+
+    this.bedrockTokenProvider = bedrockTokenProvider;
+    this.responses = restoreBedrockStreamOutputText(new API.Responses(this));
+  }
+
+  protected override async prepareOptions(options: FinalRequestOptions): Promise<void> {
+    const security = options.__security ?? { bearerAuth: true };
+    if (security.adminAPIKeyAuth && !security.bearerAuth) {
+      await this._callApiKey();
+    }
+
+    await super.prepareOptions(options);
+  }
+
+  protected override async authHeaders(
+    opts: FinalRequestOptions,
+    schemes?: { bearerAuth?: boolean; adminAPIKeyAuth?: boolean },
+  ): Promise<NullableHeaders | undefined> {
+    const security = schemes ?? { bearerAuth: true, adminAPIKeyAuth: true };
+    if ((security.bearerAuth || security.adminAPIKeyAuth) && this.apiKey !== null) {
+      return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
+    }
+
+    return super.authHeaders(opts, security);
+  }
+
+  override withOptions(options: Partial<BedrockClientOptions>): this {
+    const bedrockTokenProvider =
+      options.apiKey !== undefined ? undefined : options.bedrockTokenProvider ?? this.bedrockTokenProvider;
+
+    return super.withOptions({
+      ...options,
+      ...(bedrockTokenProvider ? { apiKey: undefined, bedrockTokenProvider } : {}),
+    } as Partial<ClientOptions>);
+  }
+}

package/src/index.ts

@@ -26,3 +26,4 @@ export {
 } from './core/error';
 
 export { AzureOpenAI } from './azure';
+export { BedrockOpenAI, type BedrockClientOptions } from './bedrock';

package/src/resources/chat/completions/completions.ts

@@ -295,6 +295,12 @@ export interface ChatCompletion {
    */
   object: 'chat.completion';
 
+  /**
+   * Moderation results for the request input and generated output, if moderated
+   * completions were requested.
+   */
+  moderation?: ChatCompletion.Moderation | null;
+
   /**
    * Specifies the processing type used for serving the request.
    *
@@ -338,7 +344,8 @@ export namespace ChatCompletion {
      * number of tokens specified in the request was reached, `content_filter` if
      * content was omitted due to a flag from our content filters, `tool_calls` if the
      * model called a tool, or `function_call` (deprecated) if the model called a
-     * function.
+     * function. Read the [Model Spec](https://model-spec.openai.com/2025-12-18.html)
+     * for more.
      */
     finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call';
 
@@ -374,6 +381,182 @@ export namespace ChatCompletion {
       refusal: Array<ChatCompletionsAPI.ChatCompletionTokenLogprob> | null;
     }
   }
+
+  /**
+   * Moderation results for the request input and generated output, if moderated
+   * completions were requested.
+   */
+  export interface Moderation {
+    /**
+     * Moderation for the request input.
+     */
+    input: Moderation.ModerationResults | Moderation.Error;
+
+    /**
+     * Moderation for the generated output.
+     */
+    output: Moderation.ModerationResults | Moderation.Error;
+  }
+
+  export namespace Moderation {
+    /**
+     * Successful moderation results for the request input or generated output.
+     */
+    export interface ModerationResults {
+      /**
+       * The moderation model used to generate the results.
+       */
+      model: string;
+
+      /**
+       * A list of moderation results.
+       */
+      results: Array<ModerationResults.Result>;
+
+      /**
+       * The object type, which is always `moderation_results`.
+       */
+      type: 'moderation_results';
+    }
+
+    export namespace ModerationResults {
+      /**
+       * A moderation result produced for the response input or output.
+       */
+      export interface Result {
+        /**
+         * A dictionary of moderation categories to booleans, True if the input is flagged
+         * under this category.
+         */
+        categories: { [key: string]: boolean };
+
+        /**
+         * Which modalities of input are reflected by the score for each category.
+         */
+        category_applied_input_types: { [key: string]: Array<'text' | 'image'> };
+
+        /**
+         * A dictionary of moderation categories to scores.
+         */
+        category_scores: { [key: string]: number };
+
+        /**
+         * A boolean indicating whether the content was flagged by any category.
+         */
+        flagged: boolean;
+
+        /**
+         * The moderation model that produced this result.
+         */
+        model: string;
+
+        /**
+         * The object type, which was always `moderation_result` for successful moderation
+         * results.
+         */
+        type: 'moderation_result';
+      }
+    }
+
+    /**
+     * An error produced while attempting moderation.
+     */
+    export interface Error {
+      /**
+       * The error code.
+       */
+      code: string;
+
+      /**
+       * The error message.
+       */
+      message: string;
+
+      /**
+       * The object type, which is always `error`.
+       */
+      type: 'error';
+    }
+
+    /**
+     * Successful moderation results for the request input or generated output.
+     */
+    export interface ModerationResults {
+      /**
+       * The moderation model used to generate the results.
+       */
+      model: string;
+
+      /**
+       * A list of moderation results.
+       */
+      results: Array<ModerationResults.Result>;
+
+      /**
+       * The object type, which is always `moderation_results`.
+       */
+      type: 'moderation_results';
+    }
+
+    export namespace ModerationResults {
+      /**
+       * A moderation result produced for the response input or output.
+       */
+      export interface Result {
+        /**
+         * A dictionary of moderation categories to booleans, True if the input is flagged
+         * under this category.
+         */
+        categories: { [key: string]: boolean };
+
+        /**
+         * Which modalities of input are reflected by the score for each category.
+         */
+        category_applied_input_types: { [key: string]: Array<'text' | 'image'> };
+
+        /**
+         * A dictionary of moderation categories to scores.
+         */
+        category_scores: { [key: string]: number };
+
+        /**
+         * A boolean indicating whether the content was flagged by any category.
+         */
+        flagged: boolean;
+
+        /**
+         * The moderation model that produced this result.
+         */
+        model: string;
+
+        /**
+         * The object type, which was always `moderation_result` for successful moderation
+         * results.
+         */
+        type: 'moderation_result';
+      }
+    }
+
+    /**
+     * An error produced while attempting moderation.
+     */
+    export interface Error {
+      /**
+       * The error code.
+       */
+      code: string;
+
+      /**
+       * The error message.
+       */
+      message: string;
+
+      /**
+       * The object type, which is always `error`.
+       */
+      type: 'error';
+    }
+  }
 }
 
 /**
@@ -575,6 +758,12 @@ export interface ChatCompletionChunk {
    */
   object: 'chat.completion.chunk';
 
+  /**
+   * Moderation results for the request input and generated output. Present on the
+   * moderation chunk when moderated completions are requested.
+   */
+  moderation?: ChatCompletionChunk.Moderation | null;
+
   /**
    * Specifies the processing type used for serving the request.
    *
@@ -740,6 +929,182 @@ export namespace ChatCompletionChunk {
       refusal: Array<ChatCompletionsAPI.ChatCompletionTokenLogprob> | null;
     }
   }
+
+  /**
+   * Moderation results for the request input and generated output. Present on the
+   * moderation chunk when moderated completions are requested.
+   */
+  export interface Moderation {
+    /**
+     * Moderation for the request input.
+     */
+    input: Moderation.ModerationResults | Moderation.Error;
+
+    /**
+     * Moderation for the generated output.
+     */
+    output: Moderation.ModerationResults | Moderation.Error;
+  }
+
+  export namespace Moderation {
+    /**
+     * Successful moderation results for the request input or generated output.
+     */
+    export interface ModerationResults {
+      /**
+       * The moderation model used to generate the results.
+       */
+      model: string;
+
+      /**
+       * A list of moderation results.
+       */
+      results: Array<ModerationResults.Result>;
+
+      /**
+       * The object type, which is always `moderation_results`.
+       */
+      type: 'moderation_results';
+    }
+
+    export namespace ModerationResults {
+      /**
+       * A moderation result produced for the response input or output.
+       */
+      export interface Result {
+        /**
+         * A dictionary of moderation categories to booleans, True if the input is flagged
+         * under this category.
+         */
+        categories: { [key: string]: boolean };
+
+        /**
+         * Which modalities of input are reflected by the score for each category.
+         */
+        category_applied_input_types: { [key: string]: Array<'text' | 'image'> };
+
+        /**
+         * A dictionary of moderation categories to scores.
+         */
+        category_scores: { [key: string]: number };
+
+        /**
+         * A boolean indicating whether the content was flagged by any category.
+         */
+        flagged: boolean;
+
+        /**
+         * The moderation model that produced this result.
+         */
+        model: string;
+
+        /**
+         * The object type, which was always `moderation_result` for successful moderation
+         * results.
+         */
+        type: 'moderation_result';
+      }
+    }
+
+    /**
+     * An error produced while attempting moderation.
+     */
+    export interface Error {
+      /**
+       * The error code.
+       */
+      code: string;
+
+      /**
+       * The error message.
+       */
+      message: string;
+
+      /**
+       * The object type, which is always `error`.
+       */
+      type: 'error';
+    }
+
+    /**
+     * Successful moderation results for the request input or generated output.
+     */
+    export interface ModerationResults {
+      /**
+       * The moderation model used to generate the results.
+       */
+      model: string;
+
+      /**
+       * A list of moderation results.
+       */
+      results: Array<ModerationResults.Result>;
+
+      /**
+       * The object type, which is always `moderation_results`.
+       */
+      type: 'moderation_results';
+    }
+
+    export namespace ModerationResults {
+      /**
+       * A moderation result produced for the response input or output.
+       */
+      export interface Result {
+        /**
+         * A dictionary of moderation categories to booleans, True if the input is flagged
+         * under this category.
+         */
+        categories: { [key: string]: boolean };
+
+        /**
+         * Which modalities of input are reflected by the score for each category.
+         */
+        category_applied_input_types: { [key: string]: Array<'text' | 'image'> };
+
+        /**
+         * A dictionary of moderation categories to scores.
+         */
+        category_scores: { [key: string]: number };
+
+        /**
+         * A boolean indicating whether the content was flagged by any category.
+         */
+        flagged: boolean;
+
+        /**
+         * The moderation model that produced this result.
+         */
+        model: string;
+
+        /**
+         * The object type, which was always `moderation_result` for successful moderation
+         * results.
+         */
+        type: 'moderation_result';
+      }
+    }
+
+    /**
+     * An error produced while attempting moderation.
+     */
+    export interface Error {
+      /**
+       * The error code.
+       */
+      code: string;
+
+      /**
+       * The error message.
+       */
+      message: string;
+
+      /**
+       * The object type, which is always `error`.
+       */
+      type: 'error';
+    }
+  }
 }
 
 /**
@@ -1641,6 +2006,11 @@ export interface ChatCompletionCreateParamsBase {
    */
   modalities?: Array<'text' | 'audio'> | null;
 
+  /**
+   * Configuration for running moderation on the request input and generated output.
+   */
+  moderation?: ChatCompletionCreateParams.Moderation | null;
+
   /**
    * How many chat completion choices to generate for each input message. Note that
    * you will be charged based on the number of generated tokens across all of the
@@ -1897,6 +2267,17 @@ export namespace ChatCompletionCreateParams {
     parameters?: Shared.FunctionParameters;
   }
 
+  /**
+   * Configuration for running moderation on the request input and generated output.
+   */
+  export interface Moderation {
+    /**
+     * The moderation model to use for moderated completions, e.g.
+     * 'omni-moderation-latest'.
+     */
+    model: string;
+  }
+
   /**
    * This tool searches the web for relevant results to use in a response. Learn more
    * about the