@firebase/ai 2.1.0-canary.5501791d0 → 2.1.0-canary.984086b0b

package/dist/src/api.d.ts

@@ -18,14 +18,16 @@ import { FirebaseApp } from '@firebase/app';
 import { AI_TYPE } from './constants';
 import { AIService } from './service';
 import { AI, AIOptions } from './public-types';
-import { ImagenModelParams, HybridParams, ModelParams, RequestOptions } from './types';
+import { ImagenModelParams, HybridParams, ModelParams, RequestOptions, LiveModelParams } from './types';
 import { AIError } from './errors';
-import { AIModel, GenerativeModel, ImagenModel } from './models';
+import { AIModel, GenerativeModel, LiveGenerativeModel, ImagenModel } from './models';
 export { ChatSession } from './methods/chat-session';
+export { LiveSession } from './methods/live-session';
 export * from './requests/schema-builder';
 export { ImagenImageFormat } from './requests/imagen-image-format';
-export { AIModel, GenerativeModel, ImagenModel, AIError };
+export { AIModel, GenerativeModel, LiveGenerativeModel, ImagenModel, AIError };
 export { Backend, VertexAIBackend, GoogleAIBackend } from './backend';
+export { startAudioConversation, AudioConversationController, StartAudioConversationOptions } from './methods/live-session-helpers';
 declare module '@firebase/component' {
     interface NameServiceMapping {
         [AI_TYPE]: AIService;
@@ -82,3 +84,16 @@ export declare function getGenerativeModel(ai: AI, modelParams: ModelParams | Hy
  * @beta
  */
 export declare function getImagenModel(ai: AI, modelParams: ImagenModelParams, requestOptions?: RequestOptions): ImagenModel;
+/**
+ * Returns a {@link LiveGenerativeModel} class for real-time, bidirectional communication.
+ *
+ * The Live API is only supported in modern browser windows and Node >= 22.
+ *
+ * @param ai - An {@link AI} instance.
+ * @param modelParams - Parameters to use when setting up a {@link LiveSession}.
+ * @throws If the `apiKey` or `projectId` fields are missing in your
+ * Firebase config.
+ *
+ * @beta
+ */
+export declare function getLiveGenerativeModel(ai: AI, modelParams: LiveModelParams): LiveGenerativeModel;

package/dist/src/constants.d.ts

@@ -16,7 +16,7 @@
  */
 export declare const AI_TYPE = "AI";
 export declare const DEFAULT_LOCATION = "us-central1";
-export declare const DEFAULT_BASE_URL = "https://firebasevertexai.googleapis.com";
+export declare const DEFAULT_DOMAIN = "firebasevertexai.googleapis.com";
 export declare const DEFAULT_API_VERSION = "v1beta";
 export declare const PACKAGE_VERSION: string;
 export declare const LANGUAGE_TAG = "gl-js";

package/dist/src/index.d.ts

@@ -3,10 +3,14 @@
  *
  * @packageDocumentation
  */
+import { AIService } from './service';
+import { ComponentContainer, InstanceFactoryOptions } from '@firebase/component';
+import { LanguageModel } from './types/language-model';
 declare global {
     interface Window {
-        [key: string]: unknown;
+        LanguageModel: LanguageModel;
     }
 }
+export declare function factory(container: ComponentContainer, { instanceIdentifier }: InstanceFactoryOptions): AIService;
 export * from './api';
 export * from './public-types';

package/dist/src/methods/chrome-adapter.d.ts

@@ -23,9 +23,9 @@ import { LanguageModel } from '../types/language-model';
  * possible.
  */
 export declare class ChromeAdapterImpl implements ChromeAdapter {
-    private languageModelProvider;
-    private mode;
-    private onDeviceParams;
+    languageModelProvider: LanguageModel;
+    mode: InferenceMode;
+    onDeviceParams: OnDeviceParams;
     static SUPPORTED_MIME_TYPES: string[];
     private isDownloading;
     private downloadPromise;
@@ -118,3 +118,7 @@ export declare class ChromeAdapterImpl implements ChromeAdapter {
      */
     private static toStreamResponse;
 }
+/**
+ * Creates a ChromeAdapterImpl on demand.
+ */
+export declare function chromeAdapterFactory(mode: InferenceMode, window?: Window, params?: OnDeviceParams): ChromeAdapterImpl | undefined;

package/dist/src/methods/live-session-helpers.d.ts

@@ -0,0 +1,154 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { LiveServerToolCall, Part } from '../types';
+import { LiveSession } from './live-session';
+/**
+ * A controller for managing an active audio conversation.
+ *
+ * @beta
+ */
+export interface AudioConversationController {
+    /**
+     * Stops the audio conversation, closes the microphone connection, and
+     * cleans up resources. Returns a promise that resolves when cleanup is complete.
+     */
+    stop: () => Promise<void>;
+}
+/**
+ * Options for {@link startAudioConversation}.
+ *
+ * @beta
+ */
+export interface StartAudioConversationOptions {
+    /**
+     * An async handler that is called when the model requests a function to be executed.
+     * The handler should perform the function call and return the result as a `Part`,
+     * which will then be sent back to the model.
+     */
+    functionCallingHandler?: (functionCalls: LiveServerToolCall['functionCalls']) => Promise<Part>;
+}
+/**
+ * Dependencies needed by the {@link AudioConversationRunner}.
+ *
+ * @internal
+ */
+interface RunnerDependencies {
+    audioContext: AudioContext;
+    mediaStream: MediaStream;
+    sourceNode: MediaStreamAudioSourceNode;
+    workletNode: AudioWorkletNode;
+}
+/**
+ * Encapsulates the core logic of an audio conversation.
+ *
+ * @internal
+ */
+export declare class AudioConversationRunner {
+    private readonly liveSession;
+    private readonly options;
+    private readonly deps;
+    /** A flag to indicate if the conversation has been stopped. */
+    private isStopped;
+    /** A deferred that contains a promise that is resolved when stop() is called, to unblock the receive loop. */
+    private readonly stopDeferred;
+    /** A promise that tracks the lifecycle of the main `runReceiveLoop`. */
+    private readonly receiveLoopPromise;
+    /** A FIFO queue of 24kHz, 16-bit PCM audio chunks received from the server. */
+    private readonly playbackQueue;
+    /** Tracks scheduled audio sources. Used to cancel scheduled audio when the model is interrupted. */
+    private scheduledSources;
+    /** A high-precision timeline pointer for scheduling gapless audio playback. */
+    private nextStartTime;
+    /** A mutex to prevent the playback processing loop from running multiple times concurrently. */
+    private isPlaybackLoopRunning;
+    constructor(liveSession: LiveSession, options: StartAudioConversationOptions, deps: RunnerDependencies);
+    /**
+     * Stops the conversation and unblocks the main receive loop.
+     */
+    stop(): Promise<void>;
+    /**
+     * Cleans up all audio resources (nodes, stream tracks, context) and marks the
+     * session as no longer in a conversation.
+     */
+    private cleanup;
+    /**
+     * Adds audio data to the queue and ensures the playback loop is running.
+     */
+    private enqueueAndPlay;
+    /**
+     * Stops all current and pending audio playback and clears the queue. This is
+     * called when the server indicates the model's speech was interrupted with
+     * `LiveServerContent.modelTurn.interrupted`.
+     */
+    private interruptPlayback;
+    /**
+     * Processes the playback queue in a loop, scheduling each chunk in a gapless sequence.
+     */
+    private processPlaybackQueue;
+    /**
+     * The main loop that listens for and processes messages from the server.
+     */
+    private runReceiveLoop;
+}
+/**
+ * Starts a real-time, bidirectional audio conversation with the model. This helper function manages
+ * the complexities of microphone access, audio recording, playback, and interruptions.
+ *
+ * @remarks Important: This function must be called in response to a user gesture
+ * (for example, a button click) to comply with {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Best_practices#autoplay_policy | browser autoplay policies}.
+ *
+ * @example
+ * ```javascript
+ * const liveSession = await model.connect();
+ * let conversationController;
+ *
+ * // This function must be called from within a click handler.
+ * async function startConversation() {
+ *   try {
+ *     conversationController = await startAudioConversation(liveSession);
+ *   } catch (e) {
+ *     // Handle AI-specific errors
+ *     if (e instanceof AIError) {
+ *       console.error("AI Error:", e.message);
+ *     }
+ *     // Handle microphone permission and hardware errors
+ *     else if (e instanceof DOMException) {
+ *       console.error("Microphone Error:", e.message);
+ *     }
+ *     // Handle other unexpected errors
+ *     else {
+ *       console.error("An unexpected error occurred:", e);
+ *     }
+ *   }
+ * }
+ *
+ * // Later, to stop the conversation:
+ * // if (conversationController) {
+ * //   await conversationController.stop();
+ * // }
+ * ```
+ *
+ * @param liveSession - An active {@link LiveSession} instance.
+ * @param options - Configuration options for the audio conversation.
+ * @returns A `Promise` that resolves with an {@link AudioConversationController}.
+ * @throws `AIError` if the environment does not support required Web APIs (`UNSUPPORTED`), if a conversation is already active (`REQUEST_ERROR`), the session is closed (`SESSION_CLOSED`), or if an unexpected initialization error occurs (`ERROR`).
+ * @throws `DOMException` Thrown by `navigator.mediaDevices.getUserMedia()` if issues occur with microphone access, such as permissions being denied (`NotAllowedError`) or no compatible hardware being found (`NotFoundError`). See the {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia#exceptions | MDN documentation} for a full list of exceptions.
+ *
+ * @beta
+ */
+export declare function startAudioConversation(liveSession: LiveSession, options?: StartAudioConversationOptions): Promise<AudioConversationController>;
+export {};

package/dist/src/methods/live-session.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GenerativeContentBlob, LiveServerContent, LiveServerToolCall, LiveServerToolCallCancellation, Part } from '../public-types';
+import { WebSocketHandler } from '../websocket';
+/**
+ * Represents an active, real-time, bidirectional conversation with the model.
+ *
+ * This class should only be instantiated by calling {@link LiveGenerativeModel.connect}.
+ *
+ * @beta
+ */
+export declare class LiveSession {
+    private webSocketHandler;
+    private serverMessages;
+    /**
+     * Indicates whether this Live session is closed.
+     *
+     * @beta
+     */
+    isClosed: boolean;
+    /**
+     * Indicates whether this Live session is being controlled by an `AudioConversationController`.
+     *
+     * @beta
+     */
+    inConversation: boolean;
+    /**
+     * @internal
+     */
+    constructor(webSocketHandler: WebSocketHandler, serverMessages: AsyncGenerator<unknown>);
+    /**
+     * Sends content to the server.
+     *
+     * @param request - The message to send to the model.
+     * @param turnComplete - Indicates if the turn is complete. Defaults to false.
+     * @throws If this session has been closed.
+     *
+     * @beta
+     */
+    send(request: string | Array<string | Part>, turnComplete?: boolean): Promise<void>;
+    /**
+     * Sends realtime input to the server.
+     *
+     * @param mediaChunks - The media chunks to send.
+     * @throws If this session has been closed.
+     *
+     * @beta
+     */
+    sendMediaChunks(mediaChunks: GenerativeContentBlob[]): Promise<void>;
+    /**
+     * Sends a stream of {@link GenerativeContentBlob}.
+     *
+     * @param mediaChunkStream - The stream of {@link GenerativeContentBlob} to send.
+     * @throws If this session has been closed.
+     *
+     * @beta
+     */
+    sendMediaStream(mediaChunkStream: ReadableStream<GenerativeContentBlob>): Promise<void>;
+    /**
+     * Yields messages received from the server.
+     * This can only be used by one consumer at a time.
+     *
+     * @returns An `AsyncGenerator` that yields server messages as they arrive.
+     * @throws If the session is already closed, or if we receive a response that we don't support.
+     *
+     * @beta
+     */
+    receive(): AsyncGenerator<LiveServerContent | LiveServerToolCall | LiveServerToolCallCancellation>;
+    /**
+     * Closes this session.
+     * All methods on this session will throw an error once this resolves.
+     *
+     * @beta
+     */
+    close(): Promise<void>;
+}

package/dist/src/models/ai-model.d.ts

@@ -33,7 +33,7 @@ export declare abstract class AIModel {
     /**
      * @internal
      */
-    protected _apiSettings: ApiSettings;
+    _apiSettings: ApiSettings;
     /**
      * Constructs a new instance of the {@link AIModel} class.
      *

package/dist/src/models/index.d.ts

@@ -16,4 +16,5 @@
  */
 export * from './ai-model';
 export * from './generative-model';
+export * from './live-generative-model';
 export * from './imagen-model';

package/dist/src/models/live-generative-model.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AIModel } from './ai-model';
+import { LiveSession } from '../methods/live-session';
+import { AI, Content, LiveGenerationConfig, LiveModelParams, Tool, ToolConfig } from '../public-types';
+import { WebSocketHandler } from '../websocket';
+/**
+ * Class for Live generative model APIs. The Live API enables low-latency, two-way multimodal
+ * interactions with Gemini.
+ *
+ * This class should only be instantiated with {@link getLiveGenerativeModel}.
+ *
+ * @beta
+ */
+export declare class LiveGenerativeModel extends AIModel {
+    /**
+     * @internal
+     */
+    private _webSocketHandler;
+    generationConfig: LiveGenerationConfig;
+    tools?: Tool[];
+    toolConfig?: ToolConfig;
+    systemInstruction?: Content;
+    /**
+     * @internal
+     */
+    constructor(ai: AI, modelParams: LiveModelParams, 
+    /**
+     * @internal
+     */
+    _webSocketHandler: WebSocketHandler);
+    /**
+     * Starts a {@link LiveSession}.
+     *
+     * @returns A {@link LiveSession}.
+     * @throws If the connection failed to be established with the server.
+     *
+     * @beta
+     */
+    connect(): Promise<LiveSession>;
+}

package/dist/src/public-types.d.ts

@@ -35,6 +35,10 @@ export interface AI {
      * Vertex AI Gemini API (using {@link VertexAIBackend}).
      */
     backend: Backend;
+    /**
+     * Options applied to this {@link AI} instance.
+     */
+    options?: AIOptions;
     /**
      * @deprecated use `AI.backend.location` instead.
      *
@@ -83,6 +87,11 @@ export type BackendType = (typeof BackendType)[keyof typeof BackendType];
 export interface AIOptions {
     /**
      * The backend configuration to use for the AI service instance.
+     * Defaults to the Gemini Developer API backend ({@link GoogleAIBackend}).
      */
-    backend: Backend;
+    backend?: Backend;
+    /**
+     * Whether to use App Check limited use tokens. Defaults to false.
+     */
+    useLimitedUseAppCheckTokens?: boolean;
 }

package/dist/src/requests/request.d.ts

@@ -35,6 +35,12 @@ export declare class RequestUrl {
     private get modelPath();
     private get queryParams();
 }
+export declare class WebSocketUrl {
+    apiSettings: ApiSettings;
+    constructor(apiSettings: ApiSettings);
+    toString(): string;
+    private get pathname();
+}
 export declare function getHeaders(url: RequestUrl): Promise<Headers>;
 export declare function constructRequest(model: string, task: Task, apiSettings: ApiSettings, stream: boolean, body: string, requestOptions?: RequestOptions): Promise<{
     url: string;

package/dist/src/requests/response-helpers.d.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { EnhancedGenerateContentResponse, FunctionCall, GenerateContentResponse, ImagenGCSImage, ImagenInlineImage, InlineDataPart } from '../types';
+import { EnhancedGenerateContentResponse, FunctionCall, GenerateContentResponse, ImagenGCSImage, ImagenInlineImage, InlineDataPart, Part } from '../types';
 /**
  * Creates an EnhancedGenerateContentResponse object that has helper functions and
  * other modifications that improve usability.
@@ -26,15 +26,19 @@ export declare function createEnhancedContentResponse(response: GenerateContentR
  */
 export declare function addHelpers(response: GenerateContentResponse): EnhancedGenerateContentResponse;
 /**
- * Returns all text found in all parts of first candidate.
+ * Returns all text from the first candidate's parts, filtering by whether
+ * `partFilter()` returns true.
+ *
+ * @param response - The `GenerateContentResponse` from which to extract text.
+ * @param partFilter - Only return `Part`s for which this returns true
  */
-export declare function getText(response: GenerateContentResponse): string;
+export declare function getText(response: GenerateContentResponse, partFilter: (part: Part) => boolean): string;
 /**
- * Returns {@link FunctionCall}s associated with first candidate.
+ * Returns every {@link FunctionCall} associated with first candidate.
  */
 export declare function getFunctionCalls(response: GenerateContentResponse): FunctionCall[] | undefined;
 /**
- * Returns {@link InlineDataPart}s in the first candidate if present.
+ * Returns every {@link InlineDataPart} in the first candidate if present.
  *
  * @internal
  */

package/dist/src/service.d.ts

@@ -15,17 +15,22 @@
  * limitations under the License.
  */
 import { FirebaseApp, _FirebaseService } from '@firebase/app';
-import { AI } from './public-types';
+import { AI, AIOptions, InferenceMode, OnDeviceParams } from './public-types';
 import { AppCheckInternalComponentName, FirebaseAppCheckInternal } from '@firebase/app-check-interop-types';
 import { Provider } from '@firebase/component';
 import { FirebaseAuthInternal, FirebaseAuthInternalName } from '@firebase/auth-interop-types';
 import { Backend } from './backend';
+import { ChromeAdapterImpl } from './methods/chrome-adapter';
 export declare class AIService implements AI, _FirebaseService {
     app: FirebaseApp;
     backend: Backend;
+    chromeAdapterFactory?: ((mode: InferenceMode, window?: Window, params?: OnDeviceParams) => ChromeAdapterImpl | undefined) | undefined;
     auth: FirebaseAuthInternal | null;
     appCheck: FirebaseAppCheckInternal | null;
+    _options?: Omit<AIOptions, 'backend'>;
     location: string;
-    constructor(app: FirebaseApp, backend: Backend, authProvider?: Provider<FirebaseAuthInternalName>, appCheckProvider?: Provider<AppCheckInternalComponentName>);
+    constructor(app: FirebaseApp, backend: Backend, authProvider?: Provider<FirebaseAuthInternalName>, appCheckProvider?: Provider<AppCheckInternalComponentName>, chromeAdapterFactory?: ((mode: InferenceMode, window?: Window, params?: OnDeviceParams) => ChromeAdapterImpl | undefined) | undefined);
     _delete(): Promise<void>;
+    set options(optionsToSet: AIOptions);
+    get options(): AIOptions | undefined;
 }

package/dist/src/types/content.d.ts

@@ -38,6 +38,11 @@ export interface TextPart {
     inlineData?: never;
     functionCall?: never;
     functionResponse?: never;
+    thought?: boolean;
+    /**
+     * @internal
+     */
+    thoughtSignature?: string;
 }
 /**
  * Content part interface if the part represents an image.
@@ -52,6 +57,11 @@ export interface InlineDataPart {
      * Applicable if `inlineData` is a video.
      */
     videoMetadata?: VideoMetadata;
+    thought?: boolean;
+    /**
+     * @internal
+     */
+    thoughtSignature?: never;
 }
 /**
  * Describes the input video content.
@@ -78,6 +88,11 @@ export interface FunctionCallPart {
     inlineData?: never;
     functionCall: FunctionCall;
     functionResponse?: never;
+    thought?: boolean;
+    /**
+     * @internal
+     */
+    thoughtSignature?: never;
 }
 /**
  * Content part interface if the part represents {@link FunctionResponse}.
@@ -88,6 +103,11 @@ export interface FunctionResponsePart {
     inlineData?: never;
     functionCall?: never;
     functionResponse: FunctionResponse;
+    thought?: boolean;
+    /**
+     * @internal
+     */
+    thoughtSignature?: never;
 }
 /**
  * Content part interface if the part represents {@link FileData}
@@ -99,6 +119,11 @@ export interface FileDataPart {
     functionCall?: never;
     functionResponse?: never;
     fileData: FileData;
+    thought?: boolean;
+    /**
+     * @internal
+     */
+    thoughtSignature?: never;
 }
 /**
  * A predicted {@link FunctionCall} returned from the model
@@ -107,6 +132,15 @@ export interface FileDataPart {
  * @public
  */
 export interface FunctionCall {
+    /**
+     * The id of the function call. This must be sent back in the associated {@link FunctionResponse}.
+     *
+     *
+     * @remarks This property is only supported in the Gemini Developer API ({@link GoogleAIBackend}).
+     * When using the Gemini Developer API ({@link GoogleAIBackend}), this property will be
+     * `undefined`.
+     */
+    id?: string;
     name: string;
     args: object;
 }
@@ -120,6 +154,14 @@ export interface FunctionCall {
  * @public
  */
 export interface FunctionResponse {
+    /**
+     * The id of the {@link FunctionCall}.
+     *
+     * @remarks This property is only supported in the Gemini Developer API ({@link GoogleAIBackend}).
+     * When using the Gemini Developer API ({@link GoogleAIBackend}), this property will be
+     * `undefined`.
+     */
+    id?: string;
     name: string;
     response: object;
 }

package/dist/src/types/enums.d.ts

@@ -304,6 +304,11 @@ export declare const ResponseModality: {
      * @beta
      */
     readonly IMAGE: "IMAGE";
+    /**
+     * Audio.
+     * @beta
+     */
+    readonly AUDIO: "AUDIO";
 };
 /**
  * Generation modalities to be returned in generation responses.

package/dist/src/types/error.d.ts

@@ -60,6 +60,8 @@ export declare const AIErrorCode: {
     readonly RESPONSE_ERROR: "response-error";
     /** An error occurred while performing a fetch. */
     readonly FETCH_ERROR: "fetch-error";
+    /** An error occurred because an operation was attempted on a closed session. */
+    readonly SESSION_CLOSED: "session-closed";
     /** An error associated with a Content object.  */
     readonly INVALID_CONTENT: "invalid-content";
     /** An error due to the Firebase API not being enabled in the Console. */

package/dist/src/types/imagen/internal.d.ts

@@ -59,6 +59,14 @@ export interface ImagenResponseInternal {
          * The reason why the image was filtered.
          */
         raiFilteredReason?: string;
+        /**
+         * The safety attributes.
+         *
+         * This type is currently unused in the SDK. It is sent back because our requests set
+         * `includeSafetyAttributes`. This property is currently only used to avoid throwing an error
+         * when encountering this unsupported prediction type.
+         */
+        safetyAttributes?: unknown;
     }>;
 }
 /**
@@ -81,6 +89,7 @@ export interface ImagenResponseInternal {
  *     "personGeneration": "allow_all",
  *     "sampleCount": 2,
  *     "includeRaiReason": true,
+ *     "includeSafetyAttributes": true,
  *     "aspectRatio": "9:16"
  *   }
  * }
@@ -108,6 +117,7 @@ export interface PredictRequestBody {
         safetyFilterLevel?: string;
         personGeneration?: string;
         includeRaiReason: boolean;
+        includeSafetyAttributes: boolean;
     };
 }
 /**