@google/genai 1.32.0 → 1.34.0

package/dist/node/node.d.ts

@@ -1,5 +1,8 @@
+/// <reference types="node" />
+
 import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { GoogleAuthOptions } from 'google-auth-library';
+import { ReadableStream as ReadableStream_2 } from 'stream/web';
 
 /** Marks the end of user activity.
 
@@ -63,6 +66,41 @@ export declare enum AdapterSize {
     ADAPTER_SIZE_THIRTY_TWO = "ADAPTER_SIZE_THIRTY_TWO"
 }
 
+/**
+ * The configuration for allowed tools.
+ */
+declare interface AllowedTools {
+    /**
+     * The mode of the tool choice.
+     */
+    mode?: ToolChoiceType;
+    /**
+     * The names of the allowed tools.
+     */
+    tools?: Array<string>;
+}
+
+/**
+ * Citation information for model-generated content.
+ */
+declare interface Annotation {
+    /**
+     * End of the attributed segment, exclusive.
+     */
+    end_index?: number;
+    /**
+     * Source attributed for a portion of the text. Could be a URL, title, or
+     * other identifier.
+     */
+    source?: string;
+    /**
+     * Start of segment of the response that is attributed to this source.
+     *
+     * Index indicates the start of the segment, measured in bytes.
+     */
+    start_index?: number;
+}
+
 /** The generic reusable api auth config. Deprecated. Please use AuthConfig (google/cloud/aiplatform/master/auth.proto) instead. This data type is not supported in Gemini API. */
 export declare interface ApiAuth {
     /** The API secret. */
@@ -81,7 +119,7 @@ export declare interface ApiAuthApiKeyConfig {
  * The ApiClient class is used to send requests to the Gemini API or Vertex AI
  * endpoints.
  */
-declare class ApiClient {
+declare class ApiClient implements GeminiNextGenAPIClientAdapter {
     readonly clientOptions: ApiClientInitOptions;
     constructor(opts: ApiClientInitOptions);
     /**
@@ -102,6 +140,7 @@ declare class ApiClient {
     isVertexAI(): boolean;
     getProject(): string | undefined;
     getLocation(): string | undefined;
+    getAuthHeaders(): Promise<Headers>;
     getApiVersion(): string;
     getBaseUrl(): string;
     getRequestUrl(): string;
@@ -217,6 +256,31 @@ declare interface ApiClientInitOptions {
     userAgentExtra?: string;
 }
 
+declare class APIConnectionError extends APIError<undefined, undefined, undefined> {
+    constructor({ message, cause }: {
+        message?: string | undefined;
+        cause?: Error | undefined;
+    });
+}
+
+declare class APIConnectionTimeoutError extends APIConnectionError {
+    constructor({ message }?: {
+        message?: string;
+    });
+}
+
+declare class APIError<TStatus extends number | undefined = number | undefined, THeaders extends Headers | undefined = Headers | undefined, TError extends Object | undefined = Object | undefined> extends GeminiNextGenAPIClientError {
+    /** HTTP status for the response that caused the error */
+    readonly status: TStatus;
+    /** HTTP headers for the response that caused the error */
+    readonly headers: THeaders;
+    /** JSON body of the response that caused the error */
+    readonly error: TError;
+    constructor(status: TStatus, error: TError, message: string | undefined, headers: THeaders);
+    private static makeMessage;
+    static generate(status: number | undefined, errorResponse: Object | undefined, message: string | undefined, headers: Headers | undefined): APIError;
+}
+
 /**
  * API errors raised by the GenAI API.
  */
@@ -253,6 +317,68 @@ export declare interface ApiKeyConfig {
     name?: string;
 }
 
+/**
+ * A subclass of `Promise` providing additional helper methods
+ * for interacting with the SDK.
+ */
+declare class APIPromise<T> extends Promise<T> {
+    private responsePromise;
+    private parseResponse;
+    private parsedPromise;
+    private client;
+    constructor(client: BaseGeminiNextGenAPIClient, responsePromise: Promise<APIResponseProps>, parseResponse?: (client: BaseGeminiNextGenAPIClient, props: APIResponseProps) => PromiseOrValue<T>);
+    _thenUnwrap<U>(transform: (data: T, props: APIResponseProps) => U): APIPromise<U>;
+    /**
+     * Gets the raw `Response` instance instead of parsing the response
+     * data.
+     *
+     * If you want to parse the response body but still get the `Response`
+     * instance, you can use {@link withResponse()}.
+     *
+     * 👋 Getting the wrong TypeScript type for `Response`?
+     * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]`
+     * to your `tsconfig.json`.
+     */
+    asResponse(): Promise<Response>;
+    /**
+     * Gets the parsed response data and the raw `Response` instance.
+     *
+     * If you just want to get the raw `Response` instance without parsing it,
+     * you can use {@link asResponse()}.
+     *
+     * 👋 Getting the wrong TypeScript type for `Response`?
+     * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]`
+     * to your `tsconfig.json`.
+     */
+    withResponse(): Promise<{
+        data: T;
+        response: Response;
+    }>;
+    private parse;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
+}
+
+declare abstract class APIResource {
+    /**
+     * The key path from the client. For example, a resource accessible as `client.resource.subresource` would
+     * have a property `static override readonly _key = Object.freeze(['resource', 'subresource'] as const);`.
+     */
+    static readonly _key: readonly string[];
+    protected _client: BaseGeminiNextGenAPIClient;
+    constructor(client: BaseGeminiNextGenAPIClient);
+}
+
+declare type APIResponseProps = {
+    response: Response;
+    options: FinalRequestOptions;
+    controller: AbortController;
+    requestLogID: string;
+    retryOfRequestLogID: string | undefined;
+    startTime: number;
+};
+
 /** The API spec that the external API implements. This enum is not supported in Gemini API. */
 export declare enum ApiSpec {
     /**
@@ -269,6 +395,12 @@ export declare enum ApiSpec {
     ELASTIC_SEARCH = "ELASTIC_SEARCH"
 }
 
+declare class APIUserAbortError extends APIError<undefined, undefined, undefined> {
+    constructor({ message }?: {
+        message?: string;
+    });
+}
+
 /** Representation of an audio chunk. */
 export declare interface AudioChunk {
     /** Raw bytes of audio data.
@@ -280,6 +412,24 @@ export declare interface AudioChunk {
     sourceMetadata?: LiveMusicSourceMetadata;
 }
 
+/**
+ * An audio content block.
+ */
+declare interface AudioContent {
+    type: 'audio';
+    data?: string;
+    /**
+     * The mime type of the audio.
+     */
+    mime_type?: AudioMimeType;
+    uri?: string;
+}
+
+/**
+ * The mime type of the audio.
+ */
+declare type AudioMimeType = 'audio/wav' | 'audio/mp3' | 'audio/aiff' | 'audio/aac' | 'audio/ogg' | 'audio/flac' | (string & {});
+
 /** The audio transcription configuration in Setup. */
 export declare interface AudioTranscriptionConfig {
 }
@@ -346,6 +496,9 @@ export declare interface AuthConfigOidcConfig {
     serviceAccount?: string;
 }
 
+declare class AuthenticationError extends APIError<401, Headers> {
+}
+
 /** Config for auth_tokens.create parameters. */
 export declare interface AuthToken {
     /** The name of the auth token. */
@@ -417,6 +570,259 @@ export declare interface AutomaticFunctionCallingConfig {
     ignoreCallHistory?: boolean;
 }
 
+declare class BadRequestError extends APIError<400, Headers> {
+}
+
+declare interface BaseCreateAgentInteractionParams {
+    /**
+     * Body param: The name of the `Agent` used for generating the interaction.
+     */
+    agent: (string & {}) | 'deep-research-pro-preview-12-2025';
+    /**
+     * Body param: The inputs for the interaction.
+     */
+    input: string | Array<TextContent | ImageContent | AudioContent | DocumentContent | VideoContent | ThoughtContent | FunctionCallContent | FunctionResultContent | CodeExecutionCallContent | CodeExecutionResultContent | URLContextCallContent | URLContextResultContent | GoogleSearchCallContent | GoogleSearchResultContent | MCPServerToolCallContent | MCPServerToolResultContent | FileSearchResultContent> | Array<Turn> | TextContent | ImageContent | AudioContent | DocumentContent | VideoContent | ThoughtContent | FunctionCallContent | FunctionResultContent | CodeExecutionCallContent | CodeExecutionResultContent | URLContextCallContent | URLContextResultContent | GoogleSearchCallContent | GoogleSearchResultContent | MCPServerToolCallContent | MCPServerToolResultContent | FileSearchResultContent;
+    /**
+     * Path param: Which version of the API to use.
+     */
+    api_version?: string;
+    /**
+     * Body param: Configuration for the agent.
+     */
+    agent_config?: DynamicAgentConfig | DeepResearchAgentConfig;
+    /**
+     * Body param: Whether to run the model interaction in the background.
+     */
+    background?: boolean;
+    /**
+     * Body param: The ID of the previous interaction, if any.
+     */
+    previous_interaction_id?: string;
+    /**
+     * Body param: Enforces that the generated response is a JSON object that complies with
+     * the JSON schema specified in this field.
+     */
+    response_format?: unknown;
+    /**
+     * Body param: The mime type of the response. This is required if response_format is set.
+     */
+    response_mime_type?: string;
+    /**
+     * Body param: The requested modalities of the response (TEXT, IMAGE, AUDIO).
+     */
+    response_modalities?: Array<'text' | 'image' | 'audio'>;
+    /**
+     * Body param: Input only. Whether to store the response and request for later retrieval.
+     */
+    store?: boolean;
+    /**
+     * Body param: Input only. Whether the interaction will be streamed.
+     */
+    stream?: boolean;
+    /**
+     * Body param: System instruction for the interaction.
+     */
+    system_instruction?: string;
+    /**
+     * Body param: A list of tool declarations the model may call during interaction.
+     */
+    tools?: Array<Tool_2>;
+}
+
+declare interface BaseCreateModelInteractionParams {
+    /**
+     * Body param: The inputs for the interaction.
+     */
+    input: string | Array<TextContent | ImageContent | AudioContent | DocumentContent | VideoContent | ThoughtContent | FunctionCallContent | FunctionResultContent | CodeExecutionCallContent | CodeExecutionResultContent | URLContextCallContent | URLContextResultContent | GoogleSearchCallContent | GoogleSearchResultContent | MCPServerToolCallContent | MCPServerToolResultContent | FileSearchResultContent> | Array<Turn> | TextContent | ImageContent | AudioContent | DocumentContent | VideoContent | ThoughtContent | FunctionCallContent | FunctionResultContent | CodeExecutionCallContent | CodeExecutionResultContent | URLContextCallContent | URLContextResultContent | GoogleSearchCallContent | GoogleSearchResultContent | MCPServerToolCallContent | MCPServerToolResultContent | FileSearchResultContent;
+    /**
+     * Body param: The name of the `Model` used for generating the interaction.
+     */
+    model: Model_2;
+    /**
+     * Path param: Which version of the API to use.
+     */
+    api_version?: string;
+    /**
+     * Body param: Whether to run the model interaction in the background.
+     */
+    background?: boolean;
+    /**
+     * Body param: Input only. Configuration parameters for the model interaction.
+     */
+    generation_config?: GenerationConfig_2;
+    /**
+     * Body param: The ID of the previous interaction, if any.
+     */
+    previous_interaction_id?: string;
+    /**
+     * Body param: Enforces that the generated response is a JSON object that complies with
+     * the JSON schema specified in this field.
+     */
+    response_format?: unknown;
+    /**
+     * Body param: The mime type of the response. This is required if response_format is set.
+     */
+    response_mime_type?: string;
+    /**
+     * Body param: The requested modalities of the response (TEXT, IMAGE, AUDIO).
+     */
+    response_modalities?: Array<'text' | 'image' | 'audio'>;
+    /**
+     * Body param: Input only. Whether to store the response and request for later retrieval.
+     */
+    store?: boolean;
+    /**
+     * Body param: Input only. Whether the interaction will be streamed.
+     */
+    stream?: boolean;
+    /**
+     * Body param: System instruction for the interaction.
+     */
+    system_instruction?: string;
+    /**
+     * Body param: A list of tool declarations the model may call during interaction.
+     */
+    tools?: Array<Tool_2>;
+}
+
+/**
+ * Base class for Gemini Next Gen API API clients.
+ */
+declare class BaseGeminiNextGenAPIClient {
+    apiKey: string | null;
+    apiVersion: string;
+    baseURL: string;
+    maxRetries: number;
+    timeout: number;
+    logger: Logger;
+    logLevel: LogLevel | undefined;
+    fetchOptions: MergedRequestInit | undefined;
+    private fetch;
+    private encoder;
+    protected idempotencyHeader?: string;
+    private _options;
+    private clientAdapter;
+    /**
+     * API Client for interfacing with the Gemini Next Gen API API.
+     *
+     * @param {string | null | undefined} [opts.apiKey=process.env['GEMINI_API_KEY'] ?? null]
+     * @param {string | undefined} [opts.apiVersion=v1beta]
+     * @param {string} [opts.baseURL=process.env['GEMINI_NEXT_GEN_API_BASE_URL'] ?? https://generativelanguage.googleapis.com] - Override the default base URL for the API.
+     * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+     * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
+     * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+     * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+     * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API.
+     * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
+     */
+    constructor({ baseURL, apiKey, apiVersion, ...opts }: ClientOptions);
+    /**
+     * Create a new client instance re-using the same options given to the current client with optional overriding.
+     */
+    withOptions(options: Partial<ClientOptions>): this;
+    /**
+     * Check whether the base URL is set to its default.
+     */
+    private baseURLOverridden;
+    protected defaultQuery(): Record<string, string | undefined> | undefined;
+    protected validateHeaders({ values, nulls }: NullableHeaders): void;
+    protected authHeaders(opts: FinalRequestOptions): Promise<NullableHeaders | undefined>;
+    /**
+     * Basic re-implementation of `qs.stringify` for primitive types.
+     */
+    protected stringifyQuery(query: Record<string, unknown>): string;
+    private getUserAgent;
+    protected defaultIdempotencyKey(): string;
+    protected makeStatusError(status: number, error: Object, message: string | undefined, headers: Headers): Errors.APIError;
+    buildURL(path: string, query: Record<string, unknown> | null | undefined, defaultBaseURL?: string | undefined): string;
+    /**
+     * Used as a callback for mutating the given `FinalRequestOptions` object.
+
+     */
+    protected prepareOptions(options: FinalRequestOptions): Promise<void>;
+    /**
+     * Used as a callback for mutating the given `RequestInit` object.
+     *
+     * This is useful for cases where you want to add certain headers based off of
+     * the request properties, e.g. `method` or `url`.
+     */
+    protected prepareRequest(request: _RequestInit, { url, options }: {
+        url: string;
+        options: FinalRequestOptions;
+    }): Promise<void>;
+    get<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
+    post<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
+    patch<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
+    put<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
+    delete<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
+    private methodRequest;
+    request<Rsp>(options: PromiseOrValue<FinalRequestOptions>, remainingRetries?: number | null): APIPromise<Rsp>;
+    private makeRequest;
+    fetchWithTimeout(url: _RequestInfo, init: _RequestInit | undefined, ms: number, controller: AbortController): Promise<Response>;
+    private shouldRetry;
+    private retryRequest;
+    private calculateDefaultRetryTimeoutMillis;
+    buildRequest(inputOptions: FinalRequestOptions, { retryCount }?: {
+        retryCount?: number;
+    }): Promise<{
+        req: FinalizedRequestInit;
+        url: string;
+        timeout: number;
+    }>;
+    private buildHeaders;
+    private buildBody;
+    static DEFAULT_TIMEOUT: number;
+}
+
+declare class BaseInteractions extends APIResource {
+    static readonly _key: readonly ['interactions'];
+    /**
+     * Creates a new interaction.
+     *
+     * @example
+     * ```ts
+     * const interaction = await client.interactions.create({
+     *   input: 'string',
+     *   model: 'gemini-2.5-pro',
+     * });
+     * ```
+     */
+    create(params: CreateModelInteractionParamsNonStreaming, options?: RequestOptions): APIPromise<Interaction>;
+    create(params: CreateModelInteractionParamsStreaming, options?: RequestOptions): APIPromise<Stream<InteractionSSEEvent>>;
+    create(params: CreateAgentInteractionParamsNonStreaming, options?: RequestOptions): APIPromise<Interaction>;
+    create(params: CreateAgentInteractionParamsStreaming, options?: RequestOptions): APIPromise<Stream<InteractionSSEEvent>>;
+    create(params: BaseCreateModelInteractionParams | BaseCreateAgentInteractionParams, options?: RequestOptions): APIPromise<Stream<InteractionSSEEvent> | Interaction>;
+    /**
+     * Deletes the interaction by id.
+     *
+     * @example
+     * ```ts
+     * const interaction = await client.interactions.delete('id');
+     * ```
+     */
+    delete(id: string, params?: InteractionDeleteParams | null | undefined, options?: RequestOptions): APIPromise<unknown>;
+    /**
+     * Cancels an interaction by id. This only applies to background interactions that are still running.
+     *
+     * @example
+     * ```ts
+     * const interaction = await client.interactions.cancel('id');
+     * ```
+     */
+    cancel(id: string, params?: InteractionCancelParams | null | undefined, options?: RequestOptions): APIPromise<Interaction>;
+    /**
+     * Retrieves the full details of a single interaction based on its `Interaction.id`.
+     *
+     * @example
+     * ```ts
+     * const interaction = await client.interactions.get('id');
+     * ```
+     */
+    get(id: string, params?: InteractionGetParamsNonStreaming, options?: RequestOptions): APIPromise<Interaction>;
+    get(id: string, params: InteractionGetParamsStreaming, options?: RequestOptions): APIPromise<Stream<InteractionSSEEvent>>;
+    get(id: string, params?: InteractionGetParamsBase | undefined, options?: RequestOptions): APIPromise<Stream<InteractionSSEEvent> | Interaction>;
+}
+
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -705,6 +1111,11 @@ export declare enum BlockedReason {
     JAILBREAK = "JAILBREAK"
 }
 
+declare const brand_privateNullableHeaders: unique symbol;
+
+/** @ts-ignore For users with \@types/bun */
+declare type BunRequestInit = globalThis.FetchRequestInit;
+
 /** A resource used in LLM queries for users to explicitly specify what to cache. */
 export declare interface CachedContent {
     /** The server-generated resource name of the cached content. */
@@ -1101,6 +1512,107 @@ export declare interface CitationMetadata {
     citations?: Citation[];
 }
 
+declare interface ClientOptions {
+    /**
+     * Defaults to process.env['GEMINI_API_KEY'].
+     */
+    apiKey?: string | null | undefined;
+    apiVersion?: string | undefined;
+    /**
+     * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
+     *
+     * Defaults to process.env['GEMINI_NEXT_GEN_API_BASE_URL'].
+     */
+    baseURL?: string | null | undefined;
+    /**
+     * The maximum amount of time (in milliseconds) that the client should wait for a response
+     * from the server before timing out a single request.
+     *
+     * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
+     * much longer than this timeout before the promise succeeds or fails.
+     *
+     * @unit milliseconds
+     */
+    timeout?: number | undefined;
+    /**
+     * Additional `RequestInit` options to be passed to `fetch` calls.
+     * Properties will be overridden by per-request `fetchOptions`.
+     */
+    fetchOptions?: MergedRequestInit | undefined;
+    /**
+     * Specify a custom `fetch` function implementation.
+     *
+     * If not provided, we expect that `fetch` is defined globally.
+     */
+    fetch?: Fetch | undefined;
+    /**
+     * The maximum number of times that the client will retry a request in case of a
+     * temporary failure, like a network error or a 5XX error from the server.
+     *
+     * @default 2
+     */
+    maxRetries?: number | undefined;
+    /**
+     * Default headers to include with every request to the API.
+     *
+     * These can be removed in individual requests by explicitly setting the
+     * header to `null` in request options.
+     */
+    defaultHeaders?: HeadersLike | undefined;
+    /**
+     * Default query parameters to include with every request to the API.
+     *
+     * These can be removed in individual requests by explicitly setting the
+     * param to `undefined` in request options.
+     */
+    defaultQuery?: Record<string, string | undefined> | undefined;
+    /**
+     * Set the log level.
+     *
+     * Defaults to process.env['GEMINI_NEXT_GEN_API_LOG'] or 'warn' if it isn't set.
+     */
+    logLevel?: LogLevel | undefined;
+    /**
+     * Set the logger.
+     *
+     * Defaults to globalThis.console.
+     */
+    logger?: Logger | undefined;
+    /**
+     * The adapter to the parent API client instance (for accessing auth, project, location)
+     */
+    clientAdapter: GeminiNextGenAPIClientAdapter;
+}
+
+/**
+ * The arguments to pass to the code execution.
+ */
+declare interface CodeExecutionCallArguments {
+    /**
+     * The code to be executed.
+     */
+    code?: string;
+    /**
+     * Programming language of the `code`.
+     */
+    language?: 'python';
+}
+
+/**
+ * Code execution content.
+ */
+declare interface CodeExecutionCallContent {
+    type: 'code_execution_call';
+    /**
+     * A unique ID for this specific tool call.
+     */
+    id?: string;
+    /**
+     * The arguments to pass to the code execution.
+     */
+    arguments?: CodeExecutionCallArguments;
+}
+
 /** Result of executing the [ExecutableCode]. Only generated when using the [CodeExecution] tool, and always follows a `part` containing the [ExecutableCode]. */
 export declare interface CodeExecutionResult {
     /** Required. Outcome of the code execution. */
@@ -1109,6 +1621,29 @@ export declare interface CodeExecutionResult {
     output?: string;
 }
 
+/**
+ * Code execution result content.
+ */
+declare interface CodeExecutionResultContent {
+    type: 'code_execution_result';
+    /**
+     * ID to match the ID from the code execution call block.
+     */
+    call_id?: string;
+    /**
+     * Whether the code execution resulted in an error.
+     */
+    is_error?: boolean;
+    /**
+     * The output of the code execution.
+     */
+    result?: string;
+    /**
+     * A signature hash for backend validation.
+     */
+    signature?: string;
+}
+
 /** Success and error statistics of processing multiple entities (for example, DataItems or structured data rows) in batch. This data type is not supported in Gemini API. */
 export declare interface CompletionStats {
     /** Output only. The number of entities for which any error was encountered. */
@@ -1166,6 +1701,13 @@ export declare class ComputeTokensResponse {
     tokensInfo?: TokensInfo[];
 }
 
+declare type _ConditionalNodeReadableStream<R = any> = typeof globalThis extends {
+    ReadableStream: any;
+} ? never : _NodeReadableStream<R>;
+
+declare class ConflictError extends APIError<409, Headers> {
+}
+
 /** Contains the multi-part content of a message. */
 export declare interface Content {
     /** List of parts that constitute a single message. Each part may have
@@ -1175,6 +1717,231 @@ export declare interface Content {
     role?: string;
 }
 
+declare interface ContentDelta {
+    delta?: ContentDelta.TextDelta | ContentDelta.ImageDelta | ContentDelta.AudioDelta | ContentDelta.DocumentDelta | ContentDelta.VideoDelta | ContentDelta.ThoughtSummaryDelta | ContentDelta.ThoughtSignatureDelta | ContentDelta.FunctionCallDelta | ContentDelta.FunctionResultDelta | ContentDelta.CodeExecutionCallDelta | ContentDelta.CodeExecutionResultDelta | ContentDelta.URLContextCallDelta | ContentDelta.URLContextResultDelta | ContentDelta.GoogleSearchCallDelta | ContentDelta.GoogleSearchResultDelta | ContentDelta.MCPServerToolCallDelta | ContentDelta.MCPServerToolResultDelta | ContentDelta.FileSearchResultDelta;
+    /**
+     * The event_id token to be used to resume the interaction stream, from
+     * this event.
+     */
+    event_id?: string;
+    event_type?: 'content.delta';
+    index?: number;
+}
+
+declare namespace ContentDelta {
+    interface TextDelta {
+        type: 'text';
+        /**
+         * Citation information for model-generated content.
+         */
+        annotations?: Array<InteractionsAPI.Annotation>;
+        text?: string;
+    }
+    interface ImageDelta {
+        type: 'image';
+        data?: string;
+        /**
+         * The mime type of the image.
+         */
+        mime_type?: InteractionsAPI.ImageMimeType;
+        /**
+         * The resolution of the media.
+         */
+        resolution?: 'low' | 'medium' | 'high' | 'ultra_high';
+        uri?: string;
+    }
+    interface AudioDelta {
+        type: 'audio';
+        data?: string;
+        /**
+         * The mime type of the audio.
+         */
+        mime_type?: InteractionsAPI.AudioMimeType;
+        uri?: string;
+    }
+    interface DocumentDelta {
+        type: 'document';
+        data?: string;
+        /**
+         * The mime type of the document.
+         */
+        mime_type?: InteractionsAPI.DocumentMimeType;
+        uri?: string;
+    }
+    interface VideoDelta {
+        type: 'video';
+        data?: string;
+        /**
+         * The mime type of the video.
+         */
+        mime_type?: InteractionsAPI.VideoMimeType;
+        /**
+         * The resolution of the media.
+         */
+        resolution?: 'low' | 'medium' | 'high' | 'ultra_high';
+        uri?: string;
+    }
+    interface ThoughtSummaryDelta {
+        type: 'thought_summary';
+        /**
+         * A text content block.
+         */
+        content?: InteractionsAPI.TextContent | InteractionsAPI.ImageContent;
+    }
+    interface ThoughtSignatureDelta {
+        type: 'thought_signature';
+        /**
+         * Signature to match the backend source to be part of the generation.
+         */
+        signature?: string;
+    }
+    interface FunctionCallDelta {
+        type: 'function_call';
+        /**
+         * A unique ID for this specific tool call.
+         */
+        id?: string;
+        arguments?: {
+            [key: string]: unknown;
+        };
+        name?: string;
+    }
+    interface FunctionResultDelta {
+        type: 'function_result';
+        /**
+         * ID to match the ID from the function call block.
+         */
+        call_id?: string;
+        is_error?: boolean;
+        name?: string;
+        /**
+         * Tool call result delta.
+         */
+        result?: FunctionResultDelta.Items | string;
+    }
+    namespace FunctionResultDelta {
+        interface Items {
+            items?: Array<string | InteractionsAPI.ImageContent | unknown>;
+        }
+    }
+    interface CodeExecutionCallDelta {
+        type: 'code_execution_call';
+        /**
+         * A unique ID for this specific tool call.
+         */
+        id?: string;
+        /**
+         * The arguments to pass to the code execution.
+         */
+        arguments?: InteractionsAPI.CodeExecutionCallArguments;
+    }
+    interface CodeExecutionResultDelta {
+        type: 'code_execution_result';
+        /**
+         * ID to match the ID from the function call block.
+         */
+        call_id?: string;
+        is_error?: boolean;
+        result?: string;
+        signature?: string;
+    }
+    interface URLContextCallDelta {
+        type: 'url_context_call';
+        /**
+         * A unique ID for this specific tool call.
+         */
+        id?: string;
+        /**
+         * The arguments to pass to the URL context.
+         */
+        arguments?: InteractionsAPI.URLContextCallArguments;
+    }
+    interface URLContextResultDelta {
+        type: 'url_context_result';
+        /**
+         * ID to match the ID from the function call block.
+         */
+        call_id?: string;
+        is_error?: boolean;
+        result?: Array<InteractionsAPI.URLContextResult>;
+        signature?: string;
+    }
+    interface GoogleSearchCallDelta {
+        type: 'google_search_call';
+        /**
+         * A unique ID for this specific tool call.
+         */
+        id?: string;
+        /**
+         * The arguments to pass to Google Search.
+         */
+        arguments?: InteractionsAPI.GoogleSearchCallArguments;
+    }
+    interface GoogleSearchResultDelta {
+        type: 'google_search_result';
+        /**
+         * ID to match the ID from the function call block.
+         */
+        call_id?: string;
+        is_error?: boolean;
+        result?: Array<InteractionsAPI.GoogleSearchResult>;
+        signature?: string;
+    }
+    interface MCPServerToolCallDelta {
+        type: 'mcp_server_tool_call';
+        /**
+         * A unique ID for this specific tool call.
+         */
+        id?: string;
+        arguments?: {
+            [key: string]: unknown;
+        };
+        name?: string;
+        server_name?: string;
+    }
+    interface MCPServerToolResultDelta {
+        type: 'mcp_server_tool_result';
+        /**
+         * ID to match the ID from the function call block.
+         */
+        call_id?: string;
+        name?: string;
+        /**
+         * Tool call result delta.
+         */
+        result?: MCPServerToolResultDelta.Items | string;
+        server_name?: string;
+    }
+    namespace MCPServerToolResultDelta {
+        interface Items {
+            items?: Array<string | InteractionsAPI.ImageContent | unknown>;
+        }
+    }
+    interface FileSearchResultDelta {
+        type: 'file_search_result';
+        result?: Array<FileSearchResultDelta.Result>;
+    }
+    namespace FileSearchResultDelta {
+        /**
+         * The result of the File Search.
+         */
+        interface Result {
+            /**
+             * The name of the file search store.
+             */
+            file_search_store?: string;
+            /**
+             * The text of the search result.
+             */
+            text?: string;
+            /**
+             * The title of the search result.
+             */
+            title?: string;
+        }
+    }
+}
+
 /** The embedding generated from an input content. */
 export declare interface ContentEmbedding {
     /** A list of floats representing an embedding.
@@ -1215,6 +1982,30 @@ export declare class ContentReferenceImage {
     toReferenceImageAPI(): ReferenceImageAPIInternal;
 }
 
+declare interface ContentStart {
+    /**
+     * The content of the response.
+     */
+    content?: TextContent | ImageContent | AudioContent | DocumentContent | VideoContent | ThoughtContent | FunctionCallContent | FunctionResultContent | CodeExecutionCallContent | CodeExecutionResultContent | URLContextCallContent | URLContextResultContent | GoogleSearchCallContent | GoogleSearchResultContent | MCPServerToolCallContent | MCPServerToolResultContent | FileSearchResultContent;
+    /**
+     * The event_id token to be used to resume the interaction stream, from
+     * this event.
+     */
+    event_id?: string;
+    event_type?: 'content.start';
+    index?: number;
+}
+
+declare interface ContentStop {
+    /**
+     * The event_id token to be used to resume the interaction stream, from
+     * this event.
+     */
+    event_id?: string;
+    event_type?: 'content.stop';
+    index?: number;
+}
+
 export declare type ContentUnion = Content | PartUnion[] | PartUnion;
 
 /** Enables context window compression -- mechanism managing model context window so it does not exceed given length. */
@@ -1310,6 +2101,20 @@ export declare class CountTokensResponse {
     cachedContentTokenCount?: number;
 }
 
+declare interface CreateAgentInteractionParamsNonStreaming extends BaseCreateAgentInteractionParams {
+    /**
+     * Body param: Input only. Whether the interaction will be streamed.
+     */
+    stream?: false;
+}
+
+declare interface CreateAgentInteractionParamsStreaming extends BaseCreateAgentInteractionParams {
+    /**
+     * Body param: Input only. Whether the interaction will be streamed.
+     */
+    stream: true;
+}
+
 /** Optional parameters. */
 export declare interface CreateAuthTokenConfig {
     /** Used to override HTTP request options. */
@@ -1560,6 +2365,20 @@ export declare function createFunctionResponsePartFromUri(uri: string, mimeType:
  */
 export declare function createModelContent(partOrString: PartListUnion | string): Content;
 
+declare interface CreateModelInteractionParamsNonStreaming extends BaseCreateModelInteractionParams {
+    /**
+     * Body param: Input only. Whether the interaction will be streamed.
+     */
+    stream?: false;
+}
+
+declare interface CreateModelInteractionParamsStreaming extends BaseCreateModelInteractionParams {
+    /**
+     * Body param: Input only. Whether the interaction will be streamed.
+     */
+    stream: true;
+}
+
 /**
  * Creates a `Part` object from a `base64` encoded `string`.
  */
@@ -1723,6 +2542,17 @@ export declare interface DatasetStats {
     userOutputTokenDistribution?: DatasetDistribution;
 }
 
+/**
+ * Configuration for the Deep Research agent.
+ */
+declare interface DeepResearchAgentConfig {
+    /**
+     * Whether to include thought summaries in the response.
+     */
+    thinking_summaries?: 'auto' | 'none';
+    type?: 'deep-research';
+}
+
 /** Optional parameters for models.get method. */
 export declare interface DeleteBatchJobConfig {
     /** Used to override HTTP request options. */
@@ -1917,6 +2747,24 @@ declare interface Document_2 {
 }
 export { Document_2 as Document }
 
+/**
+ * A document content block.
+ */
+declare interface DocumentContent {
+    type: 'document';
+    data?: string;
+    /**
+     * The mime type of the document.
+     */
+    mime_type?: DocumentMimeType;
+    uri?: string;
+}
+
+/**
+ * The mime type of the document.
+ */
+declare type DocumentMimeType = (string & {}) | 'application/pdf';
+
 declare class Documents extends BaseModule {
     private readonly apiClient;
     constructor(apiClient: ApiClient);
@@ -1959,6 +2807,9 @@ export declare enum DocumentState {
     STATE_FAILED = "STATE_FAILED"
 }
 
+/** @ts-ignore */
+declare type _DOMReadableStream<R = any> = globalThis.ReadableStream<R>;
+
 export declare type DownloadableFileUnion = string | File_2 | GeneratedVideo | Video;
 
 declare interface Downloader {
@@ -1995,6 +2846,14 @@ export declare interface DownloadFileParameters {
     config?: DownloadFileConfig;
 }
 
+/**
+ * Configuration for dynamic agents.
+ */
+declare interface DynamicAgentConfig {
+    type?: 'dynamic';
+    [k: string]: unknown;
+}
+
 /** Describes the options to customize dynamic retrieval. */
 export declare interface DynamicRetrievalConfig {
     /** The mode of the predictor to be used in dynamic retrieval. */
@@ -2248,6 +3107,53 @@ export declare enum Environment {
     ENVIRONMENT_BROWSER = "ENVIRONMENT_BROWSER"
 }
 
+declare interface ErrorEvent_2 {
+    /**
+     * Error message from an interaction.
+     */
+    error?: ErrorEvent_2.Error;
+    /**
+     * The event_id token to be used to resume the interaction stream, from
+     * this event.
+     */
+    event_id?: string;
+    event_type?: 'error';
+}
+
+declare namespace ErrorEvent_2 {
+    /**
+     * Error message from an interaction.
+     */
+    interface Error {
+        /**
+         * A URI that identifies the error type.
+         */
+        code?: string;
+        /**
+         * A human-readable error message.
+         */
+        message?: string;
+    }
+}
+
+declare namespace Errors {
+    export {
+        GeminiNextGenAPIClientError,
+        APIError,
+        APIUserAbortError,
+        APIConnectionError,
+        APIConnectionTimeoutError,
+        BadRequestError,
+        AuthenticationError,
+        PermissionDeniedError,
+        NotFoundError,
+        ConflictError,
+        UnprocessableEntityError,
+        RateLimitError,
+        InternalServerError
+    }
+}
+
 /** Code generated by the model that is meant to be executed, and the result returned to the model. Generated when using the [CodeExecution] tool, in which the code will be automatically executed, and a corresponding [CodeExecutionResult] will also be generated. */
 export declare interface ExecutableCode {
     /** Required. The code to be executed. */
@@ -2294,6 +3200,13 @@ export declare enum FeatureSelectionPreference {
     PRIORITIZE_COST = "PRIORITIZE_COST"
 }
 
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+declare type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
 export declare interface FetchPredictOperationConfig {
     /** Used to override HTTP request options. */
     httpOptions?: HttpOptions;
@@ -2315,6 +3228,9 @@ export declare interface FetchPredictOperationParameters {
     config?: FetchPredictOperationConfig;
 }
 
+/** @ts-ignore For users who use Deno */
+declare type FetchRequestInit = NonNullable<OverloadedParameters<typeof fetch>[1]>;
+
 /** 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` */
@@ -2482,6 +3398,37 @@ export declare interface FileSearch {
     metadataFilter?: string;
 }
 
+/**
+ * File Search result content.
+ */
+declare interface FileSearchResultContent {
+    type: 'file_search_result';
+    /**
+     * The results of the File Search.
+     */
+    result?: Array<FileSearchResultContent.Result>;
+}
+
+declare namespace FileSearchResultContent {
+    /**
+     * The result of the File Search.
+     */
+    interface Result {
+        /**
+         * The name of the file search store.
+         */
+        file_search_store?: string;
+        /**
+         * The text of the search result.
+         */
+        text?: string;
+        /**
+         * The title of the search result.
+         */
+        title?: string;
+    }
+}
+
 /** A collection of Documents. */
 export declare interface FileSearchStore {
     /** The resource name of the FileSearchStore. Example: `fileSearchStores/my-file-search-store-123` */
@@ -2634,6 +3581,15 @@ export declare interface FileStatus {
     code?: number;
 }
 
+declare type FinalizedRequestInit = RequestInit & {
+    headers: Headers;
+};
+
+declare type FinalRequestOptions = RequestOptions & {
+    method: HTTPMethod;
+    path: string;
+};
+
 /** Output only. The reason why the model stopped generating tokens.
 
  If empty, the model has not stopped generating the tokens. */
@@ -2697,7 +3653,34 @@ export declare enum FinishReason {
     /**
      * The model was expected to generate an image, but none was generated.
      */
-    NO_IMAGE = "NO_IMAGE"
+    NO_IMAGE = "NO_IMAGE",
+    /**
+     * Image generation stopped because the generated image may be a recitation from a source.
+     */
+    IMAGE_RECITATION = "IMAGE_RECITATION",
+    /**
+     * Image generation stopped for a reason not otherwise specified.
+     */
+    IMAGE_OTHER = "IMAGE_OTHER"
+}
+
+/**
+ * A tool that can be used by the model.
+ */
+declare interface Function_2 {
+    type: 'function';
+    /**
+     * A description of the function.
+     */
+    description?: string;
+    /**
+     * The name of the function.
+     */
+    name?: string;
+    /**
+     * The JSON Schema for the function's parameters.
+     */
+    parameters?: unknown;
 }
 
 /** A function call. */
@@ -2715,6 +3698,27 @@ export declare interface FunctionCall {
     willContinue?: boolean;
 }
 
+/**
+ * A function tool call content block.
+ */
+declare interface FunctionCallContent {
+    /**
+     * A unique ID for this specific tool call.
+     */
+    id: string;
+    /**
+     * The arguments to pass to the function.
+     */
+    arguments: {
+        [key: string]: unknown;
+    };
+    /**
+     * The name of the tool to call.
+     */
+    name: string;
+    type: 'function_call';
+}
+
 /** Function calling config. */
 export declare interface FunctionCallingConfig {
     /** Optional. Function calling mode. */
@@ -2849,6 +3853,55 @@ export declare enum FunctionResponseScheduling {
     INTERRUPT = "INTERRUPT"
 }
 
+/**
+ * A function tool result content block.
+ */
+declare interface FunctionResultContent {
+    /**
+     * ID to match the ID from the function call block.
+     */
+    call_id: string;
+    /**
+     * The result of the tool call.
+     */
+    result: FunctionResultContent.Items | unknown | string;
+    type: 'function_result';
+    /**
+     * Whether the tool call resulted in an error.
+     */
+    is_error?: boolean;
+    /**
+     * The name of the tool that was called.
+     */
+    name?: string;
+}
+
+declare namespace FunctionResultContent {
+    interface Items {
+        items?: Array<string | InteractionsAPI.ImageContent | unknown>;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+declare interface GeminiNextGenAPIClientAdapter {
+    isVertexAI: () => boolean;
+    getProject: () => string | undefined;
+    getLocation: () => string | undefined;
+    getAuthHeaders: () => Headers | Promise<Headers>;
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+declare class GeminiNextGenAPIClientError extends Error {
+}
+
 /** Input example for preference optimization. This data type is not supported in Gemini API. */
 export declare interface GeminiPreferenceExample {
     /** List of completions for a given prompt. */
@@ -3504,6 +4557,48 @@ export declare interface GenerationConfig {
     enableEnhancedCivicAnswers?: boolean;
 }
 
+/**
+ * Configuration parameters for model interactions.
+ */
+declare interface GenerationConfig_2 {
+    /**
+     * The maximum number of tokens to include in the response.
+     */
+    max_output_tokens?: number;
+    /**
+     * Seed used in decoding for reproducibility.
+     */
+    seed?: number;
+    /**
+     * Configuration for speech interaction.
+     */
+    speech_config?: Array<SpeechConfig_2>;
+    /**
+     * A list of character sequences that will stop output interaction.
+     */
+    stop_sequences?: Array<string>;
+    /**
+     * Controls the randomness of the output.
+     */
+    temperature?: number;
+    /**
+     * The level of thought tokens that the model should generate.
+     */
+    thinking_level?: ThinkingLevel_2;
+    /**
+     * Whether to include thought summaries in the response.
+     */
+    thinking_summaries?: 'auto' | 'none';
+    /**
+     * The tool choice for the interaction.
+     */
+    tool_choice?: ToolChoice;
+    /**
+     * The maximum cumulative probability of tokens to consider when sampling.
+     */
+    top_p?: number;
+}
+
 /** The configuration for routing the request to a specific model. This data type is not supported in Gemini API. */
 export declare interface GenerationConfigRoutingConfig {
     /** Automated routing. */
@@ -3761,6 +4856,8 @@ export declare class GoogleGenAI {
     readonly authTokens: Tokens;
     readonly tunings: Tunings;
     readonly fileSearchStores: FileSearchStores;
+    private _interactions;
+    get interactions(): Interactions;
     constructor(options: GoogleGenAIOptions);
 }
 
@@ -3855,6 +4952,72 @@ export declare interface GoogleSearch {
     timeRangeFilter?: Interval;
 }
 
+/**
+ * The arguments to pass to Google Search.
+ */
+declare interface GoogleSearchCallArguments {
+    /**
+     * Web search queries for the following-up web search.
+     */
+    queries?: Array<string>;
+}
+
+/**
+ * Google Search content.
+ */
+declare interface GoogleSearchCallContent {
+    type: 'google_search_call';
+    /**
+     * A unique ID for this specific tool call.
+     */
+    id?: string;
+    /**
+     * The arguments to pass to Google Search.
+     */
+    arguments?: GoogleSearchCallArguments;
+}
+
+/**
+ * The result of the Google Search.
+ */
+declare interface GoogleSearchResult {
+    /**
+     * Web content snippet that can be embedded in a web page or an app webview.
+     */
+    rendered_content?: string;
+    /**
+     * Title of the search result.
+     */
+    title?: string;
+    /**
+     * URI reference of the search result.
+     */
+    url?: string;
+}
+
+/**
+ * Google Search result content.
+ */
+declare interface GoogleSearchResultContent {
+    type: 'google_search_result';
+    /**
+     * ID to match the ID from the google search call block.
+     */
+    call_id?: string;
+    /**
+     * Whether the Google Search resulted in an error.
+     */
+    is_error?: boolean;
+    /**
+     * The results of the Google Search.
+     */
+    result?: Array<GoogleSearchResult>;
+    /**
+     * The signature of the Google Search result.
+     */
+    signature?: string;
+}
+
 /** Tool to retrieve public web data for grounding, powered by Google. */
 export declare interface GoogleSearchRetrieval {
     /** Specifies the dynamic retrieval configuration for the given source. */
@@ -4133,6 +5296,15 @@ export declare enum HarmSeverity {
     HARM_SEVERITY_HIGH = "HARM_SEVERITY_HIGH"
 }
 
+declare type HeadersLike = Headers | readonly HeaderValue[][] | Record<string, HeaderValue | readonly HeaderValue[]> | undefined | null | NullableHeaders;
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+declare type HeaderValue = string | undefined | null;
+
 /** The location of the API key. This enum is not supported in Gemini API. */
 export declare enum HttpElementLocation {
     HTTP_IN_UNSPECIFIED = "HTTP_IN_UNSPECIFIED",
@@ -4158,6 +5330,8 @@ export declare enum HttpElementLocation {
     HTTP_IN_COOKIE = "HTTP_IN_COOKIE"
 }
 
+declare type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+
 /** HTTP options to be used in each of the requests. */
 export declare interface HttpOptions {
     /** The base URL for the AI platform service endpoint. */
@@ -4267,6 +5441,28 @@ export declare interface ImageConfig {
     outputCompressionQuality?: number;
 }
 
+/**
+ * An image content block.
+ */
+declare interface ImageContent {
+    type: 'image';
+    data?: string;
+    /**
+     * The mime type of the image.
+     */
+    mime_type?: ImageMimeType;
+    /**
+     * The resolution of the media.
+     */
+    resolution?: 'low' | 'medium' | 'high' | 'ultra_high';
+    uri?: string;
+}
+
+/**
+ * The mime type of the image.
+ */
+declare type ImageMimeType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/heic' | 'image/heif' | (string & {});
+
 /** Enum that specifies the language of the text in the prompt. */
 export declare enum ImagePromptLanguage {
     /**
@@ -4396,6 +5592,218 @@ export declare class InlinedResponse {
     error?: JobError;
 }
 
+/**
+ * The Interaction resource.
+ */
+declare interface Interaction {
+    /**
+     * Output only. A unique identifier for the interaction completion.
+     */
+    id: string;
+    /**
+     * Output only. The status of the interaction.
+     */
+    status: 'in_progress' | 'requires_action' | 'completed' | 'failed' | 'cancelled';
+    /**
+     * The name of the `Agent` used for generating the interaction.
+     */
+    agent?: (string & {}) | 'deep-research-pro-preview-12-2025';
+    /**
+     * Output only. The time at which the response was created in ISO 8601 format
+     * (YYYY-MM-DDThh:mm:ssZ).
+     */
+    created?: string;
+    /**
+     * The name of the `Model` used for generating the interaction.
+     */
+    model?: Model_2;
+    /**
+     * Output only. The object type of the interaction. Always set to `interaction`.
+     */
+    object?: 'interaction';
+    /**
+     * Output only. Responses from the model.
+     */
+    outputs?: Array<TextContent | ImageContent | AudioContent | DocumentContent | VideoContent | ThoughtContent | FunctionCallContent | FunctionResultContent | CodeExecutionCallContent | CodeExecutionResultContent | URLContextCallContent | URLContextResultContent | GoogleSearchCallContent | GoogleSearchResultContent | MCPServerToolCallContent | MCPServerToolResultContent | FileSearchResultContent>;
+    /**
+     * The ID of the previous interaction, if any.
+     */
+    previous_interaction_id?: string;
+    /**
+     * Output only. The role of the interaction.
+     */
+    role?: string;
+    /**
+     * Output only. The time at which the response was last updated in ISO 8601 format
+     * (YYYY-MM-DDThh:mm:ssZ).
+     */
+    updated?: string;
+    /**
+     * Output only. Statistics on the interaction request's token usage.
+     */
+    usage?: Usage;
+}
+
+declare interface InteractionCancelParams {
+    /**
+     * Which version of the API to use.
+     */
+    api_version?: string;
+}
+
+declare type InteractionCreateParams = CreateModelInteractionParamsNonStreaming | CreateModelInteractionParamsStreaming | CreateAgentInteractionParamsNonStreaming | CreateAgentInteractionParamsStreaming;
+
+declare interface InteractionDeleteParams {
+    /**
+     * Which version of the API to use.
+     */
+    api_version?: string;
+}
+
+declare type InteractionDeleteResponse = unknown;
+
+declare interface InteractionEvent {
+    /**
+     * The event_id token to be used to resume the interaction stream, from
+     * this event.
+     */
+    event_id?: string;
+    event_type?: 'interaction.start' | 'interaction.complete';
+    /**
+     * The Interaction resource.
+     */
+    interaction?: Interaction;
+}
+
+declare type InteractionGetParams = InteractionGetParamsNonStreaming | InteractionGetParamsStreaming;
+
+declare namespace InteractionGetParams {
+    type InteractionGetParamsNonStreaming = InteractionsAPI.InteractionGetParamsNonStreaming;
+    type InteractionGetParamsStreaming = InteractionsAPI.InteractionGetParamsStreaming;
+}
+
+declare interface InteractionGetParamsBase {
+    /**
+     * Path param: Which version of the API to use.
+     */
+    api_version?: string;
+    /**
+     * Query param: Optional. If set, resumes the interaction stream from the next chunk after the event marked by the event id. Can only be used if `stream` is true.
+     */
+    last_event_id?: string;
+    /**
+     * Query param: If set to true, the generated content will be streamed incrementally.
+     */
+    stream?: boolean;
+}
+
+declare interface InteractionGetParamsNonStreaming extends InteractionGetParamsBase {
+    /**
+     * Query param: If set to true, the generated content will be streamed incrementally.
+     */
+    stream?: false;
+}
+
+declare interface InteractionGetParamsStreaming extends InteractionGetParamsBase {
+    /**
+     * Query param: If set to true, the generated content will be streamed incrementally.
+     */
+    stream: true;
+}
+
+export declare class Interactions extends BaseInteractions {
+}
+
+export declare namespace Interactions {
+    export { type AllowedTools as AllowedTools, type Annotation as Annotation, type AudioContent as AudioContent, type AudioMimeType as AudioMimeType, type CodeExecutionCallArguments as CodeExecutionCallArguments, type CodeExecutionCallContent as CodeExecutionCallContent, type CodeExecutionResultContent as CodeExecutionResultContent, type ContentDelta as ContentDelta, type ContentStart as ContentStart, type ContentStop as ContentStop, type DeepResearchAgentConfig as DeepResearchAgentConfig, type DocumentContent as DocumentContent, type DocumentMimeType as DocumentMimeType, type DynamicAgentConfig as DynamicAgentConfig, type ErrorEvent_2 as ErrorEvent, type FileSearchResultContent as FileSearchResultContent, type Function_2 as Function, type FunctionCallContent as FunctionCallContent, type FunctionResultContent as FunctionResultContent, type GenerationConfig_2 as GenerationConfig, type GoogleSearchCallArguments as GoogleSearchCallArguments, type GoogleSearchCallContent as GoogleSearchCallContent, type GoogleSearchResult as GoogleSearchResult, type GoogleSearchResultContent as GoogleSearchResultContent, type ImageContent as ImageContent, type ImageMimeType as ImageMimeType, type Interaction as Interaction, type InteractionEvent as InteractionEvent, type InteractionSSEEvent as InteractionSSEEvent, type InteractionStatusUpdate as InteractionStatusUpdate, type MCPServerToolCallContent as MCPServerToolCallContent, type MCPServerToolResultContent as MCPServerToolResultContent, type Model_2 as Model, type SpeechConfig_2 as SpeechConfig, type TextContent as TextContent, type ThinkingLevel_2 as ThinkingLevel, type ThoughtContent as ThoughtContent, type Tool_2 as Tool, type ToolChoice as ToolChoice, type ToolChoiceConfig as ToolChoiceConfig, type ToolChoiceType as ToolChoiceType, type Turn as Turn, type URLContextCallArguments as URLContextCallArguments, type URLContextCallContent as URLContextCallContent, type URLContextResult as URLContextResult, type URLContextResultContent as URLContextResultContent, type Usage as Usage, type VideoContent as VideoContent, type VideoMimeType as VideoMimeType, type InteractionDeleteResponse as InteractionDeleteResponse, type InteractionCreateParams as InteractionCreateParams, type CreateModelInteractionParamsNonStreaming as CreateModelInteractionParamsNonStreaming, type CreateModelInteractionParamsStreaming as CreateModelInteractionParamsStreaming, type CreateAgentInteractionParamsNonStreaming as CreateAgentInteractionParamsNonStreaming, type CreateAgentInteractionParamsStreaming as CreateAgentInteractionParamsStreaming, type InteractionDeleteParams as InteractionDeleteParams, type InteractionCancelParams as InteractionCancelParams, type InteractionGetParams as InteractionGetParams, type InteractionGetParamsNonStreaming as InteractionGetParamsNonStreaming, type InteractionGetParamsStreaming as InteractionGetParamsStreaming, };
+}
+
+declare namespace InteractionsAPI {
+    export {
+        BaseInteractions,
+        Interactions,
+        AllowedTools,
+        Annotation,
+        AudioContent,
+        AudioMimeType,
+        CodeExecutionCallArguments,
+        CodeExecutionCallContent,
+        CodeExecutionResultContent,
+        ContentDelta,
+        ContentStart,
+        ContentStop,
+        DeepResearchAgentConfig,
+        DocumentContent,
+        DocumentMimeType,
+        DynamicAgentConfig,
+        ErrorEvent_2 as ErrorEvent,
+        FileSearchResultContent,
+        Function_2 as Function,
+        FunctionCallContent,
+        FunctionResultContent,
+        GenerationConfig_2 as GenerationConfig,
+        GoogleSearchCallArguments,
+        GoogleSearchCallContent,
+        GoogleSearchResult,
+        GoogleSearchResultContent,
+        ImageContent,
+        ImageMimeType,
+        Interaction,
+        InteractionEvent,
+        InteractionSSEEvent,
+        InteractionStatusUpdate,
+        MCPServerToolCallContent,
+        MCPServerToolResultContent,
+        Model_2 as Model,
+        SpeechConfig_2 as SpeechConfig,
+        TextContent,
+        ThinkingLevel_2 as ThinkingLevel,
+        ThoughtContent,
+        Tool_2 as Tool,
+        ToolChoice,
+        ToolChoiceConfig,
+        ToolChoiceType,
+        Turn,
+        URLContextCallArguments,
+        URLContextCallContent,
+        URLContextResult,
+        URLContextResultContent,
+        Usage,
+        VideoContent,
+        VideoMimeType,
+        InteractionDeleteResponse,
+        InteractionCreateParams,
+        BaseCreateModelInteractionParams,
+        BaseCreateAgentInteractionParams,
+        CreateModelInteractionParamsNonStreaming,
+        CreateModelInteractionParamsStreaming,
+        CreateAgentInteractionParamsNonStreaming,
+        CreateAgentInteractionParamsStreaming,
+        InteractionDeleteParams,
+        InteractionCancelParams,
+        InteractionGetParams,
+        InteractionGetParamsBase,
+        InteractionGetParamsNonStreaming,
+        InteractionGetParamsStreaming
+    }
+}
+
+declare type InteractionSSEEvent = InteractionEvent | InteractionStatusUpdate | ContentStart | ContentDelta | ContentStop | ErrorEvent_2;
+
+declare interface InteractionStatusUpdate {
+    /**
+     * The event_id token to be used to resume the interaction stream, from
+     * this event.
+     */
+    event_id?: string;
+    event_type?: 'interaction.status_update';
+    interaction_id?: string;
+    status?: 'in_progress' | 'requires_action' | 'completed' | 'failed' | 'cancelled';
+}
+
+declare class InternalServerError extends APIError<number, Headers> {
+}
+
 /** Represents a time interval, encoded as a Timestamp start (inclusive) and a Timestamp end (exclusive). The start must be less than or equal to the end. When the start equals the end, the interval is empty (matches no time). When both start and end are unspecified, the interval matches any time. */
 export declare interface Interval {
     /** Optional. Exclusive end of the interval. If specified, a Timestamp matching this interval will have to be before the end. */
@@ -4892,6 +6300,10 @@ export declare interface LiveClientSetup {
     /** Configures the proactivity of the model. This allows the model to respond proactively to
      the input and to ignore irrelevant input. */
     proactivity?: ProactivityConfig;
+    /** Configures the explicit VAD signal. If enabled, the client will send
+     vad_signal to indicate the start and end of speech. This allows the server
+     to process the audio more efficiently. */
+    explicitVadSignal?: boolean;
 }
 
 /** Client generated response to a `ToolCall` received from the server.
@@ -4994,6 +6406,10 @@ export declare interface LiveConnectConfig {
     /** Configures the proactivity of the model. This allows the model to respond proactively to
      the input and to ignore irrelevant input. */
     proactivity?: ProactivityConfig;
+    /** Configures the explicit VAD signal. If enabled, the client will send
+     vad_signal to indicate the start and end of speech. This allows the server
+     to process the audio more efficiently. */
+    explicitVadSignal?: boolean;
 }
 
 /** Config for LiveConnectConstraints for Auth Token creation. */
@@ -5404,6 +6820,8 @@ export declare class LiveServerMessage {
     goAway?: LiveServerGoAway;
     /** Update of the session resumption state. */
     sessionResumptionUpdate?: LiveServerSessionResumptionUpdate;
+    /** Voice activity detection signal. */
+    voiceActivityDetectionSignal?: VoiceActivityDetectionSignal;
     /**
      * Returns the concatenation of all text parts from the server content if present.
      *
@@ -5461,6 +6879,17 @@ export declare interface LiveServerToolCallCancellation {
     ids?: string[];
 }
 
+declare type LogFn = (message: string, ...rest: unknown[]) => void;
+
+declare type Logger = {
+    error: LogFn;
+    warn: LogFn;
+    info: LogFn;
+    debug: LogFn;
+};
+
+declare type LogLevel = 'off' | 'error' | 'warn' | 'info' | 'debug';
+
 /** Logprobs Result */
 export declare interface LogprobsResult {
     /** Length = total number of decoding steps. The chosen candidates may or may not be in top_candidates. */
@@ -5529,6 +6958,60 @@ export declare enum MaskReferenceMode {
     MASK_MODE_SEMANTIC = "MASK_MODE_SEMANTIC"
 }
 
+/**
+ * MCPServer tool call content.
+ */
+declare interface MCPServerToolCallContent {
+    /**
+     * A unique ID for this specific tool call.
+     */
+    id: string;
+    /**
+     * The JSON object of arguments for the function.
+     */
+    arguments: {
+        [key: string]: unknown;
+    };
+    /**
+     * The name of the tool which was called.
+     */
+    name: string;
+    /**
+     * The name of the used MCP server.
+     */
+    server_name: string;
+    type: 'mcp_server_tool_call';
+}
+
+/**
+ * MCPServer tool result content.
+ */
+declare interface MCPServerToolResultContent {
+    /**
+     * ID to match the ID from the MCP server tool call block.
+     */
+    call_id: string;
+    /**
+     * The result of the tool call.
+     */
+    result: MCPServerToolResultContent.Items | unknown | string;
+    type: 'mcp_server_tool_result';
+    /**
+     * Name of the tool which is called for this specific tool call.
+     */
+    name?: string;
+    /**
+     * The name of the used MCP server.
+     */
+    server_name?: string;
+}
+
+declare namespace MCPServerToolResultContent {
+    interface Items {
+        items?: Array<string | InteractionsAPI.ImageContent | unknown>;
+    }
+}
+
 /**
  * Creates a McpCallableTool from MCP clients and an optional config.
  *
@@ -5589,6 +7072,14 @@ export declare enum MediaResolution {
     MEDIA_RESOLUTION_HIGH = "MEDIA_RESOLUTION_HIGH"
 }
 
+/**
+ * This type contains `RequestInit` options that may be available on the current runtime,
+ * including per-platform extensions like `dispatcher`, `agent`, `client`, etc.
+ */
+declare type MergedRequestInit = RequestInits & 
+/** We don't include these in the types as they'll be overridden for every request. */
+Partial<Record<'body' | 'headers' | 'method' | 'signal', never>>;
+
 /** Server content modalities. */
 export declare enum Modality {
     /**
@@ -5684,6 +7175,11 @@ export declare interface Model {
     thinking?: boolean;
 }
 
+/**
+ * The model that will complete your prompt.\n\nSee [models](https://ai.google.dev/gemini-api/docs/models) for additional details.
+ */
+declare type Model_2 = 'gemini-2.5-pro' | 'gemini-2.5-flash' | 'gemini-2.5-flash-preview-09-2025' | 'gemini-2.5-flash-lite' | 'gemini-2.5-flash-lite-preview-09-2025' | 'gemini-2.5-flash-preview-native-audio-dialog' | 'gemini-2.5-flash-image-preview' | 'gemini-2.5-pro-preview-tts' | 'gemini-3-pro-preview' | (string & {});
+
 export declare class Models extends BaseModule {
     private readonly apiClient;
     constructor(apiClient: ApiClient);
@@ -6058,9 +7554,9 @@ export declare interface ModelSelectionConfig {
     featureSelectionPreference?: FeatureSelectionPreference;
 }
 
-/** The configuration for the multi-speaker setup. This data type is not supported in Vertex AI. */
+/** Configuration for a multi-speaker text-to-speech request. */
 export declare interface MultiSpeakerVoiceConfig {
-    /** Required. All the enabled speaker voices. */
+    /** Required. A list of configurations for the voices of the speakers. Exactly two speaker voice configurations must be provided. */
     speakerVoiceConfigs?: SpeakerVoiceConfig[];
 }
 
@@ -6087,6 +7583,48 @@ export declare enum MusicGenerationMode {
     VOCALIZATION = "VOCALIZATION"
 }
 
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/// <reference types="node" />
+/**
+ * Shims for types that we can't always rely on being available globally.
+ *
+ * Note: these only exist at the type-level, there is no corresponding runtime
+ * version for any of these symbols.
+ */
+declare type NeverToAny<T> = T extends never ? any : T;
+
+/** @ts-ignore For users with node-fetch@2 */
+declare type NodeFetch2RequestInit = NotAny<import('../node_modules/@types/node-fetch/index.d.ts').RequestInit> | NotAny<import('../../node_modules/@types/node-fetch/index.d.ts').RequestInit> | NotAny<import('../../../node_modules/@types/node-fetch/index.d.ts').RequestInit> | NotAny<import('../../../../node_modules/@types/node-fetch/index.d.ts').RequestInit> | NotAny<import('../../../../../node_modules/@types/node-fetch/index.d.ts').RequestInit> | NotAny<import('../../../../../../node_modules/@types/node-fetch/index.d.ts').RequestInit> | NotAny<import('../../../../../../../node_modules/@types/node-fetch/index.d.ts').RequestInit> | NotAny<import('../../../../../../../../node_modules/@types/node-fetch/index.d.ts').RequestInit> | NotAny<import('../../../../../../../../../node_modules/@types/node-fetch/index.d.ts').RequestInit> | NotAny<import('../../../../../../../../../../node_modules/@types/node-fetch/index.d.ts').RequestInit>;
+
+/** @ts-ignore For users with node-fetch@3, doesn't need file extension because types are at ./@types/index.d.ts */
+declare type NodeFetch3RequestInit = NotAny<import('../node_modules/node-fetch').RequestInit> | NotAny<import('../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../../../../node_modules/node-fetch').RequestInit> | NotAny<import('../../../../../../../../../../node_modules/node-fetch').RequestInit>;
+
+/** @ts-ignore */
+declare type _NodeReadableStream<R = any> = ReadableStream_2<R>;
+
+declare type NotAny<T> = [0] extends [1 & T] ? never : T;
+
+declare class NotFoundError extends APIError<404, Headers> {
+}
+
+/**
+ * @internal
+ * Users can pass explicit nulls to unset default headers. When we parse them
+ * into a standard headers type we need to preserve that information.
+ */
+declare type NullableHeaders = {
+    /** Brand check, prevent users from creating a NullableHeaders. */
+    [brand_privateNullableHeaders]: true;
+    /** Parsed headers. */
+    values: Headers;
+    /** Set of lowercase header names explicitly set to null. */
+    nulls: Set<string>;
+};
+
 /** A long-running operation. */
 export declare interface Operation<T> {
     /** 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}`. */
@@ -6163,6 +7701,23 @@ export declare enum Outcome {
     OUTCOME_DEADLINE_EXCEEDED = "OUTCOME_DEADLINE_EXCEEDED"
 }
 
+/**
+ * Some environments overload the global fetch function, and Parameters<T> only gets the last signature.
+ */
+declare type OverloadedParameters<T> = T extends ({
+    (...args: infer A): unknown;
+    (...args: infer B): unknown;
+    (...args: infer C): unknown;
+    (...args: infer D): unknown;
+}) ? A | B | C | D : T extends ({
+    (...args: infer A): unknown;
+    (...args: infer B): unknown;
+    (...args: infer C): unknown;
+}) ? A | B | C : T extends ({
+    (...args: infer A): unknown;
+    (...args: infer B): unknown;
+}) ? A | B : T extends (...args: infer A) => unknown ? A : never;
+
 export declare enum PagedItem {
     PAGED_ITEM_BATCH_JOBS = "batchJobs",
     PAGED_ITEM_MODELS = "models",
@@ -6370,7 +7925,11 @@ export declare enum PartMediaResolutionLevel {
     /**
      * Media resolution set to high.
      */
-    MEDIA_RESOLUTION_HIGH = "MEDIA_RESOLUTION_HIGH"
+    MEDIA_RESOLUTION_HIGH = "MEDIA_RESOLUTION_HIGH",
+    /**
+     * Media resolution set to ultra high.
+     */
+    MEDIA_RESOLUTION_ULTRA_HIGH = "MEDIA_RESOLUTION_ULTRA_HIGH"
 }
 
 /** Tuning spec for Partner models. This data type is not supported in Gemini API. */
@@ -6385,6 +7944,9 @@ export declare interface PartnerModelTuningSpec {
 
 export declare type PartUnion = Part | string;
 
+declare class PermissionDeniedError extends APIError<403, Headers> {
+}
+
 /** Enum that controls the generation of people. */
 export declare enum PersonGeneration {
     /**
@@ -6507,6 +8069,13 @@ export declare interface ProductImage {
     productImage?: Image_2;
 }
 
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+declare type PromiseOrValue<T> = T | Promise<T>;
+
 /** A RagChunk includes the content of a chunk of a RagFile, and associated metadata. This data type is not supported in Gemini API. */
 export declare interface RagChunk {
     /** If populated, represents where the chunk starts and ends in the document. */
@@ -6571,6 +8140,9 @@ export declare interface RagRetrievalConfigRankingRankService {
     modelName?: string;
 }
 
+declare class RateLimitError extends APIError<429, Headers> {
+}
+
 /** A raw reference image.
 
  A raw reference image represents the base image to edit, provided by the user.
@@ -6587,6 +8159,8 @@ export declare class RawReferenceImage {
     toReferenceImageAPI(): ReferenceImageAPIInternal;
 }
 
+declare type _ReadableStream_2<R = any> = NeverToAny<([0] extends [1 & _DOMReadableStream<R>] ? never : _DOMReadableStream<R>) | ([0] extends [1 & _ConditionalNodeReadableStream<R>] ? never : _ConditionalNodeReadableStream<R>)>;
+
 /** Marks the end of user activity.
 
  This can only be sent if automatic (i.e. server-side) activity detection is
@@ -6726,6 +8300,82 @@ export declare interface ReplicatedVoiceConfig {
     voiceSampleAudio?: string;
 }
 
+/**
+ * The type for the first argument to `fetch`.
+ *
+ * https://developer.mozilla.org/docs/Web/API/Window/fetch#resource
+ */
+declare type _RequestInfo = Request | URL | string;
+
+/**
+ * An alias to the builtin `RequestInit` type so we can
+ * easily alias it in import statements if there are name clashes.
+ *
+ * https://developer.mozilla.org/docs/Web/API/RequestInit
+ */
+declare type _RequestInit = RequestInit;
+
+declare type RequestInits = NotAny<UndiciTypesRequestInit> | NotAny<UndiciRequestInit> | NotAny<BunRequestInit> | NotAny<NodeFetch2RequestInit> | NotAny<NodeFetch3RequestInit> | NotAny<RequestInit> | NotAny<FetchRequestInit>;
+
+declare type RequestOptions = {
+    /**
+     * The HTTP method for the request (e.g., 'get', 'post', 'put', 'delete').
+     */
+    method?: HTTPMethod;
+    /**
+     * The URL path for the request.
+     *
+     * @example "/v1/foo"
+     */
+    path?: string;
+    /**
+     * Query parameters to include in the request URL.
+     */
+    query?: object | undefined | null;
+    /**
+     * The request body. Can be a string, JSON object, FormData, or other supported types.
+     */
+    body?: unknown;
+    /**
+     * HTTP headers to include with the request. Can be a Headers object, plain object, or array of tuples.
+     */
+    headers?: HeadersLike;
+    /**
+     * The maximum number of times that the client will retry a request in case of a
+     * temporary failure, like a network error or a 5XX error from the server.
+     *
+     * @default 2
+     */
+    maxRetries?: number;
+    stream?: boolean | undefined;
+    /**
+     * The maximum amount of time (in milliseconds) that the client should wait for a response
+     * from the server before timing out a single request.
+     *
+     * @unit milliseconds
+     */
+    timeout?: number;
+    /**
+     * Additional `RequestInit` options to be passed to the underlying `fetch` call.
+     * These options will be merged with the client's default fetch options.
+     */
+    fetchOptions?: MergedRequestInit;
+    /**
+     * An AbortSignal that can be used to cancel the request.
+     */
+    signal?: AbortSignal | undefined | null;
+    /**
+     * A unique key for this request to enable idempotency.
+     */
+    idempotencyKey?: string;
+    /**
+     * Override the default base URL for this specific request.
+     */
+    defaultBaseURL?: string | undefined;
+    __binaryResponse?: boolean | undefined;
+    __streamClass?: typeof Stream;
+};
+
 /** Defines a retrieval tool that model can call to access external knowledge. This data type is not supported in Gemini API. */
 export declare interface Retrieval {
     /** Optional. Deprecated. This option is no longer supported. */
@@ -7221,10 +8871,28 @@ export declare interface SpeechConfig {
     voiceConfig?: VoiceConfig;
     /** Optional. Language code (ISO 639. e.g. en-US) for the speech synthesization. */
     languageCode?: string;
-    /** Optional. The configuration for the multi-speaker setup. It is mutually exclusive with the voice_config field. This field is not supported in Vertex AI. */
+    /** The configuration for a multi-speaker text-to-speech request. This field is mutually exclusive with `voice_config`. */
     multiSpeakerVoiceConfig?: MultiSpeakerVoiceConfig;
 }
 
+/**
+ * The configuration for speech interaction.
+ */
+declare interface SpeechConfig_2 {
+    /**
+     * The language of the speech.
+     */
+    language?: string;
+    /**
+     * The speaker's name, it should match the speaker name given in the prompt.
+     */
+    speaker?: string;
+    /**
+     * The voice of the speaker.
+     */
+    voice?: string;
+}
+
 export declare type SpeechConfigUnion = SpeechConfig | string;
 
 /** Start of speech sensitivity. */
@@ -7243,6 +8911,31 @@ export declare enum StartSensitivity {
     START_SENSITIVITY_LOW = "START_SENSITIVITY_LOW"
 }
 
+declare class Stream<Item> implements AsyncIterable<Item> {
+    private iterator;
+    controller: AbortController;
+    private client;
+    constructor(iterator: () => AsyncIterator<Item>, controller: AbortController, client?: BaseGeminiNextGenAPIClient);
+    static fromSSEResponse<Item>(response: Response, controller: AbortController, client?: BaseGeminiNextGenAPIClient): Stream<Item>;
+    /**
+     * Generates a Stream from a newline-separated ReadableStream
+     * where each item is a JSON value.
+     */
+    static fromReadableStream<Item>(readableStream: _ReadableStream_2, controller: AbortController, client?: BaseGeminiNextGenAPIClient): Stream<Item>;
+    [Symbol.asyncIterator](): AsyncIterator<Item>;
+    /**
+     * Splits the stream into two streams which can be
+     * independently read from at different speeds.
+     */
+    tee(): [Stream<Item>, Stream<Item>];
+    /**
+     * Converts this stream to a newline-separated ReadableStream of
+     * JSON stringified values in the stream
+     * which can be turned back into a Stream with `Stream.fromReadableStream()`.
+     */
+    toReadableStream(): _ReadableStream_2;
+}
+
 /** User provided string values assigned to a single metadata key. This data type is not supported in Vertex AI. */
 export declare interface StringList {
     /** The string values of the metadata to store. */
@@ -7424,6 +9117,21 @@ export declare interface TestTableItem {
     ignoreKeys?: string[];
 }
 
+/**
+ * A text content block.
+ */
+declare interface TextContent {
+    type: 'text';
+    /**
+     * Citation information for model-generated content.
+     */
+    annotations?: Array<Annotation>;
+    /**
+     * The text content.
+     */
+    text?: string;
+}
+
 /** The thinking features configuration. */
 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.
@@ -7432,24 +9140,49 @@ export declare interface ThinkingConfig {
     /** Indicates the thinking budget in tokens. 0 is DISABLED. -1 is AUTOMATIC. The default values and allowed ranges are model dependent.
      */
     thinkingBudget?: number;
-    /** Optional. The level of thoughts tokens that the model should generate. */
+    /** Optional. The number of thoughts tokens that the model should generate. */
     thinkingLevel?: ThinkingLevel;
 }
 
-/** The level of thoughts tokens that the model should generate. */
+/** The number of thoughts tokens that the model should generate. */
 export declare enum ThinkingLevel {
     /**
-     * Default value.
+     * Unspecified thinking level.
      */
     THINKING_LEVEL_UNSPECIFIED = "THINKING_LEVEL_UNSPECIFIED",
     /**
      * Low thinking level.
      */
     LOW = "LOW",
+    /**
+     * Medium thinking level.
+     */
+    MEDIUM = "MEDIUM",
     /**
      * High thinking level.
      */
-    HIGH = "HIGH"
+    HIGH = "HIGH",
+    /**
+     * MINIMAL thinking level.
+     */
+    MINIMAL = "MINIMAL"
+}
+
+declare type ThinkingLevel_2 = 'minimal' | 'low' | 'medium' | 'high';
+
+/**
+ * A thought content block.
+ */
+declare interface ThoughtContent {
+    type: 'thought';
+    /**
+     * Signature to match the backend source to be part of the generation.
+     */
+    signature?: string;
+    /**
+     * A summary of the thought.
+     */
+    summary?: Array<TextContent | ImageContent>;
 }
 
 export declare class Tokens extends BaseModule {
@@ -7578,6 +9311,103 @@ export declare interface Tool {
     urlContext?: UrlContext;
 }
 
+/**
+ * A tool that can be used by the model.
+ */
+declare type Tool_2 = Function_2 | Tool_2.GoogleSearch | Tool_2.CodeExecution | Tool_2.URLContext | Tool_2.ComputerUse | Tool_2.MCPServer | Tool_2.FileSearch;
+
+declare namespace Tool_2 {
+    /**
+     * A tool that can be used by the model to search Google.
+     */
+    interface GoogleSearch {
+        type: 'google_search';
+    }
+    /**
+     * A tool that can be used by the model to execute code.
+     */
+    interface CodeExecution {
+        type: 'code_execution';
+    }
+    /**
+     * A tool that can be used by the model to fetch URL context.
+     */
+    interface URLContext {
+        type: 'url_context';
+    }
+    /**
+     * A tool that can be used by the model to interact with the computer.
+     */
+    interface ComputerUse {
+        type: 'computer_use';
+        /**
+         * The environment being operated.
+         */
+        environment?: 'browser';
+        /**
+         * The list of predefined functions that are excluded from the model call.
+         */
+        excludedPredefinedFunctions?: Array<string>;
+    }
+    /**
+     * A MCPServer is a server that can be called by the model to perform actions.
+     */
+    interface MCPServer {
+        type: 'mcp_server';
+        /**
+         * The allowed tools.
+         */
+        allowed_tools?: Array<InteractionsAPI.AllowedTools>;
+        /**
+         * Optional: Fields for authentication headers, timeouts, etc., if needed.
+         */
+        headers?: {
+            [key: string]: string;
+        };
+        /**
+         * The name of the MCPServer.
+         */
+        name?: string;
+        /**
+         * The full URL for the MCPServer endpoint.
+         * Example: "https://api.example.com/mcp"
+         */
+        url?: string;
+    }
+    /**
+     * A tool that can be used by the model to search files.
+     */
+    interface FileSearch {
+        type: 'file_search';
+        /**
+         * The file search store names to search.
+         */
+        file_search_store_names?: Array<string>;
+        /**
+         * Metadata filter to apply to the semantic retrieval documents and chunks.
+         */
+        metadata_filter?: string;
+        /**
+         * The number of semantic retrieval chunks to retrieve.
+         */
+        top_k?: number;
+    }
+}
+
+/**
+ * The configuration for tool choice.
+ */
+declare type ToolChoice = ToolChoiceType | ToolChoiceConfig;
+
+declare interface ToolChoiceConfig {
+    /**
+     * The configuration for allowed tools.
+     */
+    allowed_tools?: AllowedTools;
+}
+
+declare type ToolChoiceType = 'auto' | 'any' | 'none' | 'validated';
+
 /** Tool that executes code generated by the model, and automatically returns the result to the model. See also [ExecutableCode]and [CodeExecutionResult] which are input and output to this tool. This data type is not supported in Gemini API. */
 export declare interface ToolCodeExecution {
 }
@@ -7875,6 +9705,18 @@ export declare interface TuningValidationDataset {
     vertexDatasetResource?: string;
 }
 
+declare interface Turn {
+    /**
+     * The content of the turn.
+     */
+    content?: string | Array<TextContent | ImageContent | AudioContent | DocumentContent | VideoContent | ThoughtContent | FunctionCallContent | FunctionResultContent | CodeExecutionCallContent | CodeExecutionResultContent | URLContextCallContent | URLContextResultContent | GoogleSearchCallContent | GoogleSearchResultContent | MCPServerToolCallContent | MCPServerToolResultContent | FileSearchResultContent>;
+    /**
+     * The originator of this turn. Must be user for input or model for
+     * model output.
+     */
+    role?: string;
+}
+
 /** The reason why the turn is complete. */
 export declare enum TurnCompleteReason {
     /**
@@ -8008,6 +9850,7 @@ declare namespace types {
         FileSource,
         TurnCompleteReason,
         MediaModality,
+        VadSignalType,
         StartSensitivity,
         EndSensitivity,
         ActivityHandling,
@@ -8329,6 +10172,7 @@ declare namespace types {
         UsageMetadata,
         LiveServerGoAway,
         LiveServerSessionResumptionUpdate,
+        VoiceActivityDetectionSignal,
         LiveServerMessage,
         OperationFromAPIResponseParameters,
         GenerationConfigThinkingConfig,
@@ -8394,6 +10238,37 @@ declare namespace types {
     }
 }
 
+/** @ts-ignore For users with undici */
+declare type UndiciRequestInit = NotAny<import('../node_modules/undici/index.d.ts').RequestInit> | NotAny<import('../../node_modules/undici/index.d.ts').RequestInit> | NotAny<import('../../../node_modules/undici/index.d.ts').RequestInit> | NotAny<import('../../../../node_modules/undici/index.d.ts').RequestInit> | NotAny<import('../../../../../node_modules/undici/index.d.ts').RequestInit> | NotAny<import('../../../../../../node_modules/undici/index.d.ts').RequestInit> | NotAny<import('../../../../../../../node_modules/undici/index.d.ts').RequestInit> | NotAny<import('../../../../../../../../node_modules/undici/index.d.ts').RequestInit> | NotAny<import('../../../../../../../../../node_modules/undici/index.d.ts').RequestInit> | NotAny<import('../../../../../../../../../../node_modules/undici/index.d.ts').RequestInit>;
+
+/**
+ * These imports attempt to get types from a parent package's dependencies.
+ * Unresolved bare specifiers can trigger [automatic type acquisition][1] in some projects, which
+ * would cause typescript to show types not present at runtime. To avoid this, we import
+ * directly from parent node_modules folders.
+ *
+ * We need to check multiple levels because we don't know what directory structure we'll be in.
+ * For example, pnpm generates directories like this:
+ * ```
+ * node_modules
+ * ├── .pnpm
+ * │   └── pkg@1.0.0
+ * │       └── node_modules
+ * │           └── pkg
+ * │               └── internal
+ * │                   └── types.d.ts
+ * ├── pkg -> .pnpm/pkg@1.0.0/node_modules/pkg
+ * └── undici
+ * ```
+ *
+ * [1]: https://www.typescriptlang.org/tsconfig/#typeAcquisition
+ */
+/** @ts-ignore For users with \@types/node */
+declare type UndiciTypesRequestInit = NotAny<import('../node_modules/undici-types/index.d.ts').RequestInit> | NotAny<import('../../node_modules/undici-types/index.d.ts').RequestInit> | NotAny<import('../../../node_modules/undici-types/index.d.ts').RequestInit> | NotAny<import('../../../../node_modules/undici-types/index.d.ts').RequestInit> | NotAny<import('../../../../../node_modules/undici-types/index.d.ts').RequestInit> | NotAny<import('../../../../../../node_modules/undici-types/index.d.ts').RequestInit> | NotAny<import('../../../../../../../node_modules/undici-types/index.d.ts').RequestInit> | NotAny<import('../../../../../../../../node_modules/undici-types/index.d.ts').RequestInit> | NotAny<import('../../../../../../../../../node_modules/undici-types/index.d.ts').RequestInit> | NotAny<import('../../../../../../../../../../node_modules/undici-types/index.d.ts').RequestInit>;
+
+declare class UnprocessableEntityError extends APIError<422, Headers> {
+}
+
 /** Optional parameters for caches.update method. */
 export declare interface UpdateCachedContentConfig {
     /** Used to override HTTP request options. */
@@ -8644,12 +10519,74 @@ export declare class UpscaleImageResponse {
 export declare interface UrlContext {
 }
 
+/**
+ * The arguments to pass to the URL context.
+ */
+declare interface URLContextCallArguments {
+    /**
+     * The URLs to fetch.
+     */
+    urls?: Array<string>;
+}
+
+/**
+ * URL context content.
+ */
+declare interface URLContextCallContent {
+    type: 'url_context_call';
+    /**
+     * A unique ID for this specific tool call.
+     */
+    id?: string;
+    /**
+     * The arguments to pass to the URL context.
+     */
+    arguments?: URLContextCallArguments;
+}
+
 /** Metadata related to url context retrieval tool. */
 export declare interface UrlContextMetadata {
     /** Output only. List of url context. */
     urlMetadata?: UrlMetadata[];
 }
 
+/**
+ * The result of the URL context.
+ */
+declare interface URLContextResult {
+    /**
+     * The status of the URL retrieval.
+     */
+    status?: 'success' | 'error' | 'paywall' | 'unsafe';
+    /**
+     * The URL that was fetched.
+     */
+    url?: string;
+}
+
+/**
+ * URL context result content.
+ */
+declare interface URLContextResultContent {
+    type: 'url_context_result';
+    /**
+     * ID to match the ID from the url context call block.
+     */
+    call_id?: string;
+    /**
+     * Whether the URL context resulted in an error.
+     */
+    is_error?: boolean;
+    /**
+     * The results of the URL context.
+     */
+    result?: Array<URLContextResult>;
+    /**
+     * The signature of the URL context result.
+     */
+    signature?: string;
+}
+
 /** Context of the a single url retrieval. */
 export declare interface UrlMetadata {
     /** Retrieved url by the tool. */
@@ -8682,6 +10619,108 @@ export declare enum UrlRetrievalStatus {
     URL_RETRIEVAL_STATUS_UNSAFE = "URL_RETRIEVAL_STATUS_UNSAFE"
 }
 
+/**
+ * Statistics on the interaction request's token usage.
+ */
+declare interface Usage {
+    /**
+     * A breakdown of cached token usage by modality.
+     */
+    cached_tokens_by_modality?: Array<Usage.CachedTokensByModality>;
+    /**
+     * A breakdown of input token usage by modality.
+     */
+    input_tokens_by_modality?: Array<Usage.InputTokensByModality>;
+    /**
+     * A breakdown of output token usage by modality.
+     */
+    output_tokens_by_modality?: Array<Usage.OutputTokensByModality>;
+    /**
+     * A breakdown of tool-use token usage by modality.
+     */
+    tool_use_tokens_by_modality?: Array<Usage.ToolUseTokensByModality>;
+    /**
+     * Number of tokens in the cached part of the prompt (the cached content).
+     */
+    total_cached_tokens?: number;
+    /**
+     * Number of tokens in the prompt (context).
+     */
+    total_input_tokens?: number;
+    /**
+     * Total number of tokens across all the generated responses.
+     */
+    total_output_tokens?: number;
+    /**
+     * Number of tokens of thoughts for thinking models.
+     */
+    total_reasoning_tokens?: number;
+    /**
+     * Total token count for the interaction request (prompt + responses + other
+     * internal tokens).
+     */
+    total_tokens?: number;
+    /**
+     * Number of tokens present in tool-use prompt(s).
+     */
+    total_tool_use_tokens?: number;
+}
+
+declare namespace Usage {
+    /**
+     * The token count for a single response modality.
+     */
+    interface CachedTokensByModality {
+        /**
+         * The modality associated with the token count.
+         */
+        modality?: 'text' | 'image' | 'audio';
+        /**
+         * Number of tokens for the modality.
+         */
+        tokens?: number;
+    }
+    /**
+     * The token count for a single response modality.
+     */
+    interface InputTokensByModality {
+        /**
+         * The modality associated with the token count.
+         */
+        modality?: 'text' | 'image' | 'audio';
+        /**
+         * Number of tokens for the modality.
+         */
+        tokens?: number;
+    }
+    /**
+     * The token count for a single response modality.
+     */
+    interface OutputTokensByModality {
+        /**
+         * The modality associated with the token count.
+         */
+        modality?: 'text' | 'image' | 'audio';
+        /**
+         * Number of tokens for the modality.
+         */
+        tokens?: number;
+    }
+    /**
+     * The token count for a single response modality.
+     */
+    interface ToolUseTokensByModality {
+        /**
+         * The modality associated with the token count.
+         */
+        modality?: 'text' | 'image' | 'audio';
+        /**
+         * Number of tokens for the modality.
+         */
+        tokens?: number;
+    }
+}
+
 /** 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. */
@@ -8709,6 +10748,22 @@ export declare interface UsageMetadata {
     trafficType?: TrafficType;
 }
 
+/** The type of the VAD signal. */
+export declare enum VadSignalType {
+    /**
+     * The default is VAD_SIGNAL_TYPE_UNSPECIFIED.
+     */
+    VAD_SIGNAL_TYPE_UNSPECIFIED = "VAD_SIGNAL_TYPE_UNSPECIFIED",
+    /**
+     * Start of sentence signal.
+     */
+    VAD_SIGNAL_TYPE_SOS = "VAD_SIGNAL_TYPE_SOS",
+    /**
+     * End of sentence signal.
+     */
+    VAD_SIGNAL_TYPE_EOS = "VAD_SIGNAL_TYPE_EOS"
+}
+
 /** Hyperparameters for Veo. This data type is not supported in Gemini API. */
 export declare interface VeoHyperParameters {
     /** Optional. Number of complete passes the model makes over the entire training dataset during training. */
@@ -8800,6 +10855,23 @@ export declare enum VideoCompressionQuality {
     LOSSLESS = "LOSSLESS"
 }
 
+/**
+ * A video content block.
+ */
+declare interface VideoContent {
+    type: 'video';
+    data?: string;
+    /**
+     * The mime type of the video.
+     */
+    mime_type?: VideoMimeType;
+    /**
+     * The resolution of the media.
+     */
+    resolution?: 'low' | 'medium' | 'high' | 'ultra_high';
+    uri?: string;
+}
+
 /** A mask for video generation. */
 export declare interface VideoGenerationMask {
     /** The image mask to use for generating videos. */
@@ -8871,6 +10943,16 @@ export declare interface VideoMetadata {
     startOffset?: string;
 }
 
+/**
+ * The mime type of the video.
+ */
+declare type VideoMimeType = 'video/mp4' | 'video/mpeg' | 'video/mov' | 'video/avi' | 'video/x-flv' | 'video/mpg' | 'video/webm' | 'video/wmv' | 'video/3gpp' | (string & {});
+
+export declare interface VoiceActivityDetectionSignal {
+    /** The type of the VAD signal. */
+    vadSignalType?: VadSignalType;
+}
+
 export declare interface VoiceConfig {
     /** If true, the model will use a replicated voice for the response. */
     replicatedVoiceConfig?: ReplicatedVoiceConfig;