openai 7.19.0 → 7.21.0

package/src/resources/responses/responses.ts

@@ -73,6 +73,123 @@ export interface ParsedResponse<ParsedT> extends Response {
 
 export type ResponseParseParams = ResponseCreateParamsNonStreaming;
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
+// Recognizable options across SDK runtime versions. Keep this independent of
+// private RequestOptions fields so older handwritten runtimes still compile.
+const normalizeRequestOptionsForQueryKeys = new Set([
+  'method',
+  'path',
+  'query',
+  'body',
+  'headers',
+  'maxRetries',
+  'stream',
+  'timeout',
+  'httpAgent',
+  'fetchOptions',
+  'signal',
+  'idempotencyKey',
+  'defaultBaseURL',
+  '__metadata',
+  '__binaryRequest',
+  '__binaryResponse',
+  '__streamClass',
+  '__security',
+  '__synthesizeEventData',
+]);
+
+function normalizeRequestOptionsForQuery(
+  value: unknown,
+  queryKeys: ReadonlyArray<string>,
+  options: RequestOptions | undefined,
+):
+  | ({
+      [K in 'headers' | 'maxRetries' | 'timeout' | 'signal' | 'idempotencyKey' | 'query']?: RequestOptions[K];
+    } & {
+      [
+        K in
+          | 'method'
+          | 'path'
+          | 'body'
+          | 'stream'
+          | 'httpAgent'
+          | 'fetchOptions'
+          | 'defaultBaseURL'
+          | '__metadata'
+          | '__binaryRequest'
+          | '__binaryResponse'
+          | '__streamClass'
+          | '__security'
+          | '__synthesizeEventData'
+      ]?: never;
+    })
+  | undefined {
+  if (typeof value !== 'object' || value === null) return undefined;
+  // Optional never fields can still be explicitly undefined unless consumers
+  // enable exactOptionalPropertyTypes. Snapshot data without invoking getters.
+  const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(
+    ([, descriptor]) => descriptor.enumerable && (!('value' in descriptor) || descriptor.value !== undefined),
+  );
+  const keys = entries.map(([key]) => key);
+  const requestOnly = keys.some(
+    (key) => normalizeRequestOptionsForQueryKeys.has(key) && !queryKeys.includes(key),
+  );
+  if (!requestOnly) return undefined;
+  // Declared query fields, including stream, must use the query argument.
+  // Mixing them with request-only options is ambiguous and could change the return type.
+  if (
+    options !== undefined ||
+    keys.some((key) => !normalizeRequestOptionsForQueryKeys.has(key) || queryKeys.includes(key))
+  ) {
+    throw new TypeError('Query parameters and request options must be passed as separate arguments.');
+  }
+  // The query position must not gain authority to change the request destination
+  // or transport. Those overrides require the explicit request options argument.
+  if (
+    keys.some(
+      (key) => !['headers', 'maxRetries', 'timeout', 'signal', 'idempotencyKey', 'query'].includes(key),
+    )
+  ) {
+    throw new TypeError('Pass transport overrides in the explicit request options argument.');
+  }
+  // Copy only the validated fields. Spreading value would reintroduce undefined
+  // transport overrides, and deleting them would mutate the caller's object.
+  return Object.fromEntries(
+    entries.map(([key, descriptor]) => {
+      if ('value' in descriptor) return [key, descriptor.value];
+      return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : undefined];
+    }),
+  ) as {
+    [K in 'headers' | 'maxRetries' | 'timeout' | 'signal' | 'idempotencyKey' | 'query']?: RequestOptions[K];
+  } & {
+    [
+      K in
+        | 'method'
+        | 'path'
+        | 'body'
+        | 'stream'
+        | 'httpAgent'
+        | 'fetchOptions'
+        | 'defaultBaseURL'
+        | '__metadata'
+        | '__binaryRequest'
+        | '__binaryResponse'
+        | '__streamClass'
+        | '__security'
+        | '__synthesizeEventData'
+    ]?: never;
+  };
+}
+
+/**
+ * Create and manage model responses.
+ */
 export class Responses extends APIResource {
   inputItems: InputItemsAPI.InputItems = new InputItemsAPI.InputItems(this._client);
   inputTokens: InputTokensAPI.InputTokens = new InputTokensAPI.InputTokens(this._client);
@@ -109,12 +226,15 @@ export class Responses extends APIResource {
     options?: RequestOptions,
   ): APIPromise<Response> | APIPromise<Stream<ResponseStreamEvent>> {
     return (
-      this._client.post('/responses', {
-        body,
-        ...options,
-        stream: body.stream ?? false,
-        __security: { bearerAuth: true },
-      }) as APIPromise<Response> | APIPromise<Stream<ResponseStreamEvent>>
+      this._client.post(
+        '/responses',
+        resolveResourceRequestOptions(options, (options) => ({
+          body,
+          ...options,
+          stream: body.stream ?? false,
+          __security: { bearerAuth: true },
+        })),
+      ) as APIPromise<Response> | APIPromise<Stream<ResponseStreamEvent>>
     )._thenUnwrap((rsp) => {
       if ('object' in rsp && rsp.object === 'response') {
         addOutputText(rsp as Response);
@@ -136,31 +256,174 @@ export class Responses extends APIResource {
    */
   retrieve(
     responseID: string,
-    query?: ResponseRetrieveParamsNonStreaming,
+    query?: ResponseRetrieveParamsNonStreaming &
+      (
+        | {
+            [
+              K in
+                | 'method'
+                | 'path'
+                | 'query'
+                | 'body'
+                | 'headers'
+                | 'maxRetries'
+                | 'timeout'
+                | 'httpAgent'
+                | 'fetchOptions'
+                | 'signal'
+                | 'idempotencyKey'
+                | 'defaultBaseURL'
+                | '__metadata'
+                | '__binaryRequest'
+                | '__binaryResponse'
+                | '__streamClass'
+                | '__security'
+                | '__synthesizeEventData'
+            ]?: never;
+          }
+        | null
+        | undefined
+      ),
     options?: RequestOptions,
   ): APIPromise<Response>;
   retrieve(
     responseID: string,
-    query: ResponseRetrieveParamsStreaming,
+    query: ResponseRetrieveParamsStreaming &
+      (
+        | {
+            [
+              K in
+                | 'method'
+                | 'path'
+                | 'query'
+                | 'body'
+                | 'headers'
+                | 'maxRetries'
+                | 'timeout'
+                | 'httpAgent'
+                | 'fetchOptions'
+                | 'signal'
+                | 'idempotencyKey'
+                | 'defaultBaseURL'
+                | '__metadata'
+                | '__binaryRequest'
+                | '__binaryResponse'
+                | '__streamClass'
+                | '__security'
+                | '__synthesizeEventData'
+            ]?: never;
+          }
+        | null
+        | undefined
+      ),
     options?: RequestOptions,
   ): APIPromise<Stream<ResponseStreamEvent>>;
   retrieve(
     responseID: string,
-    query?: ResponseRetrieveParamsBase | undefined,
+    query?:
+      | (ResponseRetrieveParamsBase &
+          (
+            | {
+                [
+                  K in
+                    | 'method'
+                    | 'path'
+                    | 'query'
+                    | 'body'
+                    | 'headers'
+                    | 'maxRetries'
+                    | 'timeout'
+                    | 'httpAgent'
+                    | 'fetchOptions'
+                    | 'signal'
+                    | 'idempotencyKey'
+                    | 'defaultBaseURL'
+                    | '__metadata'
+                    | '__binaryRequest'
+                    | '__binaryResponse'
+                    | '__streamClass'
+                    | '__security'
+                    | '__synthesizeEventData'
+                ]?: never;
+              }
+            | null
+            | undefined
+          ))
+      | undefined,
     options?: RequestOptions,
   ): APIPromise<Stream<ResponseStreamEvent> | Response>;
   retrieve(
     responseID: string,
-    query: ResponseRetrieveParams | undefined = {},
+    options?: {
+      [K in 'headers' | 'maxRetries' | 'timeout' | 'signal' | 'idempotencyKey' | 'query']?: RequestOptions[K];
+    } & {
+      [
+        K in
+          | 'method'
+          | 'path'
+          | 'body'
+          | 'stream'
+          | 'httpAgent'
+          | 'fetchOptions'
+          | 'defaultBaseURL'
+          | '__metadata'
+          | '__binaryRequest'
+          | '__binaryResponse'
+          | '__streamClass'
+          | '__security'
+          | '__synthesizeEventData'
+      ]?: never;
+    },
+  ): APIPromise<Response>;
+  retrieve(
+    responseID: string,
+    query:
+      | ResponseRetrieveParamsBase
+      | ({
+          [
+            K in 'headers' | 'maxRetries' | 'timeout' | 'signal' | 'idempotencyKey' | 'query'
+          ]?: RequestOptions[K];
+        } & {
+          [
+            K in
+              | 'method'
+              | 'path'
+              | 'body'
+              | 'stream'
+              | 'httpAgent'
+              | 'fetchOptions'
+              | 'defaultBaseURL'
+              | '__metadata'
+              | '__binaryRequest'
+              | '__binaryResponse'
+              | '__streamClass'
+              | '__security'
+              | '__synthesizeEventData'
+          ]?: never;
+        })
+      | undefined = {},
     options?: RequestOptions,
   ): APIPromise<Response> | APIPromise<Stream<ResponseStreamEvent>> {
+    const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery(
+      query,
+      ['include', 'include_obfuscation', 'starting_after', 'stream'],
+      options,
+    );
+    if (normalizeRequestOptionsForQueryOptions !== undefined) {
+      options = normalizeRequestOptionsForQueryOptions;
+      query = {};
+    }
+    query = query as ResponseRetrieveParams | undefined;
     return (
-      this._client.get(path`/responses/${responseID}`, {
-        query,
-        ...options,
-        stream: query?.stream ?? false,
-        __security: { bearerAuth: true },
-      }) as APIPromise<Response> | APIPromise<Stream<ResponseStreamEvent>>
+      this._client.get(
+        path`/responses/${responseID}`,
+        resolveResourceRequestOptions(options, (options) => ({
+          query,
+          ...options,
+          stream: query?.stream ?? false,
+          __security: { bearerAuth: true },
+        })),
+      ) as APIPromise<Response> | APIPromise<Stream<ResponseStreamEvent>>
     )._thenUnwrap((rsp) => {
       if ('object' in rsp && rsp.object === 'response') {
         addOutputText(rsp as Response);
@@ -181,11 +444,14 @@ export class Responses extends APIResource {
    * ```
    */
   delete(responseID: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.delete(path`/responses/${responseID}`, {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-      __security: { bearerAuth: true },
-    });
+    return this._client.delete(
+      path`/responses/${responseID}`,
+      resolveResourceRequestOptions(options, (options) => ({
+        ...options,
+        headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 
   parse<Params extends ResponseCreateParamsWithTools, ParsedT = ExtractParsedContentFromParams<Params>>(
@@ -220,10 +486,10 @@ export class Responses extends APIResource {
    * ```
    */
   cancel(responseID: string, options?: RequestOptions): APIPromise<Response> {
-    return this._client.post(path`/responses/${responseID}/cancel`, {
-      ...options,
-      __security: { bearerAuth: true },
-    });
+    return this._client.post(
+      path`/responses/${responseID}/cancel`,
+      resolveResourceRequestOptions(options, (options) => ({ ...options, __security: { bearerAuth: true } })),
+    );
   }
 
   /**
@@ -242,7 +508,14 @@ export class Responses extends APIResource {
    * ```
    */
   compact(body: ResponseCompactParams, options?: RequestOptions): APIPromise<CompactedResponse> {
-    return this._client.post('/responses/compact', { body, ...options, __security: { bearerAuth: true } });
+    return this._client.post(
+      '/responses/compact',
+      resolveResourceRequestOptions(options, (options) => ({
+        body,
+        ...options,
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 }
 
@@ -6785,7 +7058,7 @@ export namespace ResponseOutputText {
  */
 export interface ResponseOutputTextAnnotationAddedEvent {
   /**
-   * An annotation that applies to a span of output text.
+   * The annotation object being added. (See annotation schema for details.)
    */
   annotation:
     | ResponseOutputTextAnnotationAddedEvent.FileCitation
@@ -10305,10 +10578,9 @@ export namespace Tool {
     background?: 'transparent' | 'opaque' | 'auto';
 
     /**
-     * Control how much effort the model will exert to match the style and features,
-     * especially facial features, of input images. This parameter is only supported
-     * for `gpt-image-1` and `gpt-image-1.5` and later models, unsupported for
-     * `gpt-image-1-mini`. Supports `high` and `low`. Defaults to `low`.
+     * Controls fidelity to the original input image(s). This parameter is supported
+     * for GPT image models that support input fidelity. `gpt-image-2` and
+     * `gpt-image-2-2026-04-21` ignore this parameter.
      */
     input_fidelity?: 'high' | 'low' | null;
 

package/src/resources/safety/alerts.ts

@@ -5,12 +5,22 @@ import { APIPromise } from '../../core/api-promise';
 import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 export class Alerts extends APIResource {
   /**
    * Get a safety alert belonging to the authenticated API project.
    */
   retrieve(id: string, options?: RequestOptions): APIPromise<SafetyAlert> {
-    return this._client.get(path`/safety/alerts/${id}`, { ...options, __security: { bearerAuth: true } });
+    return this._client.get(
+      path`/safety/alerts/${id}`,
+      resolveResourceRequestOptions(options, (options) => ({ ...options, __security: { bearerAuth: true } })),
+    );
   }
 }
 

package/src/resources/safety/cases.ts

@@ -0,0 +1,49 @@
+// File generated from our OpenAPI spec by Castiron. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
+export class Cases extends APIResource {
+  /**
+   * Get a safety case by ID.
+   */
+  retrieve(id: string, options?: RequestOptions): APIPromise<SafetyCase> {
+    return this._client.get(
+      path`/safety/cases/${id}`,
+      resolveResourceRequestOptions(options, (options) => ({ ...options, __security: { bearerAuth: true } })),
+    );
+  }
+}
+
+export interface SafetyCase {
+  id: string;
+
+  created_at: number;
+
+  entity_identifier: string;
+
+  notice: SafetyCase.Notice;
+
+  object: 'safety.case';
+
+  reason: string | null;
+}
+
+export namespace SafetyCase {
+  export interface Notice {
+    type: 'warning' | 'deactivation';
+  }
+}
+
+export declare namespace Cases {
+  export { type SafetyCase as SafetyCase };
+}

package/src/resources/safety/index.ts

@@ -1,4 +1,5 @@
 // File generated from our OpenAPI spec by Castiron. See CONTRIBUTING.md for details.
 
 export { Alerts, type SafetyAlert } from './alerts';
+export { Cases, type SafetyCase } from './cases';
 export { Safety } from './safety';

package/src/resources/safety/safety.ts

@@ -3,13 +3,19 @@
 import { APIResource } from '../../core/resource';
 import * as AlertsAPI from './alerts';
 import { Alerts, SafetyAlert } from './alerts';
+import * as CasesAPI from './cases';
+import { Cases, SafetyCase } from './cases';
 
 export class Safety extends APIResource {
+  cases: CasesAPI.Cases = new CasesAPI.Cases(this._client);
   alerts: AlertsAPI.Alerts = new AlertsAPI.Alerts(this._client);
 }
 
+Safety.Cases = Cases;
 Safety.Alerts = Alerts;
 
 export declare namespace Safety {
+  export { Cases as Cases, type SafetyCase as SafetyCase };
+
   export { Alerts as Alerts, type SafetyAlert as SafetyAlert };
 }

package/src/resources/skills/content.ts

@@ -6,16 +6,26 @@ import { buildHeaders } from '../../internal/headers';
 import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 export class Content extends APIResource {
   /**
    * Download a skill zip bundle by its ID.
    */
   retrieve(skillID: string, options?: RequestOptions): APIPromise<Response> {
-    return this._client.get(path`/skills/${skillID}/content`, {
-      ...options,
-      headers: buildHeaders([{ Accept: 'application/binary' }, options?.headers]),
-      __security: { bearerAuth: true },
-      __binaryResponse: true,
-    });
+    return this._client.get(
+      path`/skills/${skillID}/content`,
+      resolveResourceRequestOptions(options, (options) => ({
+        ...options,
+        headers: buildHeaders([{ Accept: 'application/binary' }, options?.headers]),
+        __security: { bearerAuth: true },
+        __binaryResponse: true,
+      })),
+    );
   }
 }