@langchain/google 0.2.11 → 0.2.13

package/dist/chat_models/types.d.ts

@@ -1,9 +1,13 @@
+import { ApiClient } from "../clients/index.js";
+import { GenContent } from "./api_types/generate_content.js";
+import { Interactions } from "./api_types/interactions.js";
 import { LowercaseLiteral, Prettify } from "../utils/misc.js";
-import { Gemini } from "./api-types.js";
-import { BindToolsInput } from "@langchain/core/language_models/chat_models";
+import { GoogleChatApiHandler } from "./handlers/base.js";
+import { BaseChatModelCallOptions, BaseChatModelParams, BindToolsInput } from "@langchain/core/language_models/chat_models";
 import { InteropZodType } from "@langchain/core/utils/types";
-//#region src/chat_models/types.d.ts
-export interface ChatGoogleFields {
+import { SerializableSchema } from "@langchain/core/utils/standard_schema";
+import { AsyncCaller } from "@langchain/core/utils/async_caller";
+export interface BaseChatGoogleFields {
   /**
    * The temperature is used for sampling during response generation, which
    * occurs when topP and topK are applied. Temperature controls the degree of
@@ -65,155 +69,235 @@ export interface ChatGoogleFields {
    */
   seed?: number;
   /**
-   * If true, returns the log probabilities of the tokens that were chosen by
-   * the model at each step. By default, this parameter is set to false.
+   * A list of tools the model may use to generate the next response.
+   * Can be LangChain tools, OpenAI tools, or Gemini function declarations.
    */
-  responseLogprobs?: boolean;
+  tools?: BindToolsInput[];
   /**
-   * Returns the log probabilities of the top candidate tokens at each generation
-   * step. The model's chosen token might not be the same as the top candidate
-   * token at each step. Specify the number of candidates to return by using an
-   * integer value in the range of 1-20.
+   * OpenAI-compatible alias for media input detail level.
+   *
+   * This is mapped to `generationConfig.mediaResolution`:
+   * - `"auto"` => default Gemini behavior (`mediaResolution` omitted)
+   * - `"low"` => `"MEDIA_RESOLUTION_LOW"`
+   * - `"high"` => `"MEDIA_RESOLUTION_HIGH"`
+   *
+   * If both `mediaResolution` and `detail` are provided, `mediaResolution` wins.
    */
-  logprobs?: number;
+  detail?: "auto" | "low" | "high";
+  /**
+   * The number of reasoning tokens that the model should generate.
+   * If explicitly set, then the reasoning blocks will be returned.
+   */
+  maxReasoningTokens?: number;
+  /**
+   * An alias for `maxReasoningTokens` for compatibility.
+   */
+  thinkingBudget?: number;
+  /**
+   * An alias for `maxReasoningTokens` under Gemini 2.5 or
+   * the primary thinking/reasoning setting for Gemini 3.
+   * If explicitly set, then the reasoning blocks will be returned.
+   */
+  reasoningEffort?: Gemini.Shared.ThinkingLevel;
+  /**
+   * An alias for `reasoningEffort` for compatibility.
+   */
+  thinkingLevel?: Gemini.Shared.ThinkingLevel;
+  /**
+   * Custom / additional headers to include with every request to the API.
+   * When set on both constructor params and per-invocation call options,
+   * per-invocation headers take precidence for matching keys.
+   */
+  customHeaders?: Record<string, string>;
   /**
    * Per request settings for blocking unsafe content
    */
-  safetySettings?: Prettify<Gemini.SafetySetting>[];
+  safetySettings?: Prettify<Gemini.Shared.SafetySetting>[];
   /**
-   * Configuration for the model's thinking process
+   * Media resolution for input media processing.
+   *
+   * This maps to `generationConfig.mediaResolution`, which is a scalar enum-like
+   * string value in the Gemini API.
    */
-  thinkingConfig?: Prettify<Gemini.ThinkingConfig>;
+  mediaResolution?: Gemini.Shared.MediaResolution;
   /**
    * The schema that the generated response should match.
    * Can be a Zod schema or a JSON Schema object.
    * When set, the response will be structured according to this schema
    * and `responseMimeType` will automatically be set to "application/json".
    */
-  responseSchema?: InteropZodType | Record<string, unknown>;
+  responseSchema?: InteropZodType | SerializableSchema | Record<string, unknown>;
   /**
-   * A list of tools the model may use to generate the next response.
-   * Can be LangChain tools, OpenAI tools, or Gemini function declarations.
+   * Desired MIME type of the generated candidate content.
    */
-  tools?: BindToolsInput[];
+  responseMimeType?: string;
   /**
    * The requested modalities of the response.
    * Represents the set of modalities that the model can return.
    * An empty list is equivalent to requesting only text.
    */
-  responseModalities?: Prettify<Gemini.GenerativeLanguageModality>[];
+  responseModalities?: Prettify<GenContent.GenerativeLanguageModality>[];
   /**
-   * If true, enables enhanced civic answers feature.
+   * Configuration for the model's thinking process
    */
-  enableEnhancedCivicAnswers?: boolean;
+  thinkingConfig?: Prettify<GenContent.ThinkingConfig>;
   /**
    * Speech generation configuration.
    * You can use either Google's definition of the speech configuration,
    * or a simplified version we've defined (which can be as simple
    * as the name of a pre-defined voice).
    */
-  speechConfig?: Prettify<Gemini.SpeechConfig> | SimplifiedSpeechConfig;
+  speechConfig?: Prettify<GenContent.SpeechConfig> | SimplifiedSpeechConfig;
   /**
    * Configuration for image generation.
    */
-  imageConfig?: Prettify<Gemini.ImageConfig>;
+  imageConfig?: Prettify<GenContent.ImageConfig>;
   /**
-   * Media resolution for input media processing.
-   *
-   * This maps to `generationConfig.mediaResolution`, which is a scalar enum-like
-   * string value in the Gemini API.
+   * Inference service tiers.
+   * "priority" offers highest reliability for higher rates.
+   * "flex" offers a discount for preemptable processing.
+   * Other values are treated as the standard service tier.
    */
-  mediaResolution?: Gemini.GenerationConfig["mediaResolution"];
+  serviceTier?: GenContent.ServiceTier;
+}
+export interface GenerateContentSpecificFields {
   /**
-   * OpenAI-compatible alias for media input detail level.
-   *
-   * This is mapped to `generationConfig.mediaResolution`:
-   * - `"auto"` => default Gemini behavior (`mediaResolution` omitted)
-   * - `"low"` => `"MEDIA_RESOLUTION_LOW"`
-   * - `"high"` => `"MEDIA_RESOLUTION_HIGH"`
-   *
-   * If both `mediaResolution` and `detail` are provided, `mediaResolution` wins.
+   * If true, returns the log probabilities of the tokens that were chosen by
+   * the model at each step. By default, this parameter is set to false.
    */
-  detail?: "auto" | "low" | "high";
+  responseLogprobs?: boolean;
   /**
-   * The number of reasoning tokens that the model should generate.
-   * If explicitly set, then the reasoning blocks will be returned.
+   * Returns the log probabilities of the top candidate tokens at each generation
+   * step. The model's chosen token might not be the same as the top candidate
+   * token at each step. Specify the number of candidates to return by using an
+   * integer value in the range of 1-20.
    */
-  maxReasoningTokens?: number;
+  logprobs?: number;
   /**
-   * An alias for `maxReasoningTokens` for compatibility.
+   * If true, enables enhanced civic answers feature.
    */
-  thinkingBudget?: number;
+  enableEnhancedCivicAnswers?: boolean;
+}
+export interface InteractionsSpecificFields {
   /**
-   * An alias for `maxReasoningTokens` under Gemini 2.5 or
-   * the primary thinking/reasoning setting for Gemini 3.
-   * If explicitly set, then the reasoning blocks will be returned.
+   * Native Interactions API `response_format` configuration (JSON Schema or media response format).
+   * Note: `responseSchema`, `responseModalities`, `responseMimeType`, and `imageConfig` are also
+   * automatically translated into `response_format` when using the Interactions API.
    */
-  reasoningEffort?: Gemini.ThinkingLevel;
+  responseFormat?: Gemini.Interactions.CreateInteractionParameters["response_format"];
   /**
-   * An alias for `reasoningEffort` for compatibility.
+   * The ID of a previous interaction to continue a stateful server-side conversation.
    */
-  thinkingLevel?: Gemini.ThinkingLevel;
+  previousInteractionId?: string;
   /**
-   * Inference service tiers.
-   * "priority" offers highest reliability for higher rates.
-   * "flex" offers a discount for preemptable processing.
-   * Other values are treated as the standard service tier.
+   * Whether to store the interaction on the server.
    */
-  serviceTier?: Gemini.ServiceTier;
+  store?: boolean;
   /**
-   * Custom / additional headers to include with every request to the API.
-   * When set on both constructor params and per-invocation call options,
-   * per-invocation headers take precidence for matching keys.
+   * Whether to execute the interaction in the background (primarily for agents).
    */
+  background?: boolean;
+  /**
+   * The name of the agent to use for the interaction (mutually exclusive with `model` in the raw API,
+   * or used when invoking an agent endpoint).
+   */
+  agent?: string;
+  /**
+   * Configuration parameters for the specified agent.
+   */
+  agentConfig?: Gemini.Interactions.AgentConfig;
+  /**
+   * Optional webhook configuration for receiving asynchronous interaction events.
+   */
+  webhookConfig?: Gemini.Interactions.WebhookConfig;
+}
+export interface GenerateContentFields extends BaseChatGoogleFields, GenerateContentSpecificFields {}
+export interface InteractionsFields extends BaseChatGoogleFields, InteractionsSpecificFields {}
+export interface ChatGoogleFields extends BaseChatGoogleFields, Partial<GenerateContentSpecificFields>, Partial<InteractionsSpecificFields> {}
+export type GooglePlatformType = "gai" | "gcp";
+export interface BaseChatGoogleParams extends BaseChatModelParams, ChatGoogleFields {
+  model: string;
+  apiClient?: ApiClient;
+  endpoint?: string;
+  location?: string;
+  apiVersion?: string;
+  platformType?: GooglePlatformType;
+  vertexai?: boolean;
+  streaming?: boolean;
+  streamUsage?: boolean;
+  apiHandler?: GoogleChatApiHandlerConfig;
+}
+export interface BaseChatGoogleCallOptions extends BaseChatModelCallOptions, ChatGoogleFields {
+  streamUsage?: boolean;
+}
+export interface GoogleChatApiHandlerParams extends BaseChatModelParams, BaseChatGoogleFields {
+  apiClient: ApiClient;
+  caller: AsyncCaller;
+  model: string;
+  platform: GooglePlatformType;
+  endpoint: string;
+  location: string;
+  apiVersion: string;
+  isVertexExpress: boolean;
+  publisher: string;
+  streaming: boolean;
+  streamUsage: boolean;
   customHeaders?: Record<string, string>;
 }
-declare module "./api-types.js" {
-  namespace Gemini {
+export interface GenerateContentApiHandlerParams extends GoogleChatApiHandlerParams, GenerateContentSpecificFields {}
+export interface InteractionsApiHandlerParams extends GoogleChatApiHandlerParams, InteractionsSpecificFields {}
+export type GoogleChatApiHandlerFactory = (params: GoogleChatApiHandlerParams) => GoogleChatApiHandler;
+export type GoogleChatApiHandlerConfig = "generateContent" | "interactions" | GoogleChatApiHandlerFactory;
+export type GenerateContentInvocationParams = Partial<Omit<GenContent.GenerateContentRequest, "contents">> & {
+  serviceTier?: GenContent.ServiceTier;
+};
+export type InteractionsInvocationParams = Partial<Omit<Gemini.Interactions.CreateInteractionParameters, "input">>;
+declare module "./api_types/generate_content.js" {
+  namespace GenContent {
     namespace Part {
-      type CodeExecutionResult = Pick<Gemini.Part, "codeExecutionResult">;
-      type ExecutableCode = Pick<Gemini.Part, "executableCode">;
-      type FileData = Pick<Gemini.Part, "fileData" | "videoMetadata">;
-      type FunctionCall = Required<Pick<Gemini.Part, "functionCall">> & Pick<Gemini.Part, "thoughtSignature">;
-      type FunctionResponse = Pick<Gemini.Part, "functionResponse">;
-      type InlineData = Pick<Gemini.Part, "inlineData" | "videoMetadata">;
-      type MediaResolution = Pick<Gemini.Part, "mediaResolution">;
-      type PartMetadata = Pick<Gemini.Part, "partMetadata">;
-      type Text = Pick<Gemini.Part, "text">;
-      type Thought = Pick<Gemini.Part, "thought">;
-      type ThoughtSignature = Pick<Gemini.Part, "thoughtSignature">;
+      type CodeExecutionResult = Pick<GenContent.Part, "codeExecutionResult">;
+      type ExecutableCode = Pick<GenContent.Part, "executableCode">;
+      type FileData = Pick<GenContent.Part, "fileData" | "videoMetadata">;
+      type FunctionCall = Required<Pick<GenContent.Part, "functionCall">> & Pick<GenContent.Part, "thoughtSignature">;
+      type FunctionResponse = Pick<GenContent.Part, "functionResponse">;
+      type InlineData = Pick<GenContent.Part, "inlineData" | "videoMetadata">;
+      type MediaResolution = Pick<GenContent.Part, "mediaResolution">;
+      type PartMetadata = Pick<GenContent.Part, "partMetadata">;
+      type Text = Pick<GenContent.Part, "text">;
+      type Thought = Pick<GenContent.Part, "thought">;
+      type ThoughtSignature = Pick<GenContent.Part, "thoughtSignature">;
     }
     namespace PrebuiltVoiceConfig {
       /**
        * The name of a prebuilt voice that can be used for speech synthesis.
        *
-       * Extracted as a non-nullable type from the GeminiBase.PrebuiltVoiceConfig["voiceName"] property.
+       * Extracted as a non-nullable type from the PrebuiltVoiceConfig["voiceName"] property.
        */
-      type VoiceName = NonNullable<Gemini.PrebuiltVoiceConfig["voiceName"]>;
+      type VoiceName = NonNullable<GenContent.PrebuiltVoiceConfig["voiceName"]>;
     }
     namespace SpeakerVoiceConfig {
       /**
        * The speaker identifier for a custom or multi-speaker TTS configuration.
        *
-       * Extracted as a non-nullable type from the GeminiBase.SpeakerVoiceConfig["speaker"] property.
+       * Extracted as a non-nullable type from the SpeakerVoiceConfig["speaker"] property.
        */
-      type Speaker = NonNullable<Gemini.SpeakerVoiceConfig["speaker"]>;
+      type Speaker = NonNullable<GenContent.SpeakerVoiceConfig["speaker"]>;
     }
     namespace SpeechConfig {
       /**
        * The BCP-47 language code for speech synthesis (e.g., "en-US").
        *
-       * Extracted as a non-nullable type from the GeminiBase.SpeechConfig["languageCode"] property.
+       * Extracted as a non-nullable type from the SpeechConfig["languageCode"] property.
        */
-      type LanguageCode = NonNullable<Gemini.SpeechConfig["languageCode"]>;
+      type LanguageCode = NonNullable<GenContent.SpeechConfig["languageCode"]>;
     }
     /**
      * The level of "thinking" or reasoning configured for the model.
      *
-     * Extends GeminiBase.ThinkingConfig["thinkingLevel"] to also accept
+     * Extends ThinkingConfig["thinkingLevel"] to also accept
      * lowercase variants (e.g. "high" in addition to "HIGH").
      */
-    type ThinkingLevel = Gemini.ThinkingConfig["thinkingLevel"] | LowercaseLiteral<Gemini.ThinkingConfig["thinkingLevel"]>;
+    type ThinkingLevel = GenContent.ThinkingConfig["thinkingLevel"] | LowercaseLiteral<GenContent.ThinkingConfig["thinkingLevel"]>;
     /**
      * The role of a content message. The spec types this as `string`, but
      * the API only accepts these specific values.
@@ -222,24 +306,24 @@ declare module "./api-types.js" {
     /**
      * Alias for the unwieldy generated grounding support type name.
      */
-    type GroundingSupport = Gemini.GoogleAiGenerativelanguageV1betaGroundingSupport;
+    type GroundingSupport = GenContent.GoogleAiGenerativelanguageV1betaGroundingSupport;
     /**
      * Alias for the unwieldy generated segment type name.
      */
-    type Segment = Gemini.GoogleAiGenerativelanguageV1betaSegment;
+    type Segment = GenContent.GoogleAiGenerativelanguageV1betaSegment;
     namespace Tools {
       /**
        * The mode for function calling configuration, extracted from the
        * FunctionCallingConfig interface.
        */
-      type FunctionCallingConfigMode = Gemini.Tools.FunctionCallingConfig["mode"];
+      type FunctionCallingConfigMode = GenContent.Tools.FunctionCallingConfig["mode"];
     }
     /**
      * Legacy URL retrieval metadata (predecessor of UrlContextMetadata).
      * Not in the current OpenAPI spec but still returned by the API.
      */
     interface UrlRetrievalMetadata {
-      urlRetrievalContexts?: Array<Gemini.UrlMetadata>;
+      urlRetrievalContexts?: Array<GenContent.UrlMetadata>;
     }
     interface Candidate {
       /** @deprecated Use urlContextMetadata instead. */
@@ -247,30 +331,634 @@ declare module "./api-types.js" {
     }
   }
 }
+export declare namespace Gemini {
+  namespace Shared {
+    type HarmCategory = GenContent.HarmCategory;
+    type SafetySetting = GenContent.SafetySetting;
+    type MediaResolution = GenContent.GenerationConfig["mediaResolution"];
+    type ThinkingLevel = GenContent.ThinkingLevel;
+  }
+  namespace GenContent {
+    type Content = GenContent.Content;
+    type Candidate = GenContent.Candidate;
+    type GenerateContentRequest = GenContent.GenerateContentRequest;
+    type GenerateContentResponse = GenContent.GenerateContentResponse;
+    type GenerationConfig = GenContent.GenerationConfig;
+    type SafetyRating = GenContent.SafetyRating;
+    type SafetySetting = GenContent.SafetySetting;
+    type PromptFeedback = GenContent.PromptFeedback;
+    type Tool = GenContent.Tool;
+    type ThinkingConfig = GenContent.ThinkingConfig;
+    type ThinkingLevel = GenContent.ThinkingLevel;
+    type SpeechConfig = GenContent.SpeechConfig;
+    namespace SpeechConfig {
+      type LanguageCode = GenContent.SpeechConfig.LanguageCode;
+    }
+    type PrebuiltVoiceConfig = GenContent.PrebuiltVoiceConfig;
+    namespace PrebuiltVoiceConfig {
+      type VoiceName = GenContent.PrebuiltVoiceConfig.VoiceName;
+    }
+    type SpeakerVoiceConfig = GenContent.SpeakerVoiceConfig;
+    namespace SpeakerVoiceConfig {
+      type Speaker = GenContent.SpeakerVoiceConfig.Speaker;
+    }
+    type ServiceTier = GenContent.ServiceTier;
+    type ImageConfig = GenContent.ImageConfig;
+    type Role = GenContent.Role;
+    type GroundingSupport = GenContent.GroundingSupport;
+    type GroundingMetadata = GenContent.GroundingMetadata;
+    type CitationMetadata = GenContent.CitationMetadata;
+    type UsageMetadata = GenContent.UsageMetadata;
+    type ModalityTokenCount = GenContent.ModalityTokenCount;
+    type Part = GenContent.Part;
+    namespace Part {
+      type CodeExecutionResult = GenContent.Part.CodeExecutionResult;
+      type ExecutableCode = GenContent.Part.ExecutableCode;
+      type FileData = GenContent.Part.FileData;
+      type FunctionCall = GenContent.Part.FunctionCall;
+      type FunctionResponse = GenContent.Part.FunctionResponse;
+      type InlineData = GenContent.Part.InlineData;
+      type MediaResolution = GenContent.Part.MediaResolution;
+      type PartMetadata = GenContent.Part.PartMetadata;
+      type Text = GenContent.Part.Text;
+      type Thought = GenContent.Part.Thought;
+      type ThoughtSignature = GenContent.Part.ThoughtSignature;
+    }
+    namespace Tools {
+      type FunctionCallingConfigMode = GenContent.Tools.FunctionCallingConfigMode;
+      type FunctionDeclaration = GenContent.Tools.FunctionDeclaration;
+      type GoogleSearch = GenContent.Tools.GoogleSearch;
+      type CodeExecution = GenContent.Tools.CodeExecution;
+      type UrlContext = GenContent.Tools.UrlContext;
+      type GoogleMaps = GenContent.Tools.GoogleMaps;
+      type FileSearch = GenContent.Tools.FileSearch;
+      type ComputerUse = GenContent.Tools.ComputerUse;
+      type FunctionCallingConfig = GenContent.Tools.FunctionCallingConfig;
+      type RetrievalConfig = GenContent.Tools.RetrievalConfig;
+      type ToolConfig = GenContent.Tools.ToolConfig;
+      type Schema = GenContent.Tools.Schema;
+      type LatLng = GenContent.Tools.LatLng;
+      type Interval = GenContent.Tools.Interval;
+      type SearchTypes = GenContent.Tools.SearchTypes;
+      type Type = GenContent.Tools.Type;
+      type WebSearch = GenContent.Tools.WebSearch;
+      type ImageSearch = GenContent.Tools.ImageSearch;
+    }
+  }
+  type Content = GenContent.Content;
+  type Candidate = GenContent.Candidate;
+  type GenerateContentRequest = GenContent.GenerateContentRequest;
+  type GenerateContentResponse = GenContent.GenerateContentResponse;
+  type GenerationConfig = GenContent.GenerationConfig;
+  type SafetyRating = GenContent.SafetyRating;
+  type SafetySetting = GenContent.SafetySetting;
+  type PromptFeedback = GenContent.PromptFeedback;
+  type Tool = GenContent.Tool;
+  type ThinkingConfig = GenContent.ThinkingConfig;
+  type ThinkingLevel = GenContent.ThinkingLevel;
+  type SpeechConfig = GenContent.SpeechConfig;
+  namespace SpeechConfig {
+    type LanguageCode = GenContent.SpeechConfig.LanguageCode;
+  }
+  type PrebuiltVoiceConfig = GenContent.PrebuiltVoiceConfig;
+  namespace PrebuiltVoiceConfig {
+    type VoiceName = GenContent.PrebuiltVoiceConfig.VoiceName;
+  }
+  type SpeakerVoiceConfig = GenContent.SpeakerVoiceConfig;
+  namespace SpeakerVoiceConfig {
+    type Speaker = GenContent.SpeakerVoiceConfig.Speaker;
+  }
+  type ServiceTier = GenContent.ServiceTier;
+  type ImageConfig = GenContent.ImageConfig;
+  type Role = GenContent.Role;
+  type GroundingSupport = GenContent.GroundingSupport;
+  type GroundingMetadata = GenContent.GroundingMetadata;
+  type CitationMetadata = GenContent.CitationMetadata;
+  type UsageMetadata = GenContent.UsageMetadata;
+  type ModalityTokenCount = GenContent.ModalityTokenCount;
+  type Part = GenContent.Part;
+  namespace Part {
+    type CodeExecutionResult = GenContent.Part.CodeExecutionResult;
+    type ExecutableCode = GenContent.Part.ExecutableCode;
+    type FileData = GenContent.Part.FileData;
+    type FunctionCall = GenContent.Part.FunctionCall;
+    type FunctionResponse = GenContent.Part.FunctionResponse;
+    type InlineData = GenContent.Part.InlineData;
+    type MediaResolution = GenContent.Part.MediaResolution;
+    type PartMetadata = GenContent.Part.PartMetadata;
+    type Text = GenContent.Part.Text;
+    type Thought = GenContent.Part.Thought;
+    type ThoughtSignature = GenContent.Part.ThoughtSignature;
+  }
+  namespace Tools {
+    type FunctionCallingConfigMode = GenContent.Tools.FunctionCallingConfigMode;
+    type FunctionDeclaration = GenContent.Tools.FunctionDeclaration;
+    type GoogleSearch = GenContent.Tools.GoogleSearch;
+    type CodeExecution = GenContent.Tools.CodeExecution;
+    type UrlContext = GenContent.Tools.UrlContext;
+    type GoogleMaps = GenContent.Tools.GoogleMaps;
+    type FileSearch = GenContent.Tools.FileSearch;
+    type ComputerUse = GenContent.Tools.ComputerUse;
+    type FunctionCallingConfig = GenContent.Tools.FunctionCallingConfig;
+    type RetrievalConfig = GenContent.Tools.RetrievalConfig;
+    type ToolConfig = GenContent.Tools.ToolConfig;
+    type Schema = GenContent.Tools.Schema;
+    type LatLng = GenContent.Tools.LatLng;
+    type Interval = GenContent.Tools.Interval;
+    type SearchTypes = GenContent.Tools.SearchTypes;
+    type Type = GenContent.Tools.Type;
+    type WebSearch = GenContent.Tools.WebSearch;
+    type ImageSearch = GenContent.Tools.ImageSearch;
+  }
+  namespace Interactions {
+    type StaticMediaProcessing = Omit<Interactions.StaticMediaProcessing, "type"> & {
+      type: "static";
+    };
+    type MediaProcessing = StaticMediaProcessing;
+    type UrlCitation = Omit<Interactions.UrlCitation, "type"> & {
+      type: "url_citation";
+    };
+    type FileCitation = Omit<Interactions.FileCitation, "type"> & {
+      type: "file_citation";
+    };
+    type PlaceCitation = Omit<Interactions.PlaceCitation, "type"> & {
+      type: "place_citation";
+    };
+    type SpeechAnnotation = Omit<Interactions.SpeechAnnotation, "type"> & {
+      type: "speech_metadata";
+    };
+    type WordInfo = Omit<Interactions.WordInfo, "type"> & {
+      type: "word_info";
+    };
+    type Annotation = UrlCitation | FileCitation | PlaceCitation | SpeechAnnotation | WordInfo;
+    type TextContent = Omit<Interactions.TextContent, "type" | "annotations"> & {
+      type: "text";
+      annotations?: Array<Annotation>;
+    };
+    type ImageContent = Omit<Interactions.ImageContent, "type"> & {
+      type: "image";
+    };
+    type AudioContent = Omit<Interactions.AudioContent, "type"> & {
+      type: "audio";
+    };
+    type DocumentContent = Omit<Interactions.DocumentContent, "type"> & {
+      type: "document";
+    };
+    type VideoContent = Omit<Interactions.VideoContent, "type" | "processing"> & {
+      type: "video";
+      processing?: MediaProcessing | "static" | "agentic" | (string & {});
+    };
+    type Content = TextContent | ImageContent | AudioContent | DocumentContent | VideoContent;
+    type UserInputStep = Omit<Interactions.UserInputStep, "type" | "content"> & {
+      type: "user_input";
+      content?: Array<Content> | string;
+    };
+    type ModelOutputStep = Omit<Interactions.ModelOutputStep, "type" | "content"> & {
+      type: "model_output";
+      content?: Array<Content> | string;
+    };
+    type ThoughtStep = Omit<Interactions.ThoughtStep, "type" | "summary"> & {
+      type: "thought";
+      summary?: Array<Content>;
+    };
+    type FunctionCallStep = Omit<Interactions.FunctionCallStep, "type"> & {
+      type: "function_call";
+    };
+    type FunctionResultStep = Omit<Interactions.FunctionResultStep, "type" | "result"> & {
+      type: "function_result";
+      result: Array<Content> | string | Record<string, unknown>;
+    };
+    type CodeExecutionCallStep = Omit<Interactions.CodeExecutionCallStep, "type"> & {
+      type: "code_execution_call";
+    };
+    type CodeExecutionResultStep = Omit<Interactions.CodeExecutionResultStep, "type"> & {
+      type: "code_execution_result";
+    };
+    type GoogleSearchCallStep = Omit<Interactions.GoogleSearchCallStep, "type"> & {
+      type: "google_search_call";
+    };
+    type GoogleSearchResultStep = Omit<Interactions.GoogleSearchResultStep, "type"> & {
+      type: "google_search_result";
+    };
+    type UrlContextCallStep = Omit<Interactions.UrlContextCallStep, "type"> & {
+      type: "url_context_call";
+    };
+    type UrlContextResultStep = Omit<Interactions.UrlContextResultStep, "type"> & {
+      type: "url_context_result";
+    };
+    type FileSearchCallStep = Omit<Interactions.FileSearchCallStep, "type"> & {
+      type: "file_search_call";
+    };
+    type FileSearchResultStep = Omit<Interactions.FileSearchResultStep, "type"> & {
+      type: "file_search_result";
+      result?: Array<FileSearchResultItem>;
+    };
+    type GoogleMapsCallStep = Omit<Interactions.GoogleMapsCallStep, "type"> & {
+      type: "google_maps_call";
+    };
+    type GoogleMapsResultStep = Omit<Interactions.GoogleMapsResultStep, "type"> & {
+      type: "google_maps_result";
+    };
+    type McpServerToolCallStep = Omit<Interactions.McpServerToolCallStep, "type"> & {
+      type: "mcp_server_tool_call";
+    };
+    type McpServerToolResultStep = Omit<Interactions.McpServerToolResultStep, "type" | "result"> & {
+      type: "mcp_server_tool_result";
+      result: Array<Content> | string | Record<string, unknown>;
+    };
+    type ProcessingCallStep = Omit<Interactions.ProcessingCallStep, "type"> & {
+      type: "processing_call";
+    };
+    type ProcessingResultStep = Omit<Interactions.ProcessingResultStep, "type"> & {
+      type: "processing_result";
+    };
+    type RetrievalCallStep = Omit<Interactions.RetrievalCallStep, "type"> & {
+      type: "retrieval_call";
+    };
+    type RetrievalResultStep = Omit<Interactions.RetrievalResultStep, "type"> & {
+      type: "retrieval_result";
+    };
+    type Step = UserInputStep | ModelOutputStep | ThoughtStep | FunctionCallStep | FunctionResultStep | CodeExecutionCallStep | CodeExecutionResultStep | GoogleSearchCallStep | GoogleSearchResultStep | UrlContextCallStep | UrlContextResultStep | FileSearchCallStep | FileSearchResultStep | GoogleMapsCallStep | GoogleMapsResultStep | McpServerToolCallStep | McpServerToolResultStep | ProcessingCallStep | ProcessingResultStep | RetrievalCallStep | RetrievalResultStep;
+    type Function = Omit<Interactions.Tools.Function, "type"> & {
+      type: "function";
+    };
+    type GoogleSearch = Omit<Interactions.Tools.GoogleSearch, "type"> & {
+      type: "google_search";
+      time_range_filter?: {
+        start_time?: string;
+        end_time?: string;
+      };
+    };
+    type CodeExecution = Omit<Interactions.Tools.CodeExecution, "type"> & {
+      type: "code_execution";
+    };
+    type UrlContext = Omit<Interactions.Tools.UrlContext, "type"> & {
+      type: "url_context";
+    };
+    type ComputerUse = Omit<Interactions.Tools.ComputerUse, "type"> & {
+      type: "computer_use";
+    };
+    type FileSearch = Omit<Interactions.Tools.FileSearch, "type"> & {
+      type: "file_search";
+    };
+    type GoogleMaps = Omit<Interactions.Tools.GoogleMaps, "type"> & {
+      type: "google_maps";
+    };
+    type McpServer = Omit<Interactions.Tools.McpServer, "type"> & {
+      type: "mcp_server";
+    };
+    type Retrieval = Omit<Interactions.Tools.Retrieval, "type"> & {
+      type: "retrieval";
+    };
+    type Tool = Function | GoogleSearch | CodeExecution | UrlContext | ComputerUse | FileSearch | GoogleMaps | McpServer | Retrieval;
+    namespace Tools {
+      type AllowedTools = Interactions.Tools.AllowedTools;
+      type CodeExecution = Gemini.Interactions.CodeExecution;
+      type ComputerUse = Gemini.Interactions.ComputerUse;
+      type FileSearch = Gemini.Interactions.FileSearch;
+      type Function = Gemini.Interactions.Function;
+      type GoogleMaps = Gemini.Interactions.GoogleMaps;
+      type GoogleSearch = Gemini.Interactions.GoogleSearch;
+      type McpServer = Gemini.Interactions.McpServer;
+      type Retrieval = Gemini.Interactions.Retrieval;
+      type Tool = Gemini.Interactions.Tool;
+      type UrlContext = Gemini.Interactions.UrlContext;
+      type VertexAISearchConfig = Interactions.Tools.VertexAISearchConfig;
+    }
+    type TextResponseFormat = Omit<Interactions.TextResponseFormat, "type"> & {
+      type: "text";
+    };
+    type ImageResponseFormat = Omit<Interactions.ImageResponseFormat, "type"> & {
+      type: "image";
+    };
+    type AudioResponseFormat = Omit<Interactions.AudioResponseFormat, "type"> & {
+      type: "audio";
+    };
+    type VideoResponseFormat = Omit<Interactions.VideoResponseFormat, "type"> & {
+      type: "video";
+      mime_type?: string;
+    };
+    type ResponseFormat = TextResponseFormat | ImageResponseFormat | AudioResponseFormat | VideoResponseFormat;
+    type AntigravityAgentConfig = Omit<Interactions.AntigravityAgentConfig, "type"> & {
+      type: "antigravity";
+    };
+    type CodeMenderAgentConfig = Omit<Interactions.CodeMenderAgentConfig, "type"> & {
+      type: "code-mender";
+    };
+    type DeepResearchAgentConfig = Omit<Interactions.DeepResearchAgentConfig, "type"> & {
+      type: "deep-research";
+    };
+    type DynamicAgentConfig = Omit<Interactions.DynamicAgentConfig, "type"> & {
+      type: "dynamic";
+    };
+    type AgentConfig = AntigravityAgentConfig | CodeMenderAgentConfig | DeepResearchAgentConfig | DynamicAgentConfig;
+    type CreateInteractionParameters = Omit<Interactions.Interaction, "agent_config" | "created" | "environment_id" | "errors" | "generation_config" | "id" | "input" | "model" | "response_format" | "status" | "steps" | "tools" | "updated" | "usage"> & {
+      model?: Interactions.ModelOption;
+      agent?: Interactions.AgentOption;
+      agent_config?: AgentConfig;
+      generation_config?: GenerationConfig;
+      input: Array<Content> | Array<Step> | Content | Step | string;
+      response_format?: Record<string, unknown> | ResponseFormat | Array<ResponseFormat>;
+      tools?: Array<Tool>;
+    };
+    type Interaction = Omit<Interactions.Interaction, "agent_config" | "generation_config" | "input" | "model" | "response_format" | "steps" | "tools"> & {
+      model?: Interactions.ModelOption;
+      agent?: Interactions.AgentOption;
+      agent_config?: AgentConfig;
+      generation_config?: GenerationConfig;
+      input?: Array<Content> | Array<Step> | Content | Step | string;
+      response_format?: Record<string, unknown> | ResponseFormat | Array<ResponseFormat>;
+      role?: string;
+      steps?: Array<Step>;
+      outputs?: Array<Step | Content>;
+      tools?: Array<Tool>;
+    };
+    type AllowedTools = Interactions.Tools.AllowedTools;
+    type CodeExecutionCallStepArguments = Interactions.CodeExecutionCallStepArguments;
+    type Error = Interactions.Status;
+    type Status = Interactions.Status;
+    interface FileSearchResultItem {
+      title?: string;
+      text?: string;
+      file_search_store?: string;
+    }
+    type GenerationConfig = Omit<Interactions.GenerationConfig, "image_config"> & {
+      top_k?: number;
+      presence_penalty?: number;
+      frequency_penalty?: number;
+      response_logprobs?: boolean;
+      logprobs?: number;
+      image_config?: Interactions.ImageConfig & {
+        type?: "image";
+      };
+    };
+    type GoogleMapsCallStepArguments = Interactions.GoogleMapsCallStepArguments;
+    type GoogleMapsCallArguments = Interactions.GoogleMapsCallStepArguments;
+    type GoogleMapsResultItem = Interactions.GoogleMapsResultItem;
+    type GoogleMapsResult = Interactions.GoogleMapsResultItem;
+    type GoogleMapsResultPlaces = Interactions.GoogleMapsResultPlaces;
+    type GoogleSearchCallStepArguments = Interactions.GoogleSearchCallStepArguments;
+    type GoogleSearchResultItem = Interactions.GoogleSearchResultItem;
+    type HarmCategory = Interactions.HarmCategory;
+    type MediaResolution = Interactions.MediaResolution;
+    type ModalityTokens = Interactions.ModalityTokens;
+    type Model = Interactions.ModelOption;
+    type ModelOption = Interactions.ModelOption;
+    type ResponseModality = Interactions.ResponseModality;
+    type ReviewSnippet = Interactions.ReviewSnippet;
+    type PlaceCitationReviewSnippet = Interactions.ReviewSnippet;
+    type RetrievalStepArguments = Interactions.RetrievalStepArguments;
+    type RetrievalCallArguments = Interactions.RetrievalStepArguments;
+    type SafetySetting = Interactions.SafetySetting;
+    type ServiceTier = Interactions.ServiceTier;
+    type SpeakerConfig = Interactions.SpeakerConfig;
+    type SpeechConfig = Interactions.SpeechConfig;
+    type ThinkingLevel = Interactions.ThinkingLevel;
+    type ToolChoiceType = "auto" | "any" | "none" | "validated" | (string & {});
+    type ToolChoiceConfig = Interactions.ToolChoiceConfig;
+    type ToolChoice = ToolChoiceType | ToolChoiceConfig;
+    type UrlContextCallStepArguments = Interactions.UrlContextCallArguments;
+    type UrlContextCallArguments = Interactions.UrlContextCallArguments;
+    type UrlContextResultItem = Interactions.UrlContextResult;
+    type UrlContextResult = Interactions.UrlContextResult;
+    type Usage = Interactions.Usage;
+    type VertexAISearchConfig = Interactions.Tools.VertexAISearchConfig;
+    type VertexAiSearchConfig = Interactions.Tools.VertexAISearchConfig;
+    type WebhookConfig = Interactions.WebhookConfig;
+    type InteractionSseEventInteraction = Omit<Interaction, "steps" | "outputs"> & {
+      steps?: Array<Step>;
+      outputs?: Array<Step | Content>;
+    };
+    interface TextDelta {
+      type: "text";
+      text: string;
+    }
+    interface TextAnnotationDelta {
+      type: "text_annotation_delta" | "text_annotation";
+      annotations?: Array<Annotation>;
+    }
+    interface ImageDelta {
+      type: "image";
+      data?: string;
+      mime_type?: ImageContent["mime_type"];
+      resolution?: MediaResolution;
+      uri?: string;
+    }
+    interface AudioDelta {
+      type: "audio";
+      channels?: number;
+      data?: string;
+      mime_type?: AudioContent["mime_type"];
+      rate?: number;
+      sample_rate?: number;
+      uri?: string;
+    }
+    interface DocumentDelta {
+      type: "document";
+      data?: string;
+      mime_type?: DocumentContent["mime_type"];
+      uri?: string;
+    }
+    interface VideoDelta {
+      type: "video";
+      data?: string;
+      mime_type?: VideoContent["mime_type"];
+      resolution?: MediaResolution;
+      uri?: string;
+    }
+    interface ThoughtSummaryDelta {
+      type: "thought_summary";
+      content?: Content;
+    }
+    interface ThoughtSignatureDelta {
+      type: "thought_signature";
+      signature?: string;
+    }
+    interface ArgumentsDelta {
+      type: "arguments_delta" | "function_call";
+      id?: string;
+      name?: string;
+      arguments?: string | Record<string, unknown>;
+    }
+    interface CodeExecutionCallDelta {
+      type: "code_execution_call";
+      id?: string;
+      arguments?: CodeExecutionCallStepArguments;
+      signature?: string;
+    }
+    interface CodeExecutionResultDelta {
+      type: "code_execution_result";
+      call_id?: string;
+      is_error?: boolean;
+      result?: string;
+      signature?: string;
+    }
+    interface GoogleSearchCallDelta {
+      type: "google_search_call";
+      id?: string;
+      arguments?: GoogleSearchCallStepArguments;
+      signature?: string;
+    }
+    interface GoogleSearchResultDelta {
+      type: "google_search_result";
+      call_id?: string;
+      is_error?: boolean;
+      result?: Array<GoogleSearchResultItem & {
+        title?: string;
+        url?: string;
+        rendered_content?: string;
+      }>;
+      signature?: string;
+    }
+    interface UrlContextCallDelta {
+      type: "url_context_call";
+      id?: string;
+      arguments?: UrlContextCallArguments;
+      signature?: string;
+    }
+    interface UrlContextResultDelta {
+      type: "url_context_result";
+      call_id?: string;
+      is_error?: boolean;
+      result?: Array<UrlContextResult>;
+      signature?: string;
+    }
+    interface FileSearchCallDelta {
+      type: "file_search_call";
+      id?: string;
+      signature?: string;
+    }
+    interface FileSearchResultDelta {
+      type: "file_search_result";
+      call_id?: string;
+      result?: Array<FileSearchResultItem>;
+      signature?: string;
+    }
+    interface GoogleMapsCallDelta {
+      type: "google_maps_call";
+      id?: string;
+      arguments?: GoogleMapsCallArguments;
+      signature?: string;
+    }
+    interface GoogleMapsResultDelta {
+      type: "google_maps_result";
+      call_id?: string;
+      result?: Array<GoogleMapsResult>;
+      signature?: string;
+    }
+    interface McpServerToolCallDelta {
+      type: "mcp_server_tool_call";
+      id?: string;
+      name?: string;
+      server_name?: string;
+      arguments?: string | Record<string, unknown>;
+      signature?: string;
+    }
+    interface McpServerToolResultDelta {
+      type: "mcp_server_tool_result";
+      call_id?: string;
+      name?: string;
+      server_name?: string;
+      result?: Array<Content> | string | Record<string, unknown>;
+      signature?: string;
+    }
+    interface ProcessingCallDelta {
+      type: "processing_call";
+      id?: string;
+      signature?: string;
+    }
+    interface ProcessingResultDelta {
+      type: "processing_result";
+      call_id?: string;
+      signature?: string;
+    }
+    interface RetrievalCallDelta {
+      type: "retrieval_call";
+      id?: string;
+      arguments?: RetrievalCallArguments;
+      retrieval_type?: RetrievalCallStep["retrieval_type"];
+      signature?: string;
+    }
+    interface RetrievalResultDelta {
+      type: "retrieval_result";
+      call_id?: string;
+      is_error?: boolean;
+      signature?: string;
+    }
+    type StepDeltaData = TextDelta | TextAnnotationDelta | ImageDelta | AudioDelta | DocumentDelta | VideoDelta | ThoughtSummaryDelta | ThoughtSignatureDelta | ArgumentsDelta | CodeExecutionCallDelta | CodeExecutionResultDelta | GoogleSearchCallDelta | GoogleSearchResultDelta | UrlContextCallDelta | UrlContextResultDelta | FileSearchCallDelta | FileSearchResultDelta | GoogleMapsCallDelta | GoogleMapsResultDelta | McpServerToolCallDelta | McpServerToolResultDelta | ProcessingCallDelta | ProcessingResultDelta | RetrievalCallDelta | RetrievalResultDelta;
+    interface InteractionCreatedEvent {
+      event_id?: string;
+      event_type: "interaction.created" | "interaction.start";
+      interaction: InteractionSseEventInteraction;
+    }
+    interface InteractionCompletedEvent {
+      event_id?: string;
+      event_type: "interaction.completed" | "interaction.complete";
+      interaction: InteractionSseEventInteraction;
+    }
+    interface InteractionStatusUpdate {
+      continuation_token?: string;
+      event_id?: string;
+      event_type: "interaction.status_update";
+      interaction_id: string;
+      status: Interaction["status"];
+      usage?: Usage;
+    }
+    interface StepStart {
+      event_id?: string;
+      event_type: "step.start" | "content.start";
+      index: number;
+      step?: Step;
+      content?: Step | Content;
+    }
+    interface StepDelta {
+      delta: StepDeltaData;
+      event_id?: string;
+      event_type: "step.delta" | "content.delta";
+      index: number;
+      metadata?: {
+        total_usage?: Usage;
+      };
+    }
+    interface StepStop {
+      event_id?: string;
+      event_type: "step.stop" | "content.stop";
+      index: number;
+      step_usage?: Usage;
+      usage?: Usage;
+    }
+    interface ErrorEvent {
+      error?: Error;
+      event_id?: string;
+      event_type: "error";
+    }
+    type InteractionSseEvent = InteractionCreatedEvent | InteractionCompletedEvent | InteractionStatusUpdate | StepStart | StepDelta | StepStop | ErrorEvent;
+  }
+}
 /**
  * Simplified speaker/name pair for multi-speaker config.
  * - `speaker` derived from SpeakerVoiceConfig["speaker"]
  * - `name` is the prebuilt voice name
  */
 export interface SpeechSpeakerName {
-  speaker: Gemini.SpeakerVoiceConfig.Speaker;
-  name: Gemini.PrebuiltVoiceConfig.VoiceName;
+  speaker: Gemini.GenContent.SpeakerVoiceConfig.Speaker;
+  name: Gemini.GenContent.PrebuiltVoiceConfig.VoiceName;
 }
 /** A voice can be a prebuilt voice name, a speaker/name pair, or an array of pairs */
-export type SpeechVoice = Gemini.PrebuiltVoiceConfig.VoiceName | SpeechSpeakerName | SpeechSpeakerName[];
+export type SpeechVoice = Gemini.GenContent.PrebuiltVoiceConfig.VoiceName | SpeechSpeakerName | SpeechSpeakerName[];
 /** Voice with language code (derived from SpeechConfig's languageCode) */
 export interface SpeechVoiceLanguage {
   voice: SpeechVoice;
-  languageCode: Gemini.SpeechConfig.LanguageCode;
+  languageCode: Gemini.GenContent.SpeechConfig.LanguageCode;
 }
 /** Voices with language code */
 export interface SpeechVoicesLanguage {
   voices: SpeechVoice;
-  languageCode: Gemini.SpeechConfig.LanguageCode;
+  languageCode: Gemini.GenContent.SpeechConfig.LanguageCode;
 }
 /** Simplified language config (with voice or voices) */
 export type SimplifiedSpeechLanguageConfig = SpeechVoiceLanguage | SpeechVoicesLanguage;
 /** Top-level simplified config: just a voice, or voice+language */
 export type SimplifiedSpeechConfig = SpeechVoice | SimplifiedSpeechLanguageConfig;
-//#endregion
+export type { GenContent, Interactions };
 //# sourceMappingURL=types.d.ts.map