@google/genai 0.7.0 → 0.9.0

package/dist/web/web.d.ts

@@ -1,5 +1,28 @@
 import { GoogleAuthOptions } from 'google-auth-library';
 
+/** Marks the end of user activity.
+
+ This can only be sent if automatic (i.e. server-side) activity detection is
+ disabled.
+ */
+export declare interface ActivityEnd {
+}
+
+/** The different ways of handling user activity. */
+export declare enum ActivityHandling {
+    ACTIVITY_HANDLING_UNSPECIFIED = "ACTIVITY_HANDLING_UNSPECIFIED",
+    START_OF_ACTIVITY_INTERRUPTS = "START_OF_ACTIVITY_INTERRUPTS",
+    NO_INTERRUPTION = "NO_INTERRUPTION"
+}
+
+/** Marks the start of user activity.
+
+ This can only be sent if automatic (i.e. server-side) activity detection is
+ disabled.
+ */
+export declare interface ActivityStart {
+}
+
 /**
  * The ApiClient class is used to send requests to the Gemini API or Vertex AI
  * endpoints.
@@ -20,13 +43,14 @@ declare class ApiClient {
     getWebsocketBaseUrl(): string;
     setBaseUrl(url: string): void;
     private constructUrl;
+    private shouldPrependVertexProjectPath;
     request(request: HttpRequest): Promise<HttpResponse>;
     private patchHttpOptions;
-    requestStream(request: HttpRequest): Promise<any>;
+    requestStream(request: HttpRequest): Promise<AsyncGenerator<HttpResponse>>;
     private includeExtraHttpOptionsToRequestInit;
     private unaryApiCall;
     private streamApiCall;
-    processStreamResponse(response: Response): AsyncGenerator<any>;
+    processStreamResponse(response: Response): AsyncGenerator<HttpResponse>;
     private apiCall;
     getDefaultHeaders(): Record<string, string>;
     private getHeadersInternal;
@@ -97,6 +121,10 @@ declare interface ApiClientInitOptions {
     userAgentExtra?: string;
 }
 
+/** The audio transcription configuration in Setup. */
+export declare interface AudioTranscriptionConfig {
+}
+
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -114,6 +142,25 @@ declare interface Auth {
     addAuthHeaders(headers: Headers): Promise<void>;
 }
 
+/** Configures automatic detection of activity. */
+export declare interface AutomaticActivityDetection {
+    /** If enabled, detected voice and text input count as activity. If disabled, the client must send activity signals. */
+    disabled?: boolean;
+    /** Determines how likely speech is to be detected. */
+    startOfSpeechSensitivity?: StartSensitivity;
+    /** Determines how likely detected speech is ended. */
+    endOfSpeechSensitivity?: EndSensitivity;
+    /** The required duration of detected speech before start-of-speech is committed. The lower this value the more sensitive the start-of-speech detection is and the shorter speech can be recognized. However, this also increases the probability of false positives. */
+    prefixPaddingMs?: number;
+    /** The required duration of detected non-speech (e.g. silence) before end-of-speech is committed. The larger this value, the longer speech gaps can be without interrupting the user's activity but this will increase the model's latency. */
+    silenceDurationMs?: number;
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
 declare class BaseModule {
 }
 
@@ -126,6 +173,7 @@ declare interface Blob_2 {
 }
 export { Blob_2 as Blob }
 
+/** Output only. Blocked reason. */
 export declare enum BlockedReason {
     BLOCKED_REASON_UNSPECIFIED = "BLOCKED_REASON_UNSPECIFIED",
     SAFETY = "SAFETY",
@@ -189,8 +237,8 @@ export declare class Caches extends BaseModule {
      *
      * @remarks
      * Context caching is only supported for specific models. See [Gemini
-     * Developer API reference] (https://ai.google.dev/gemini-api/docs/caching?lang=node/context-cac)
-     * and [Vertex AI reference] (https://cloud.google.com/vertex-ai/generative-ai/docs/context-cache/context-cache-overview#supported_models)
+     * Developer API reference](https://ai.google.dev/gemini-api/docs/caching?lang=node/context-cac)
+     * and [Vertex AI reference](https://cloud.google.com/vertex-ai/generative-ai/docs/context-cache/context-cache-overview#supported_models)
      * for more information.
      *
      * @param params - The parameters for the create request.
@@ -435,16 +483,6 @@ export declare interface CodeExecutionResult {
     output?: string;
 }
 
-declare namespace common {
-    export {
-        formatMap,
-        setValueByPath,
-        getValueByPath,
-        BaseModule,
-        UploadFileParameters
-    }
-}
-
 /** Optional parameters for computing tokens. */
 export declare interface ComputeTokensConfig {
     /** Used to override HTTP request options. */
@@ -476,7 +514,7 @@ export declare interface Content {
     parts?: Part[];
     /** Optional. The producer of the content. Must be either 'user' or
      'model'. Useful to set for multi-turn conversations, otherwise can be
-     left blank or unset. If role is not specified, SDK will determine the role. */
+     empty. If role is not specified, SDK will determine the role. */
     role?: string;
 }
 
@@ -502,10 +540,18 @@ export declare interface ContentEmbeddingStatistics {
     tokenCount?: number;
 }
 
-export declare type ContentListUnion = ContentUnion[] | ContentUnion;
+export declare type ContentListUnion = Content | Content[] | PartUnion | PartUnion[];
 
 export declare type ContentUnion = Content | PartUnion[] | PartUnion;
 
+/** Enables context window compression -- mechanism managing model context window so it does not exceed given length. */
+export declare interface ContextWindowCompressionConfig {
+    /** Number of tokens (before running turn) that triggers context window compression mechanism. */
+    triggerTokens?: string;
+    /** Sliding window compression mechanism. */
+    slidingWindow?: SlidingWindow;
+}
+
 /** Configuration for a Control reference image. */
 export declare interface ControlReferenceConfig {
     /** The type of control reference image to use. */
@@ -537,6 +583,7 @@ export declare interface ControlReferenceImage {
     config?: ControlReferenceConfig;
 }
 
+/** Enum representing the control type of a control reference image. */
 export declare enum ControlReferenceType {
     CONTROL_TYPE_DEFAULT = "CONTROL_TYPE_DEFAULT",
     CONTROL_TYPE_CANNY = "CONTROL_TYPE_CANNY",
@@ -672,7 +719,7 @@ export declare class CreateFileResponse {
 export declare function createModelContent(partOrString: PartListUnion | string): Content;
 
 /**
- * Creates a `Part` object from a `base64` `string`.
+ * Creates a `Part` object from a `base64` encoded `string`.
  */
 export declare function createPartFromBase64(data: string, mimeType: string): Part;
 
@@ -763,6 +810,7 @@ export declare interface DynamicRetrievalConfig {
     dynamicThreshold?: number;
 }
 
+/** Config for the dynamic retrieval config mode. */
 export declare enum DynamicRetrievalConfigMode {
     MODE_UNSPECIFIED = "MODE_UNSPECIFIED",
     MODE_DYNAMIC = "MODE_DYNAMIC"
@@ -826,6 +874,21 @@ export declare class EmbedContentResponse {
     metadata?: EmbedContentMetadata;
 }
 
+/** An endpoint where you deploy models. */
+export declare interface Endpoint {
+    /** Resource name of the endpoint. */
+    name?: string;
+    /** ID of the model that's deployed to the endpoint. */
+    deployedModelId?: string;
+}
+
+/** End of speech sensitivity. */
+export declare enum EndSensitivity {
+    END_SENSITIVITY_UNSPECIFIED = "END_SENSITIVITY_UNSPECIFIED",
+    END_SENSITIVITY_HIGH = "END_SENSITIVITY_HIGH",
+    END_SENSITIVITY_LOW = "END_SENSITIVITY_LOW"
+}
+
 /** Code generated by the model that is meant to be executed, and the result returned to the model. Generated when using the [FunctionDeclaration] tool and [FunctionCallingConfig] mode is set to [Mode.CODE]. */
 export declare interface ExecutableCode {
     /** Required. The code to be executed. */
@@ -834,6 +897,14 @@ export declare interface ExecutableCode {
     language?: Language;
 }
 
+/** Options for feature selection preference. */
+export declare enum FeatureSelectionPreference {
+    FEATURE_SELECTION_PREFERENCE_UNSPECIFIED = "FEATURE_SELECTION_PREFERENCE_UNSPECIFIED",
+    PRIORITIZE_QUALITY = "PRIORITIZE_QUALITY",
+    BALANCED = "BALANCED",
+    PRIORITIZE_COST = "PRIORITIZE_COST"
+}
+
 export declare interface FetchPredictOperationConfig {
     /** Used to override HTTP request options. */
     httpOptions?: HttpOptions;
@@ -934,7 +1005,9 @@ export declare class Files extends BaseModule {
      * This section can contain multiple paragraphs and code examples.
      *
      * @param params - Optional parameters specified in the
-     *        `common.UploadFileParameters` interface.
+     *        `types.UploadFileParameters` interface.
+     *         @see {@link types.UploadFileParameters#config} for the optional
+     *         config in the parameters.
      * @return A promise that resolves to a `types.File` object.
      * @throws An error if called on a Vertex AI client.
      * @throws An error if the `mimeType` is not provided and can not be inferred,
@@ -951,7 +1024,7 @@ export declare class Files extends BaseModule {
      * console.log(file.name);
      * ```
      */
-    upload(params: common.UploadFileParameters): Promise<types.File>;
+    upload(params: types.UploadFileParameters): Promise<types.File>;
     private listInternal;
     private createInternal;
     /**
@@ -986,6 +1059,7 @@ export declare class Files extends BaseModule {
     delete(params: types.DeleteFileParameters): Promise<types.DeleteFileResponse>;
 }
 
+/** Source of the File. */
 export declare enum FileSource {
     SOURCE_UNSPECIFIED = "SOURCE_UNSPECIFIED",
     UPLOADED = "UPLOADED",
@@ -1009,6 +1083,7 @@ declare interface FileStat {
     type: string | undefined;
 }
 
+/** State for the lifecycle of a File. */
 export declare enum FileState {
     STATE_UNSPECIFIED = "STATE_UNSPECIFIED",
     PROCESSING = "PROCESSING",
@@ -1026,6 +1101,10 @@ export declare interface FileStatus {
     code?: number;
 }
 
+/** Output only. The reason why the model stopped generating tokens.
+
+ If empty, the model has not stopped generating the tokens.
+ */
 export declare enum FinishReason {
     FINISH_REASON_UNSPECIFIED = "FINISH_REASON_UNSPECIFIED",
     STOP = "STOP",
@@ -1040,8 +1119,6 @@ export declare enum FinishReason {
     IMAGE_SAFETY = "IMAGE_SAFETY"
 }
 
-declare function formatMap(templateString: string, valueMap: Record<string, unknown>): string;
-
 /** A function call. */
 export declare interface FunctionCall {
     /** The unique id of the function call. If populated, the client to execute the
@@ -1061,6 +1138,7 @@ export declare interface FunctionCallingConfig {
     allowedFunctionNames?: string[];
 }
 
+/** Config for the function calling config mode. */
 export declare enum FunctionCallingConfigMode {
     MODE_UNSPECIFIED = "MODE_UNSPECIFIED",
     AUTO = "AUTO",
@@ -1169,6 +1247,9 @@ export declare interface GenerateContentConfig {
     /** Configuration for model router requests.
      */
     routingConfig?: GenerationConfigRoutingConfig;
+    /** Configuration for model selection.
+     */
+    modelSelectionConfig?: ModelSelectionConfig;
     /** Safety settings in the request to block unsafe content in the
      response.
      */
@@ -1385,6 +1466,8 @@ export declare class GenerateContentResponseUsageMetadata {
     toolUsePromptTokensDetails?: ModalityTokenCount[];
     /** Total token count for prompt, response candidates, and tool-use prompts (if present). */
     totalTokenCount?: number;
+    /** Output only. Traffic type. This shows whether a request consumes Pay-As-You-Go or Provisioned Throughput quota. */
+    trafficType?: TrafficType;
 }
 
 /** An output image. */
@@ -1531,10 +1614,8 @@ export declare interface GenerateVideosOperation {
     done?: boolean;
     /** The error result of the operation in case of failure or cancellation. */
     error?: Record<string, unknown>;
-    /** The normal response of the operation in case of success. */
-    response?: Record<string, unknown>;
     /** The generated videos. */
-    result?: GenerateVideosResponse;
+    response?: GenerateVideosResponse;
 }
 
 /** Class that represents the parameters for generating an image. */
@@ -1573,6 +1654,8 @@ export declare interface GenerationConfig {
     logprobs?: number;
     /** Optional. The maximum number of output tokens to generate per message. */
     maxOutputTokens?: number;
+    /** Optional. If specified, the media resolution specified will be used. */
+    mediaResolution?: MediaResolution;
     /** Optional. Positive penalties. */
     presencePenalty?: number;
     /** Optional. If true, export the logprobs results in response. */
@@ -1645,6 +1728,18 @@ export declare interface GetFileParameters {
     config?: GetFileConfig;
 }
 
+/** Optional parameters for models.get method. */
+export declare interface GetModelConfig {
+    /** Used to override HTTP request options. */
+    httpOptions?: HttpOptions;
+}
+
+export declare interface GetModelParameters {
+    model: string;
+    /** Optional parameters for the request. */
+    config?: GetModelConfig;
+}
+
 export declare interface GetOperationConfig {
     /** Used to override HTTP request options. */
     httpOptions?: HttpOptions;
@@ -1658,8 +1753,6 @@ export declare interface GetOperationParameters {
     config?: GetOperationConfig;
 }
 
-declare function getValueByPath(data: unknown, keys: string[]): unknown;
-
 /**
  * The Google GenAI SDK.
  *
@@ -1811,6 +1904,8 @@ export declare interface GroundingChunkRetrievedContext {
 
 /** Chunk from the web. */
 export declare interface GroundingChunkWeb {
+    /** Domain of the (original) URI. */
+    domain?: string;
     /** Title of the chunk. */
     title?: string;
     /** URI reference of the chunk. */
@@ -1843,12 +1938,14 @@ export declare interface GroundingSupport {
     segment?: Segment;
 }
 
+/** Optional. Specify if the threshold is used for probability or severity score. If not specified, the threshold is used for probability score. */
 export declare enum HarmBlockMethod {
     HARM_BLOCK_METHOD_UNSPECIFIED = "HARM_BLOCK_METHOD_UNSPECIFIED",
     SEVERITY = "SEVERITY",
     PROBABILITY = "PROBABILITY"
 }
 
+/** Required. The harm block threshold. */
 export declare enum HarmBlockThreshold {
     HARM_BLOCK_THRESHOLD_UNSPECIFIED = "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
     BLOCK_LOW_AND_ABOVE = "BLOCK_LOW_AND_ABOVE",
@@ -1858,6 +1955,7 @@ export declare enum HarmBlockThreshold {
     OFF = "OFF"
 }
 
+/** Required. Harm category. */
 export declare enum HarmCategory {
     HARM_CATEGORY_UNSPECIFIED = "HARM_CATEGORY_UNSPECIFIED",
     HARM_CATEGORY_HATE_SPEECH = "HARM_CATEGORY_HATE_SPEECH",
@@ -1867,6 +1965,7 @@ export declare enum HarmCategory {
     HARM_CATEGORY_CIVIC_INTEGRITY = "HARM_CATEGORY_CIVIC_INTEGRITY"
 }
 
+/** Output only. Harm probability levels in the content. */
 export declare enum HarmProbability {
     HARM_PROBABILITY_UNSPECIFIED = "HARM_PROBABILITY_UNSPECIFIED",
     NEGLIGIBLE = "NEGLIGIBLE",
@@ -1875,6 +1974,7 @@ export declare enum HarmProbability {
     HIGH = "HIGH"
 }
 
+/** Output only. Harm severity levels in the content. */
 export declare enum HarmSeverity {
     HARM_SEVERITY_UNSPECIFIED = "HARM_SEVERITY_UNSPECIFIED",
     HARM_SEVERITY_NEGLIGIBLE = "HARM_SEVERITY_NEGLIGIBLE",
@@ -1967,6 +2067,7 @@ declare interface Image_2 {
 }
 export { Image_2 as Image }
 
+/** Enum that specifies the language of the text in the prompt. */
 export declare enum ImagePromptLanguage {
     auto = "auto",
     en = "en",
@@ -1975,6 +2076,7 @@ export declare enum ImagePromptLanguage {
     hi = "hi"
 }
 
+/** Required. Programming language of the `code`. */
 export declare enum Language {
     LANGUAGE_UNSPECIFIED = "LANGUAGE_UNSPECIFIED",
     PYTHON = "PYTHON"
@@ -2042,17 +2144,20 @@ export declare class Live {
      @experimental
 
      @remarks
-     If using the Gemini API, Live is currently only supported behind API
-     version `v1alpha`. Ensure that the API version is set to `v1alpha` when
-     initializing the SDK if relying on the Gemini API.
 
      @param params - The parameters for establishing a connection to the model.
      @return A live session.
 
      @example
      ```ts
+     let model: string;
+     if (GOOGLE_GENAI_USE_VERTEXAI) {
+     model = 'gemini-2.0-flash-live-preview-04-09';
+     } else {
+     model = 'gemini-2.0-flash-live-001';
+     }
      const session = await ai.live.connect({
-     model: 'gemini-2.0-flash-exp',
+     model: model,
      config: {
      responseModalities: [Modality.AUDIO],
      },
@@ -2078,9 +2183,21 @@ export declare class Live {
 
 /** Callbacks for the live API. */
 export declare interface LiveCallbacks {
+    /**
+     * Called when the websocket connection is established.
+     */
     onopen?: (() => void) | null;
+    /**
+     * Called when a message is received from the server.
+     */
     onmessage: (e: LiveServerMessage) => void;
+    /**
+     * Called when an error occurs.
+     */
     onerror?: ((e: ErrorEvent) => void) | null;
+    /**
+     * Called when the websocket connection is closed.
+     */
     onclose?: ((e: CloseEvent) => void) | null;
 }
 
@@ -2119,11 +2236,11 @@ export declare interface LiveClientMessage {
 
 /** User input that is sent in real time.
 
- This is different from `ClientContentUpdate` in a few ways:
+ This is different from `LiveClientContent` in a few ways:
 
  - Can be sent continuously without interruption to model generation.
  - If there is a need to mix data interleaved across the
- `ClientContentUpdate` and the `RealtimeUpdate`, server attempts to
+ `LiveClientContent` and the `LiveClientRealtimeInput`, server attempts to
  optimize for best response, but there are no guarantees.
  - End of turn is not explicitly specified, but is rather derived from user
  activity (for example, end of speech).
@@ -2135,6 +2252,10 @@ export declare interface LiveClientMessage {
 export declare interface LiveClientRealtimeInput {
     /** Inlined bytes data for media input. */
     mediaChunks?: Blob_2[];
+    /** Marks the start of user activity. */
+    activityStart?: ActivityStart;
+    /** Marks the end of user activity. */
+    activityEnd?: ActivityEnd;
 }
 
 /** Message contains configuration that will apply for the duration of the streaming session. */
@@ -2145,27 +2266,36 @@ export declare interface LiveClientSetup {
      */
     model?: string;
     /** The generation configuration for the session.
-
-     The following fields are supported:
-     - `response_logprobs`
-     - `response_mime_type`
-     - `logprobs`
-     - `response_schema`
-     - `stop_sequence`
-     - `routing_config`
-     - `audio_timestamp`
+     Note: only a subset of fields are supported.
      */
     generationConfig?: GenerationConfig;
     /** The user provided system instructions for the model.
      Note: only text should be used in parts and content in each part will be
      in a separate paragraph. */
-    systemInstruction?: Content;
+    systemInstruction?: ContentUnion;
     /**  A list of `Tools` the model may use to generate the next response.
 
      A `Tool` is a piece of code that enables the system to interact with
      external systems to perform an action, or set of actions, outside of
      knowledge and scope of the model. */
     tools?: ToolListUnion;
+    /** Configures the realtime input behavior in BidiGenerateContent. */
+    realtimeInputConfig?: RealtimeInputConfig;
+    /** Configures session resumption mechanism.
+
+     If included server will send SessionResumptionUpdate messages. */
+    sessionResumption?: SessionResumptionConfig;
+    /** Configures context window compression mechanism.
+
+     If included, server will compress context window to fit into given length. */
+    contextWindowCompression?: ContextWindowCompressionConfig;
+    /** The transcription of the input aligns with the input audio language.
+     */
+    inputAudioTranscription?: AudioTranscriptionConfig;
+    /** The transcription of the output aligns with the language code
+     specified for the output audio.
+     */
+    outputAudioTranscription?: AudioTranscriptionConfig;
 }
 
 /** Client generated response to a `ToolCall` received from the server.
@@ -2191,19 +2321,65 @@ export declare interface LiveConnectConfig {
      modalities that the model can return. Defaults to AUDIO if not specified.
      */
     responseModalities?: Modality[];
+    /** Value that controls the degree of randomness in token selection.
+     Lower temperatures are good for prompts that require a less open-ended or
+     creative response, while higher temperatures can lead to more diverse or
+     creative results.
+     */
+    temperature?: number;
+    /** Tokens are selected from the most to least probable until the sum
+     of their probabilities equals this value. Use a lower value for less
+     random responses and a higher value for more random responses.
+     */
+    topP?: number;
+    /** For each token selection step, the ``top_k`` tokens with the
+     highest probabilities are sampled. Then tokens are further filtered based
+     on ``top_p`` with the final token selected using temperature sampling. Use
+     a lower number for less random responses and a higher number for more
+     random responses.
+     */
+    topK?: number;
+    /** Maximum number of tokens that can be generated in the response.
+     */
+    maxOutputTokens?: number;
+    /** If specified, the media resolution specified will be used.
+     */
+    mediaResolution?: MediaResolution;
+    /** When ``seed`` is fixed to a specific number, the model makes a best
+     effort to provide the same response for repeated requests. By default, a
+     random number is used.
+     */
+    seed?: number;
     /** The speech generation configuration.
      */
     speechConfig?: SpeechConfig;
     /** The user provided system instructions for the model.
      Note: only text should be used in parts and content in each part will be
      in a separate paragraph. */
-    systemInstruction?: Content;
+    systemInstruction?: ContentUnion;
     /** A list of `Tools` the model may use to generate the next response.
 
      A `Tool` is a piece of code that enables the system to interact with
      external systems to perform an action, or set of actions, outside of
      knowledge and scope of the model. */
     tools?: ToolListUnion;
+    /** Configures session resumption mechanism.
+
+     If included the server will send SessionResumptionUpdate messages. */
+    sessionResumption?: SessionResumptionConfig;
+    /** The transcription of the input aligns with the input audio language.
+     */
+    inputAudioTranscription?: AudioTranscriptionConfig;
+    /** The transcription of the output aligns with the language code
+     specified for the output audio.
+     */
+    outputAudioTranscription?: AudioTranscriptionConfig;
+    /** Configures the realtime input behavior in BidiGenerateContent. */
+    realtimeInputConfig?: RealtimeInputConfig;
+    /** Configures context window compression mechanism.
+
+     If included, server will compress context window to fit into given length. */
+    contextWindowCompression?: ContextWindowCompressionConfig;
 }
 
 /** Parameters for connecting to the live API. */
@@ -2232,6 +2408,10 @@ export declare interface LiveSendClientContentParameters {
 export declare interface LiveSendRealtimeInputParameters {
     /** Realtime input to send to the session. */
     media: Blob_2;
+    /** Marks the start of user activity. */
+    activityStart?: ActivityStart;
+    /** Marks the end of user activity. */
+    activityEnd?: ActivityEnd;
 }
 
 /** Parameters for sending tool responses to the live API. */
@@ -2252,6 +2432,30 @@ export declare interface LiveServerContent {
     turnComplete?: boolean;
     /** If true, indicates that a client message has interrupted current model generation. If the client is playing out the content in realtime, this is a good signal to stop and empty the current queue. */
     interrupted?: boolean;
+    /** If true, indicates that the model is done generating. When model is
+     interrupted while generating there will be no generation_complete message
+     in interrupted turn, it will go through interrupted > turn_complete.
+     When model assumes realtime playback there will be delay between
+     generation_complete and turn_complete that is caused by model
+     waiting for playback to finish. If true, indicates that the model
+     has finished generating all content. This is a signal to the client
+     that it can stop sending messages. */
+    generationComplete?: boolean;
+    /** Input transcription. The transcription is independent to the model
+     turn which means it doesn’t imply any ordering between transcription and
+     model turn. */
+    inputTranscription?: Transcription;
+    /** Output transcription. The transcription is independent to the model
+     turn which means it doesn’t imply any ordering between transcription and
+     model turn.
+     */
+    outputTranscription?: Transcription;
+}
+
+/** Server will not be able to service client soon. */
+export declare interface LiveServerGoAway {
+    /** The remaining time before the connection will be terminated as ABORTED. The minimal time returned here is specified differently together with the rate limits for a given model. */
+    timeLeft?: string;
 }
 
 /** Response message for API call. */
@@ -2264,6 +2468,29 @@ export declare interface LiveServerMessage {
     toolCall?: LiveServerToolCall;
     /** Notification for the client that a previously issued `ToolCallMessage` with the specified `id`s should have been not executed and should be cancelled. */
     toolCallCancellation?: LiveServerToolCallCancellation;
+    /** Usage metadata about model response(s). */
+    usageMetadata?: UsageMetadata;
+    /** Server will disconnect soon. */
+    goAway?: LiveServerGoAway;
+    /** Update of the session resumption state. */
+    sessionResumptionUpdate?: LiveServerSessionResumptionUpdate;
+}
+
+/** Update of the session resumption state.
+
+ Only sent if `session_resumption` was set in the connection config.
+ */
+export declare interface LiveServerSessionResumptionUpdate {
+    /** New handle that represents state that can be resumed. Empty if `resumable`=false. */
+    newHandle?: string;
+    /** True if session can be resumed at this point. It might be not possible to resume session at some points. In that case we send update empty new_handle and resumable=false. Example of such case could be model executing function calls or just generating. Resuming session (using previous session token) in such state will result in some data loss. */
+    resumable?: boolean;
+    /** Index of last message sent by client that is included in state represented by this SessionResumptionToken. Only sent when `SessionResumptionConfig.transparent` is set.
+
+     Presence of this index allows users to transparently reconnect and avoid issue of losing some part of realtime audio input/video. If client wishes to temporarily disconnect (for example as result of receiving GoAway) they can do it without losing state by buffering messages sent since last `SessionResmumptionTokenUpdate`. This field will enable them to limit buffering (avoid keeping all requests in RAM).
+
+     Note: This should not be used for when resuming a session at some time later -- in those cases partial audio and video frames arelikely not needed. */
+    lastConsumedClientMessageIndex?: string;
 }
 
 /** Sent in response to a `LiveGenerateContentSetup` message from the client. */
@@ -2345,6 +2572,7 @@ export declare interface MaskReferenceImage {
     config?: MaskReferenceConfig;
 }
 
+/** Enum representing the mask mode of a mask reference image. */
 export declare enum MaskReferenceMode {
     MASK_MODE_DEFAULT = "MASK_MODE_DEFAULT",
     MASK_MODE_USER_PROVIDED = "MASK_MODE_USER_PROVIDED",
@@ -2353,6 +2581,7 @@ export declare enum MaskReferenceMode {
     MASK_MODE_SEMANTIC = "MASK_MODE_SEMANTIC"
 }
 
+/** Server content modalities. */
 export declare enum MediaModality {
     MODALITY_UNSPECIFIED = "MODALITY_UNSPECIFIED",
     TEXT = "TEXT",
@@ -2362,6 +2591,7 @@ export declare enum MediaModality {
     DOCUMENT = "DOCUMENT"
 }
 
+/** The media resolution to use. */
 export declare enum MediaResolution {
     MEDIA_RESOLUTION_UNSPECIFIED = "MEDIA_RESOLUTION_UNSPECIFIED",
     MEDIA_RESOLUTION_LOW = "MEDIA_RESOLUTION_LOW",
@@ -2369,6 +2599,7 @@ export declare enum MediaResolution {
     MEDIA_RESOLUTION_HIGH = "MEDIA_RESOLUTION_HIGH"
 }
 
+/** Server content modalities. */
 export declare enum Modality {
     MODALITY_UNSPECIFIED = "MODALITY_UNSPECIFIED",
     TEXT = "TEXT",
@@ -2384,11 +2615,40 @@ export declare interface ModalityTokenCount {
     tokenCount?: number;
 }
 
+/** The mode of the predictor to be used in dynamic retrieval. */
 export declare enum Mode {
     MODE_UNSPECIFIED = "MODE_UNSPECIFIED",
     MODE_DYNAMIC = "MODE_DYNAMIC"
 }
 
+/** A trained machine learning model. */
+export declare interface Model {
+    /** Resource name of the model. */
+    name?: string;
+    /** Display name of the model. */
+    displayName?: string;
+    /** Description of the model. */
+    description?: string;
+    /** Version ID of the model. A new version is committed when a new
+     model version is uploaded or trained under an existing model ID. The
+     version ID is an auto-incrementing decimal number in string
+     representation. */
+    version?: string;
+    /** List of deployed models created from this base model. Note that a
+     model could have been deployed to endpoints in different locations. */
+    endpoints?: Endpoint[];
+    /** Labels with user-defined metadata to organize your models. */
+    labels?: Record<string, string>;
+    /** Information about the tuned model from the base model. */
+    tunedModelInfo?: TunedModelInfo;
+    /** The maximum number of input tokens that the model can handle. */
+    inputTokenLimit?: number;
+    /** The maximum number of output tokens that the model can generate. */
+    outputTokenLimit?: number;
+    /** List of actions that are supported by the model. */
+    supportedActions?: string[];
+}
+
 export declare class Models extends BaseModule {
     private readonly apiClient;
     constructor(apiClient: ApiClient);
@@ -2539,6 +2799,15 @@ export declare class Models extends BaseModule {
      * ```
      */
     private generateImagesInternal;
+    /**
+     * Fetches information about a model by name.
+     *
+     * @example
+     * ```ts
+     * const modelInfo = await ai.models.get({model: 'gemini-2.0-flash'});
+     * ```
+     */
+    get(params: types.GetModelParameters): Promise<types.Model>;
     /**
      * Counts the number of tokens in the given contents. Multimodal input is
      * supported for Gemini models.
@@ -2592,15 +2861,21 @@ export declare class Models extends BaseModule {
      *
      * while (!operation.done) {
      *   await new Promise(resolve => setTimeout(resolve, 10000));
-     *   operation = await ai.operations.get({operation: operation});
+     *   operation = await ai.operations.getVideosOperation({operation: operation});
      * }
      *
-     * console.log(operation.result?.generatedVideos?.[0]?.video?.uri);
+     * console.log(operation.response?.generatedVideos?.[0]?.video?.uri);
      * ```
      */
     generateVideos(params: types.GenerateVideosParameters): Promise<types.GenerateVideosOperation>;
 }
 
+/** Config for model selection. */
+export declare interface ModelSelectionConfig {
+    /** Options for feature selection preference. */
+    featureSelectionPreference?: FeatureSelectionPreference;
+}
+
 /** Parameters for the get method of the operations module. */
 export declare interface OperationGetParameters {
     /** The operation to be retrieved. */
@@ -2615,10 +2890,10 @@ export declare class Operations extends BaseModule {
     /**
      * Gets the status of a long-running operation.
      *
-     * @param operation The Operation object returned by a previous API call.
+     * @param parameters The parameters for the get operation request.
      * @return The updated Operation object, with the latest status or result.
      */
-    get(parameters: types.OperationGetParameters): Promise<types.GenerateVideosOperation>;
+    getVideosOperation(parameters: types.OperationGetParameters): Promise<types.GenerateVideosOperation>;
     private getVideosOperationInternal;
     private fetchPredictVideosOperationInternal;
 }
@@ -2628,6 +2903,7 @@ export declare class Operations extends BaseModule {
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+/** Required. Outcome of the code execution. */
 export declare enum Outcome {
     OUTCOME_UNSPECIFIED = "OUTCOME_UNSPECIFIED",
     OUTCOME_OK = "OUTCOME_OK",
@@ -2793,6 +3069,7 @@ export declare type PartListUnion = PartUnion[] | PartUnion;
 
 export declare type PartUnion = Part | string;
 
+/** Enum that controls the generation of people. */
 export declare enum PersonGeneration {
     DONT_ALLOW = "DONT_ALLOW",
     ALLOW_ADULT = "ALLOW_ADULT",
@@ -2806,6 +3083,54 @@ export declare interface PrebuiltVoiceConfig {
     voiceName?: string;
 }
 
+/** Specifies the context retrieval config. */
+export declare interface RagRetrievalConfig {
+    /** Optional. Config for filters. */
+    filter?: RagRetrievalConfigFilter;
+    /** Optional. Config for Hybrid Search. */
+    hybridSearch?: RagRetrievalConfigHybridSearch;
+    /** Optional. Config for ranking and reranking. */
+    ranking?: RagRetrievalConfigRanking;
+    /** Optional. The number of contexts to retrieve. */
+    topK?: number;
+}
+
+/** Config for filters. */
+export declare interface RagRetrievalConfigFilter {
+    /** Optional. String for metadata filtering. */
+    metadataFilter?: string;
+    /** Optional. Only returns contexts with vector distance smaller than the threshold. */
+    vectorDistanceThreshold?: number;
+    /** Optional. Only returns contexts with vector similarity larger than the threshold. */
+    vectorSimilarityThreshold?: number;
+}
+
+/** Config for Hybrid Search. */
+export declare interface RagRetrievalConfigHybridSearch {
+    /** Optional. Alpha value controls the weight between dense and sparse vector search results. The range is [0, 1], while 0 means sparse vector search only and 1 means dense vector search only. The default value is 0.5 which balances sparse and dense vector search equally. */
+    alpha?: number;
+}
+
+/** Config for ranking and reranking. */
+export declare interface RagRetrievalConfigRanking {
+    /** Optional. Config for LlmRanker. */
+    llmRanker?: RagRetrievalConfigRankingLlmRanker;
+    /** Optional. Config for Rank Service. */
+    rankService?: RagRetrievalConfigRankingRankService;
+}
+
+/** Config for LlmRanker. */
+export declare interface RagRetrievalConfigRankingLlmRanker {
+    /** Optional. The model name used for ranking. Format: `gemini-1.5-pro` */
+    modelName?: string;
+}
+
+/** Config for Rank Service. */
+export declare interface RagRetrievalConfigRankingRankService {
+    /** Optional. The model name of the rank service. Format: `semantic-ranker-512@latest` */
+    modelName?: string;
+}
+
 /** A raw reference image.
 
  A raw reference image represents the base image to edit, provided by the user.
@@ -2821,6 +3146,20 @@ export declare interface RawReferenceImage {
     referenceType?: string;
 }
 
+/** Marks the end of user activity.
+
+ This can only be sent if automatic (i.e. server-side) activity detection is
+ disabled.
+ */
+export declare interface RealtimeInputConfig {
+    /** If not set, automatic activity detection is enabled by default. If automatic voice detection is disabled, the client must send activity signals. */
+    automaticActivityDetection?: AutomaticActivityDetection;
+    /** Defines what effect activity has. */
+    activityHandling?: ActivityHandling;
+    /** Defines which input is included in the user's turn. */
+    turnCoverage?: TurnCoverage;
+}
+
 /** Represents a recorded session. */
 export declare interface ReplayFile {
     replayId?: string;
@@ -2878,6 +3217,7 @@ export declare interface SafetyAttributes {
     contentType?: string;
 }
 
+/** Enum that controls the safety filter level for objectionable content. */
 export declare enum SafetyFilterLevel {
     BLOCK_LOW_AND_ABOVE = "BLOCK_LOW_AND_ABOVE",
     BLOCK_MEDIUM_AND_ABOVE = "BLOCK_MEDIUM_AND_ABOVE",
@@ -3113,8 +3453,14 @@ export declare class Session {
 
      @example
      ```ts
+     let model: string;
+     if (GOOGLE_GENAI_USE_VERTEXAI) {
+     model = 'gemini-2.0-flash-live-preview-04-09';
+     } else {
+     model = 'gemini-2.0-flash-live-001';
+     }
      const session = await ai.live.connect({
-     model: 'gemini-2.0-flash-exp',
+     model: model,
      config: {
      responseModalities: [Modality.AUDIO],
      }
@@ -3126,21 +3472,50 @@ export declare class Session {
     close(): void;
 }
 
-declare function setValueByPath(data: Record<string, unknown>, keys: string[], value: unknown): void;
+/** Configuration of session resumption mechanism.
+
+ Included in `LiveConnectConfig.session_resumption`. If included server
+ will send `LiveServerSessionResumptionUpdate` messages.
+ */
+export declare interface SessionResumptionConfig {
+    /** Session resumption handle of previous session (session to restore).
+
+     If not present new session will be started. */
+    handle?: string;
+    /** If set the server will send `last_consumed_client_message_index` in the `session_resumption_update` messages to allow for transparent reconnections. */
+    transparent?: boolean;
+}
+
+/** Context window will be truncated by keeping only suffix of it.
+
+ Context window will always be cut at start of USER role turn. System
+ instructions and `BidiGenerateContentSetup.prefix_turns` will not be
+ subject to the sliding window mechanism, they will always stay at the
+ beginning of context window.
+ */
+export declare interface SlidingWindow {
+    /** Session reduction target -- how many tokens we should keep. Window shortening operation has some latency costs, so we should avoid running it on every turn. Should be < trigger_tokens. If not set, trigger_tokens/2 is assumed. */
+    targetTokens?: string;
+}
 
 /** The speech generation configuration. */
 export declare interface SpeechConfig {
     /** The configuration for the speaker to use.
      */
     voiceConfig?: VoiceConfig;
+    /** Language code (ISO 639. e.g. en-US) for the speech synthesization.
+     Only available for Live API.
+     */
+    languageCode?: string;
 }
 
 export declare type SpeechConfigUnion = SpeechConfig | string;
 
-export declare enum State {
-    STATE_UNSPECIFIED = "STATE_UNSPECIFIED",
-    ACTIVE = "ACTIVE",
-    ERROR = "ERROR"
+/** Start of speech sensitivity. */
+export declare enum StartSensitivity {
+    START_SENSITIVITY_UNSPECIFIED = "START_SENSITIVITY_UNSPECIFIED",
+    START_SENSITIVITY_HIGH = "START_SENSITIVITY_HIGH",
+    START_SENSITIVITY_LOW = "START_SENSITIVITY_LOW"
 }
 
 /** Configuration for a Style reference image. */
@@ -3195,6 +3570,7 @@ export declare interface SubjectReferenceImage {
     config?: SubjectReferenceConfig;
 }
 
+/** Enum representing the subject type of a subject reference image. */
 export declare enum SubjectReferenceType {
     SUBJECT_TYPE_DEFAULT = "SUBJECT_TYPE_DEFAULT",
     SUBJECT_TYPE_PERSON = "SUBJECT_TYPE_PERSON",
@@ -3233,6 +3609,9 @@ export declare interface ThinkingConfig {
     /** Indicates whether to include thoughts in the response. If true, thoughts are returned only if the model supports thought and thoughts are available.
      */
     includeThoughts?: boolean;
+    /** Indicates the thinking budget in tokens.
+     */
+    thinkingBudget?: number;
 }
 
 /** Tokens info with a list of tokens and the corresponding list of token ids. */
@@ -3275,6 +3654,41 @@ export declare interface ToolConfig {
 
 export declare type ToolListUnion = Tool[];
 
+/** Output only. Traffic type. This shows whether a request consumes Pay-As-You-Go or Provisioned Throughput quota. */
+export declare enum TrafficType {
+    TRAFFIC_TYPE_UNSPECIFIED = "TRAFFIC_TYPE_UNSPECIFIED",
+    ON_DEMAND = "ON_DEMAND",
+    PROVISIONED_THROUGHPUT = "PROVISIONED_THROUGHPUT"
+}
+
+/** Audio transcription in Server Conent. */
+export declare interface Transcription {
+    /** Transcription text.
+     */
+    text?: string;
+    /** The bool indicates the end of the transcription.
+     */
+    finished?: boolean;
+}
+
+/** A tuned machine learning model. */
+export declare interface TunedModelInfo {
+    /** ID of the base model that you want to tune. */
+    baseModel?: string;
+    /** Date and time when the base model was created. */
+    createTime?: string;
+    /** Date and time when the base model was last updated. */
+    updateTime?: string;
+}
+
+/** Options about which input is included in the user's turn. */
+export declare enum TurnCoverage {
+    TURN_COVERAGE_UNSPECIFIED = "TURN_COVERAGE_UNSPECIFIED",
+    TURN_INCLUDES_ONLY_ACTIVITY = "TURN_INCLUDES_ONLY_ACTIVITY",
+    TURN_INCLUDES_ALL_INPUT = "TURN_INCLUDES_ALL_INPUT"
+}
+
+/** Optional. The type of the data. */
 export declare enum Type {
     TYPE_UNSPECIFIED = "TYPE_UNSPECIFIED",
     STRING = "STRING",
@@ -3307,11 +3721,12 @@ declare namespace types {
         HarmProbability,
         HarmSeverity,
         BlockedReason,
+        TrafficType,
         Modality,
-        State,
+        MediaResolution,
+        FeatureSelectionPreference,
         DynamicRetrievalConfigMode,
         FunctionCallingConfigMode,
-        MediaResolution,
         SafetyFilterLevel,
         PersonGeneration,
         ImagePromptLanguage,
@@ -3321,6 +3736,10 @@ declare namespace types {
         ControlReferenceType,
         SubjectReferenceType,
         MediaModality,
+        StartSensitivity,
+        EndSensitivity,
+        ActivityHandling,
+        TurnCoverage,
         VideoMetadata,
         CodeExecutionResult,
         ExecutableCode,
@@ -3332,6 +3751,7 @@ declare namespace types {
         Content,
         HttpOptions,
         Schema,
+        ModelSelectionConfig,
         SafetySetting,
         FunctionDeclaration,
         GoogleSearch,
@@ -3339,6 +3759,12 @@ declare namespace types {
         GoogleSearchRetrieval,
         VertexAISearch,
         VertexRagStoreRagResource,
+        RagRetrievalConfigFilter,
+        RagRetrievalConfigHybridSearch,
+        RagRetrievalConfigRankingLlmRanker,
+        RagRetrievalConfigRankingRankService,
+        RagRetrievalConfigRanking,
+        RagRetrievalConfig,
         VertexRagStore,
         Retrieval,
         ToolCodeExecution,
@@ -3386,6 +3812,11 @@ declare namespace types {
         SafetyAttributes,
         GeneratedImage,
         GenerateImagesResponse,
+        GetModelConfig,
+        GetModelParameters,
+        Endpoint,
+        TunedModelInfo,
+        Model,
         GenerationConfig,
         CountTokensConfig,
         CountTokensParameters,
@@ -3423,6 +3854,7 @@ declare namespace types {
         CreateFileParameters,
         HttpResponse,
         LiveCallbacks,
+        UploadFileParameters,
         CreateFileResponse,
         GetFileConfig,
         GetFileParameters,
@@ -3453,12 +3885,24 @@ declare namespace types {
         SubjectReferenceConfig,
         SubjectReferenceImage,
         LiveServerSetupComplete,
+        Transcription,
         LiveServerContent,
         LiveServerToolCall,
         LiveServerToolCallCancellation,
+        UsageMetadata,
+        LiveServerGoAway,
+        LiveServerSessionResumptionUpdate,
         LiveServerMessage,
+        AutomaticActivityDetection,
+        RealtimeInputConfig,
+        SessionResumptionConfig,
+        SlidingWindow,
+        ContextWindowCompressionConfig,
+        AudioTranscriptionConfig,
         LiveClientSetup,
         LiveClientContent,
+        ActivityStart,
+        ActivityEnd,
         LiveClientRealtimeInput,
         LiveClientToolResponse,
         LiveClientMessage,
@@ -3535,9 +3979,9 @@ export declare interface UploadFileConfig {
 }
 
 /** Parameters for the upload file method. */
-declare interface UploadFileParameters {
+export declare interface UploadFileParameters {
     /** The string path to the file to be uploaded or a Blob object. */
-    file: string | Blob;
+    file: string | globalThis.Blob;
     /** Configuration that contains optional parameters. */
     config?: UploadFileConfig;
 }
@@ -3573,6 +4017,33 @@ export declare interface UpscaleImageParameters {
     config?: UpscaleImageConfig;
 }
 
+/** Usage metadata about response(s). */
+export declare interface UsageMetadata {
+    /** Number of tokens in the prompt. When `cached_content` is set, this is still the total effective prompt size meaning this includes the number of tokens in the cached content. */
+    promptTokenCount?: number;
+    /** Number of tokens in the cached part of the prompt (the cached content). */
+    cachedContentTokenCount?: number;
+    /** Total number of tokens across all the generated response candidates. */
+    responseTokenCount?: number;
+    /** Number of tokens present in tool-use prompt(s). */
+    toolUsePromptTokenCount?: number;
+    /** Number of tokens of thoughts for thinking models. */
+    thoughtsTokenCount?: number;
+    /** Total token count for prompt, response candidates, and tool-use prompts(if present). */
+    totalTokenCount?: number;
+    /** List of modalities that were processed in the request input. */
+    promptTokensDetails?: ModalityTokenCount[];
+    /** List of modalities that were processed in the cache input. */
+    cacheTokensDetails?: ModalityTokenCount[];
+    /** List of modalities that were returned in the response. */
+    responseTokensDetails?: ModalityTokenCount[];
+    /** List of modalities that were processed in the tool-use prompt. */
+    toolUsePromptTokensDetails?: ModalityTokenCount[];
+    /** Traffic type. This shows whether a request consumes Pay-As-You-Go
+     or Provisioned Throughput quota. */
+    trafficType?: TrafficType;
+}
+
 /** Retrieve from Vertex AI Search datastore or engine for grounding. datastore and engine are mutually exclusive. See https://cloud.google.com/products/agent-builder */
 export declare interface VertexAISearch {
     /** Optional. Fully-qualified Vertex AI Search data store resource ID. Format: `projects/{project}/locations/{location}/collections/{collection}/dataStores/{dataStore}` */
@@ -3587,6 +4058,8 @@ export declare interface VertexRagStore {
     ragCorpora?: string[];
     /** Optional. The representation of the rag source. It can be used to specify corpus only or ragfiles. Currently only support one corpus or multiple files from one corpus. In the future we may open up multiple corpora support. */
     ragResources?: VertexRagStoreRagResource[];
+    /** Optional. The retrieval config for the Rag query. */
+    ragRetrievalConfig?: RagRetrievalConfig;
     /** Optional. Number of top k results to return from the selected corpora. */
     similarityTopK?: number;
     /** Optional. Only return results with vector distance smaller than the threshold. */