@google/genai 0.6.1 → 0.8.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,6 +43,7 @@ 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>;
@@ -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",
@@ -187,6 +235,12 @@ export declare class Caches extends BaseModule {
     /**
      * Creates a cached contents resource.
      *
+     * @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)
+     * for more information.
+     *
      * @param params - The parameters for the create request.
      * @return The created cached content.
      *
@@ -194,7 +248,7 @@ export declare class Caches extends BaseModule {
      * ```ts
      * const contents = ...; // Initialize the content to cache.
      * const response = await ai.caches.create({
-     *   model: 'gemini-2.0-flash',
+     *   model: 'gemini-1.5-flash',
      *   config: {
      *    'contents': contents,
      *    'displayName': 'test cache',
@@ -429,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. */
@@ -470,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;
 }
 
@@ -500,6 +544,14 @@ export declare type ContentListUnion = ContentUnion[] | ContentUnion;
 
 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. */
@@ -531,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",
@@ -578,9 +631,9 @@ export declare class CountTokensResponse {
 export declare interface CreateCachedContentConfig {
     /** Used to override HTTP request options. */
     httpOptions?: HttpOptions;
-    /** The TTL for this resource. The expiration time is computed: now + TTL. */
+    /** The TTL for this resource. The expiration time is computed: now + TTL. It is a duration string, with up to nine fractional digits, terminated by 's'. Example: "3.5s". */
     ttl?: string;
-    /** Timestamp of when this resource is considered expired. */
+    /** Timestamp of when this resource is considered expired. Uses RFC 3339 format, Example: 2014-10-02T15:01:23Z. */
     expireTime?: string;
     /** The user-generated meaningful display name of the cached content.
      */
@@ -666,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;
 
@@ -757,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"
@@ -820,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. */
@@ -828,6 +897,20 @@ export declare interface ExecutableCode {
     language?: Language;
 }
 
+export declare interface FetchPredictOperationConfig {
+    /** Used to override HTTP request options. */
+    httpOptions?: HttpOptions;
+}
+
+/** Parameters for the fetchPredictOperation method. */
+export declare interface FetchPredictOperationParameters {
+    /** The server-assigned name for the operation. */
+    operationName: string;
+    resourceName: string;
+    /** Used to override the default configuration. */
+    config?: FetchPredictOperationConfig;
+}
+
 /** A file uploaded to the API. */
 declare interface File_2 {
     /** The `File` resource name. The ID (name excluding the "files/" prefix) can contain up to 40 characters that are lowercase alphanumeric or dashes (-). The ID cannot start or end with a dash. If the name is empty on create, a unique name will be generated. Example: `files/123-456` */
@@ -837,7 +920,7 @@ declare interface File_2 {
     /** Output only. MIME type of the file. */
     mimeType?: string;
     /** Output only. Size of the file in bytes. */
-    sizeBytes?: number;
+    sizeBytes?: string;
     /** Output only. The timestamp of when the `File` was created. */
     createTime?: string;
     /** Output only. The timestamp of when the `File` will be deleted. Only set if the `File` is scheduled to expire. */
@@ -869,7 +952,7 @@ export declare interface FileData {
     mimeType?: string;
 }
 
-declare class Files extends BaseModule {
+export declare class Files extends BaseModule {
     private readonly apiClient;
     constructor(apiClient: ApiClient);
     /**
@@ -914,8 +997,9 @@ declare class Files extends BaseModule {
      * This section can contain multiple paragraphs and code examples.
      *
      * @param params - Optional parameters specified in the
-     *        `common.UploadFileParameters` interface.
-     *        Optional @see {@link common.UploadFileParameters}
+     *        `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,
@@ -932,7 +1016,7 @@ 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;
     /**
@@ -967,6 +1051,7 @@ 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",
@@ -990,6 +1075,7 @@ declare interface FileStat {
     type: string | undefined;
 }
 
+/** State for the lifecycle of a File. */
 export declare enum FileState {
     STATE_UNSPECIFIED = "STATE_UNSPECIFIED",
     PROCESSING = "PROCESSING",
@@ -1007,6 +1093,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",
@@ -1021,8 +1111,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
@@ -1042,6 +1130,7 @@ export declare interface FunctionCallingConfig {
     allowedFunctionNames?: string[];
 }
 
+/** Config for the function calling config mode. */
 export declare enum FunctionCallingConfigMode {
     MODE_UNSPECIFIED = "MODE_UNSPECIFIED",
     AUTO = "AUTO",
@@ -1366,6 +1455,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. */
@@ -1387,6 +1478,12 @@ export declare interface GeneratedImage {
     enhancedPrompt?: string;
 }
 
+/** A generated video. */
+export declare interface GeneratedVideo {
+    /** The output video */
+    video?: Video;
+}
+
 /** The config for generating an images. */
 export declare interface GenerateImagesConfig {
     /** Used to override HTTP request options. */
@@ -1468,6 +1565,72 @@ export declare class GenerateImagesResponse {
     positivePromptSafetyAttributes?: SafetyAttributes;
 }
 
+/** Configuration for generating videos. */
+export declare interface GenerateVideosConfig {
+    /** Used to override HTTP request options. */
+    httpOptions?: HttpOptions;
+    /** Number of output videos. */
+    numberOfVideos?: number;
+    /** The gcs bucket where to save the generated videos. */
+    outputGcsUri?: string;
+    /** Frames per second for video generation. */
+    fps?: number;
+    /** Duration of the clip for video generation in seconds. */
+    durationSeconds?: number;
+    /** The RNG seed. If RNG seed is exactly same for each request with unchanged inputs, the prediction results will be consistent. Otherwise, a random RNG seed will be used each time to produce a different result. */
+    seed?: number;
+    /** The aspect ratio for the generated video. 16:9 (landscape) and 9:16 (portrait) are supported. */
+    aspectRatio?: string;
+    /** The resolution for the generated video. 1280x720, 1920x1080 are supported. */
+    resolution?: string;
+    /** Whether allow to generate person videos, and restrict to specific ages. Supported values are: dont_allow, allow_adult. */
+    personGeneration?: string;
+    /** The pubsub topic where to publish the video generation progress. */
+    pubsubTopic?: string;
+    /** Optional field in addition to the text content. Negative prompts can be explicitly stated here to help generate the video. */
+    negativePrompt?: string;
+    /** Whether to use the prompt rewriting logic. */
+    enhancePrompt?: boolean;
+}
+
+/** A video generation operation. */
+export declare interface GenerateVideosOperation {
+    /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
+    name?: string;
+    /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
+    metadata?: Record<string, unknown>;
+    /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
+    done?: boolean;
+    /** The error result of the operation in case of failure or cancellation. */
+    error?: Record<string, unknown>;
+    /** The generated videos. */
+    response?: GenerateVideosResponse;
+}
+
+/** Class that represents the parameters for generating an image. */
+export declare interface GenerateVideosParameters {
+    /** ID of the model to use. For a list of models, see `Google models
+     <https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models>`_. */
+    model: string;
+    /** The text prompt for generating the videos. Optional for image to video use cases. */
+    prompt?: string;
+    /** The input image for generating the videos.
+     Optional if prompt is provided. */
+    image?: Image_2;
+    /** Configuration for generating videos. */
+    config?: GenerateVideosConfig;
+}
+
+/** Response with generated videos. */
+export declare class GenerateVideosResponse {
+    /** List of the generated videos */
+    generatedVideos?: GeneratedVideo[];
+    /** Returns if any videos were filtered due to RAI policies. */
+    raiMediaFilteredCount?: number;
+    /** Returns rai failure reasons if any. */
+    raiMediaFilteredReasons?: string[];
+}
+
 /** Generation config. */
 export declare interface GenerationConfig {
     /** Optional. If enabled, audio timestamp will be included in the request to the model. */
@@ -1480,6 +1643,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. */
@@ -1552,7 +1717,30 @@ export declare interface GetFileParameters {
     config?: GetFileConfig;
 }
 
-declare function getValueByPath(data: unknown, keys: string[]): unknown;
+/** 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;
+}
+
+/** Parameters for the GET method. */
+export declare interface GetOperationParameters {
+    /** The server-assigned name for the operation. */
+    operationName: string;
+    /** Used to override the default configuration. */
+    config?: GetOperationConfig;
+}
 
 /**
  * The Google GenAI SDK.
@@ -1600,6 +1788,7 @@ export declare class GoogleGenAI {
     readonly chats: Chats;
     readonly caches: Caches;
     readonly files: Files;
+    readonly operations: Operations;
     constructor(options: GoogleGenAIOptions);
 }
 
@@ -1704,6 +1893,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. */
@@ -1736,12 +1927,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",
@@ -1751,6 +1944,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",
@@ -1760,6 +1954,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",
@@ -1768,6 +1963,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",
@@ -1860,6 +2056,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",
@@ -1868,6 +2065,7 @@ export declare enum ImagePromptLanguage {
     hi = "hi"
 }
 
+/** Required. Programming language of the `code`. */
 export declare enum Language {
     LANGUAGE_UNSPECIFIED = "LANGUAGE_UNSPECIFIED",
     PYTHON = "PYTHON"
@@ -1971,9 +2169,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;
 }
 
@@ -2012,11 +2222,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).
@@ -2028,6 +2238,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. */
@@ -2038,15 +2252,7 @@ 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.
@@ -2059,6 +2265,16 @@ export declare interface LiveClientSetup {
      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;
 }
 
 /** Client generated response to a `ToolCall` received from the server.
@@ -2097,6 +2313,16 @@ export declare interface LiveConnectConfig {
      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;
+    /** 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. */
@@ -2125,6 +2351,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. */
@@ -2145,6 +2375,21 @@ 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;
+}
+
+/** 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. */
@@ -2157,6 +2402,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. */
@@ -2238,6 +2506,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",
@@ -2246,6 +2515,17 @@ export declare enum MaskReferenceMode {
     MASK_MODE_SEMANTIC = "MASK_MODE_SEMANTIC"
 }
 
+/** Server content modalities. */
+export declare enum MediaModality {
+    MODALITY_UNSPECIFIED = "MODALITY_UNSPECIFIED",
+    TEXT = "TEXT",
+    IMAGE = "IMAGE",
+    VIDEO = "VIDEO",
+    AUDIO = "AUDIO",
+    DOCUMENT = "DOCUMENT"
+}
+
+/** The media resolution to use. */
 export declare enum MediaResolution {
     MEDIA_RESOLUTION_UNSPECIFIED = "MEDIA_RESOLUTION_UNSPECIFIED",
     MEDIA_RESOLUTION_LOW = "MEDIA_RESOLUTION_LOW",
@@ -2253,6 +2533,7 @@ export declare enum MediaResolution {
     MEDIA_RESOLUTION_HIGH = "MEDIA_RESOLUTION_HIGH"
 }
 
+/** Server content modalities. */
 export declare enum Modality {
     MODALITY_UNSPECIFIED = "MODALITY_UNSPECIFIED",
     TEXT = "TEXT",
@@ -2263,16 +2544,45 @@ export declare enum Modality {
 /** Represents token counting info for a single modality. */
 export declare interface ModalityTokenCount {
     /** The modality associated with this token count. */
-    modality?: Modality;
+    modality?: MediaModality;
     /** Number of tokens. */
     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);
@@ -2423,6 +2733,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.
@@ -2459,6 +2778,52 @@ export declare class Models extends BaseModule {
      * ```
      */
     computeTokens(params: types.ComputeTokensParameters): Promise<types.ComputeTokensResponse>;
+    /**
+     *  Generates videos based on a text description and configuration.
+     *
+     * @param params - The parameters for generating videos.
+     * @return A Promise<GenerateVideosOperation> which allows you to track the progress and eventually retrieve the generated videos using the operations.get method.
+     *
+     * @example
+     * ```ts
+     * const operation = await ai.models.generateVideos({
+     *  model: 'veo-2.0-generate-001',
+     *  prompt: 'A neon hologram of a cat driving at top speed',
+     *  config: {
+     *    numberOfVideos: 1
+     * });
+     *
+     * while (!operation.done) {
+     *   await new Promise(resolve => setTimeout(resolve, 10000));
+     *   operation = await ai.operations.getVideosOperation({operation: operation});
+     * }
+     *
+     * console.log(operation.response?.generatedVideos?.[0]?.video?.uri);
+     * ```
+     */
+    generateVideos(params: types.GenerateVideosParameters): Promise<types.GenerateVideosOperation>;
+}
+
+/** Parameters for the get method of the operations module. */
+export declare interface OperationGetParameters {
+    /** The operation to be retrieved. */
+    operation: GenerateVideosOperation;
+    /** Used to override the default configuration. */
+    config?: GetOperationConfig;
+}
+
+export declare class Operations extends BaseModule {
+    private readonly apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Gets the status of a long-running operation.
+     *
+     * @param parameters The parameters for the get operation request.
+     * @return The updated Operation object, with the latest status or result.
+     */
+    getVideosOperation(parameters: types.OperationGetParameters): Promise<types.GenerateVideosOperation>;
+    private getVideosOperationInternal;
+    private fetchPredictVideosOperationInternal;
 }
 
 /**
@@ -2466,6 +2831,7 @@ export declare class Models 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",
@@ -2481,7 +2847,7 @@ export declare enum Outcome {
 /**
  * Pagers for the GenAI List APIs.
  */
-declare enum PagedItem {
+export declare enum PagedItem {
     PAGED_ITEM_BATCH_JOBS = "batchJobs",
     PAGED_ITEM_MODELS = "models",
     PAGED_ITEM_TUNING_JOBS = "tuningJobs",
@@ -2508,7 +2874,7 @@ declare interface PagedItemResponse<T> {
 /**
  * Pager class for iterating through paginated results.
  */
-declare class Pager<T> implements AsyncIterable<T> {
+export declare class Pager<T> implements AsyncIterable<T> {
     private nameInternal;
     private pageInternal;
     private paramsInternal;
@@ -2631,6 +2997,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",
@@ -2659,6 +3026,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;
@@ -2716,6 +3097,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",
@@ -2964,7 +3346,31 @@ 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 {
@@ -2975,10 +3381,11 @@ export declare interface SpeechConfig {
 
 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. */
@@ -3033,6 +3440,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",
@@ -3071,6 +3479,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. */
@@ -3113,6 +3524,31 @@ 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"
+}
+
+/** 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",
@@ -3145,11 +3581,11 @@ declare namespace types {
         HarmProbability,
         HarmSeverity,
         BlockedReason,
+        TrafficType,
         Modality,
-        State,
+        MediaResolution,
         DynamicRetrievalConfigMode,
         FunctionCallingConfigMode,
-        MediaResolution,
         SafetyFilterLevel,
         PersonGeneration,
         ImagePromptLanguage,
@@ -3158,6 +3594,11 @@ declare namespace types {
         MaskReferenceMode,
         ControlReferenceType,
         SubjectReferenceType,
+        MediaModality,
+        StartSensitivity,
+        EndSensitivity,
+        ActivityHandling,
+        TurnCoverage,
         VideoMetadata,
         CodeExecutionResult,
         ExecutableCode,
@@ -3223,6 +3664,11 @@ declare namespace types {
         SafetyAttributes,
         GeneratedImage,
         GenerateImagesResponse,
+        GetModelConfig,
+        GetModelParameters,
+        Endpoint,
+        TunedModelInfo,
+        Model,
         GenerationConfig,
         CountTokensConfig,
         CountTokensParameters,
@@ -3231,6 +3677,12 @@ declare namespace types {
         ComputeTokensParameters,
         TokensInfo,
         ComputeTokensResponse,
+        GenerateVideosConfig,
+        GenerateVideosParameters,
+        Video,
+        GeneratedVideo,
+        GenerateVideosResponse,
+        GenerateVideosOperation,
         CreateCachedContentConfig,
         CreateCachedContentParameters,
         CachedContentUsageMetadata,
@@ -3254,12 +3706,17 @@ declare namespace types {
         CreateFileParameters,
         HttpResponse,
         LiveCallbacks,
+        UploadFileParameters,
         CreateFileResponse,
         GetFileConfig,
         GetFileParameters,
         DeleteFileConfig,
         DeleteFileParameters,
         DeleteFileResponse,
+        GetOperationConfig,
+        GetOperationParameters,
+        FetchPredictOperationConfig,
+        FetchPredictOperationParameters,
         TestTableItem,
         TestTableFile,
         ReplayRequest,
@@ -3283,12 +3740,23 @@ declare namespace types {
         LiveServerContent,
         LiveServerToolCall,
         LiveServerToolCallCancellation,
+        UsageMetadata,
+        LiveServerGoAway,
+        LiveServerSessionResumptionUpdate,
         LiveServerMessage,
+        AutomaticActivityDetection,
+        RealtimeInputConfig,
+        SessionResumptionConfig,
+        SlidingWindow,
+        ContextWindowCompressionConfig,
         LiveClientSetup,
         LiveClientContent,
+        ActivityStart,
+        ActivityEnd,
         LiveClientRealtimeInput,
         LiveClientToolResponse,
         LiveClientMessage,
+        AudioTranscriptionConfig,
         LiveConnectConfig,
         LiveConnectParameters,
         CreateChatParameters,
@@ -3296,6 +3764,7 @@ declare namespace types {
         LiveSendClientContentParameters,
         LiveSendRealtimeInputParameters,
         LiveSendToolResponseParameters,
+        OperationGetParameters,
         PartUnion,
         PartListUnion,
         ContentUnion,
@@ -3310,9 +3779,9 @@ declare namespace types {
 export declare interface UpdateCachedContentConfig {
     /** Used to override HTTP request options. */
     httpOptions?: HttpOptions;
-    /** The TTL for this resource. The expiration time is computed: now + TTL. */
+    /** The TTL for this resource. The expiration time is computed: now + TTL. It is a duration string, with up to nine fractional digits, terminated by 's'. Example: "3.5s". */
     ttl?: string;
-    /** Timestamp of when this resource is considered expired. */
+    /** Timestamp of when this resource is considered expired. Uses RFC 3339 format, Example: 2014-10-02T15:01:23Z. */
     expireTime?: string;
 }
 
@@ -3361,9 +3830,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;
 }
@@ -3399,6 +3868,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}` */
@@ -3427,6 +3923,16 @@ export declare interface VertexRagStoreRagResource {
     ragFileIds?: string[];
 }
 
+/** A generated video. */
+export declare interface Video {
+    /** Path to another storage. */
+    uri?: string;
+    /** Video bytes. */
+    videoBytes?: string;
+    /** Video encoding, for example "video/mp4". */
+    mimeType?: string;
+}
+
 /** Metadata describes the input video content. */
 export declare interface VideoMetadata {
     /** Optional. The end offset of the video. */