@langchain/google 0.2.12 → 0.2.14

package/dist/chat_models/types.d.ts

@@ -1,12 +1,12 @@
 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 { GoogleChatApiHandler } from "./handlers/base.js";
 import { BaseChatModelCallOptions, BaseChatModelParams, BindToolsInput } from "@langchain/core/language_models/chat_models";
 import { InteropZodType } from "@langchain/core/utils/types";
 import { SerializableSchema } from "@langchain/core/utils/standard_schema";
 import { AsyncCaller } from "@langchain/core/utils/async_caller";
-//#region src/chat_models/types.d.ts
 export interface BaseChatGoogleFields {
   /**
    * The temperature is used for sampling during response generation, which
@@ -120,8 +120,6 @@ export interface BaseChatGoogleFields {
    * string value in the Gemini API.
    */
   mediaResolution?: Gemini.Shared.MediaResolution;
-}
-export interface GenerateContentSpecificFields {
   /**
    * The schema that the generated response should match.
    * Can be a Zod schema or a JSON Schema object.
@@ -139,26 +137,10 @@ export interface GenerateContentSpecificFields {
    * An empty list is equivalent to requesting only text.
    */
   responseModalities?: Prettify<GenContent.GenerativeLanguageModality>[];
-  /**
-   * 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.
-   */
-  responseLogprobs?: boolean;
-  /**
-   * 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.
-   */
-  logprobs?: number;
   /**
    * Configuration for the model's thinking process
    */
   thinkingConfig?: Prettify<GenContent.ThinkingConfig>;
-  /**
-   * If true, enables enhanced civic answers feature.
-   */
-  enableEnhancedCivicAnswers?: boolean;
   /**
    * Speech generation configuration.
    * You can use either Google's definition of the speech configuration,
@@ -178,8 +160,60 @@ export interface GenerateContentSpecificFields {
    */
   serviceTier?: GenContent.ServiceTier;
 }
+export interface GenerateContentSpecificFields {
+  /**
+   * 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.
+   */
+  responseLogprobs?: boolean;
+  /**
+   * 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.
+   */
+  logprobs?: number;
+  /**
+   * If true, enables enhanced civic answers feature.
+   */
+  enableEnhancedCivicAnswers?: boolean;
+}
+export interface InteractionsSpecificFields {
+  /**
+   * 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.
+   */
+  responseFormat?: Gemini.Interactions.CreateInteractionParameters["response_format"];
+  /**
+   * The ID of a previous interaction to continue a stateful server-side conversation.
+   */
+  previousInteractionId?: string;
+  /**
+   * Whether to store the interaction on the server.
+   */
+  store?: boolean;
+  /**
+   * 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 ChatGoogleFields extends BaseChatGoogleFields, Partial<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;
@@ -211,11 +245,13 @@ export interface GoogleChatApiHandlerParams extends BaseChatModelParams, BaseCha
   customHeaders?: Record<string, string>;
 }
 export interface GenerateContentApiHandlerParams extends GoogleChatApiHandlerParams, GenerateContentSpecificFields {}
+export interface InteractionsApiHandlerParams extends GoogleChatApiHandlerParams, InteractionsSpecificFields {}
 export type GoogleChatApiHandlerFactory = (params: GoogleChatApiHandlerParams) => GoogleChatApiHandler;
-export type GoogleChatApiHandlerConfig = "generateContent" | GoogleChatApiHandlerFactory;
+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 {
@@ -327,6 +363,7 @@ export declare namespace Gemini {
       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;
@@ -392,6 +429,7 @@ export declare namespace Gemini {
     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;
@@ -432,6 +470,470 @@ export declare namespace Gemini {
     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.
@@ -458,6 +960,5 @@ export interface SpeechVoicesLanguage {
 export type SimplifiedSpeechLanguageConfig = SpeechVoiceLanguage | SpeechVoicesLanguage;
 /** Top-level simplified config: just a voice, or voice+language */
 export type SimplifiedSpeechConfig = SpeechVoice | SimplifiedSpeechLanguageConfig;
-//#endregion
-export type { GenContent };
+export type { GenContent, Interactions };
 //# sourceMappingURL=types.d.ts.map

package/dist/chat_models/types.js

@@ -1,6 +1,5 @@
-//#region src/chat_models/types.ts
+// src/chat_models/types.ts
 const settableServiceTier = ["flex", "priority"];
-//#endregion
 export { settableServiceTier };
 
 //# sourceMappingURL=types.js.map