@google/adk 1.2.0 → 1.4.0

package/dist/web/common.js

@@ -8,7 +8,11 @@ const require = topLevelCreateRequire(import.meta.url);
 import { ActiveStreamingTool } from "./agents/active_streaming_tool.js";
 import { BaseAgent, isBaseAgent } from "./agents/base_agent.js";
 import { Context } from "./agents/context.js";
-import { functionsExportedForTestingOnly } from "./agents/functions.js";
+import {
+  findEventByFunctionCallId,
+  findMatchingFunctionCall,
+  functionsExportedForTestingOnly
+} from "./agents/functions.js";
 import { InvocationContext } from "./agents/invocation_context.js";
 import { LiveRequestQueue } from "./agents/live_request_queue.js";
 import { LlmAgent, LlmAgent as LlmAgent2, isLlmAgent } from "./agents/llm_agent.js";
@@ -24,13 +28,19 @@ import {
   ContentRequestProcessor
 } from "./agents/processors/content_request_processor.js";
 import { ContextCompactorRequestProcessor } from "./agents/processors/context_compactor_request_processor.js";
+import {
+  INTERACTIONS_REQUEST_PROCESSOR,
+  InteractionsRequestProcessor
+} from "./agents/processors/interactions_request_processor.js";
 import { ReadonlyContext } from "./agents/readonly_context.js";
 import { RoutedAgent, isRoutedAgent } from "./agents/routed_agent.js";
 import { StreamingMode } from "./agents/run_config.js";
 import { SequentialAgent, isSequentialAgent } from "./agents/sequential_agent.js";
+import { createResumabilityConfig } from "./apps/resumability_config.js";
 import { InMemoryArtifactService } from "./artifacts/in_memory_artifact_service.js";
 import { AuthCredentialTypes } from "./auth/auth_credential.js";
 import { AuthHandler } from "./auth/auth_handler.js";
+import { AUTH_PREPROCESSOR, AuthPreprocessor } from "./auth/auth_preprocessor.js";
 import { AuthProviderRegistry } from "./auth/auth_provider_registry.js";
 import { OAuthGrantType } from "./auth/auth_schemes.js";
 import { InMemoryCredentialService } from "./auth/credential_service/in_memory_credential_service.js";
@@ -45,8 +55,10 @@ import {
   CodeExecutionLanguage,
   FileContentEncoding
 } from "./code_executors/code_execution_utils.js";
+import { AgentControlledContextCompactor } from "./context/agent_controlled_context_compactor.js";
 import { LlmSummarizer } from "./context/summarizers/llm_summarizer.js";
 import { TokenBasedContextCompactor } from "./context/token_based_context_compactor.js";
+import { TrajectoryThoughtPruningCompactor } from "./context/trajectory_thought_pruning_compactor.js";
 import { TruncatingContextCompactor } from "./context/truncating_context_compactor.js";
 import { isCompactedEvent } from "./events/compacted_event.js";
 import {
@@ -81,7 +93,13 @@ import {
   getAskUserConfirmationFunctionCalls
 } from "./plugins/security_plugin.js";
 import { InMemoryRunner } from "./runner/in_memory_runner.js";
-import { Runner, isRunner } from "./runner/runner.js";
+import {
+  Runner,
+  determineAgentForResumption,
+  findEventByLastFunctionResponseId,
+  isRoutableLlmAgent,
+  isRunner
+} from "./runner/runner.js";
 import { BaseSessionService } from "./sessions/base_session_service.js";
 import { InMemorySessionService } from "./sessions/in_memory_session_service.js";
 import { createSession } from "./sessions/session.js";
@@ -89,6 +107,7 @@ import { State } from "./sessions/state.js";
 import { AgentTool, isAgentTool } from "./tools/agent_tool.js";
 import { BaseTool, isBaseTool } from "./tools/base_tool.js";
 import { BaseToolset, isBaseToolset } from "./tools/base_toolset.js";
+import { ConsolidateContextTool } from "./tools/consolidate_context_tool.js";
 import { EXIT_LOOP, ExitLoopTool } from "./tools/exit_loop_tool.js";
 import { FunctionTool, isFunctionTool } from "./tools/function_tool.js";
 import {
@@ -110,28 +129,55 @@ import { ToolConfirmation } from "./tools/tool_confirmation.js";
 import { URL_CONTEXT, UrlContextTool } from "./tools/url_context_tool.js";
 import { VertexAiSearchTool } from "./tools/vertex_ai_search_tool.js";
 import { VertexRagRetrievalTool } from "./tools/vertex_rag_retrieval_tool.js";
+import { getClientLabels, runWithClientLabel } from "./utils/client_labels.js";
 import { LogLevel, getLogger, setLogLevel, setLogger } from "./utils/logger.js";
-import { isGemini2OrAbove } from "./utils/model_name.js";
+import { isGemini2OrAbove, isGemini3xFlashLive } from "./utils/model_name.js";
 import { zodObjectToSchema } from "./utils/simple_zod_to_json.js";
+import { Task } from "./utils/task.js";
 import { GoogleLLMVariant } from "./utils/variant_utils.js";
 import { version } from "./version.js";
+import { GCPSkillRegistry } from "./skills/gcp_skill_registry.js";
+import {
+  loadAllSkillsInDir,
+  loadSkillFromDir,
+  loadSkillFromZipBuffer,
+  validateSkillDir
+} from "./skills/loader.js";
 import { ListSkillsTool } from "./tools/skill/list_skills_tool.js";
 import { LoadSkillResourceTool } from "./tools/skill/load_skill_resource_tool.js";
 import { LoadSkillTool } from "./tools/skill/load_skill_tool.js";
+import { SearchSkillsTool } from "./tools/skill/search_skills_tool.js";
 import { SkillToolset } from "./tools/skill/skill_toolset.js";
 export * from "./artifacts/base_artifact_service.js";
 export * from "./features/feature_registry.js";
 export * from "./memory/base_memory_service.js";
 export * from "./sessions/base_session_service.js";
 export * from "./tools/base_tool.js";
+import { OpenApiSpecParser } from "./tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.js";
+import { OperationParser } from "./tools/openapi_tool/openapi_spec_parser/operation_parser.js";
+import { ToolAuthHandler } from "./tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js";
+import { OpenAPIToolset } from "./tools/openapi_tool/openapi_toolset.js";
+import {
+  RestApiTool,
+  createRestApiTool
+} from "./tools/openapi_tool/rest_api_tool.js";
+export * from "./apps/app.js";
+export * from "./artifacts/base_artifact_service.js";
+export * from "./features/feature_registry.js";
+export * from "./memory/base_memory_service.js";
+export * from "./sessions/base_session_service.js";
+export * from "./tools/base_tool.js";
 export {
+  AUTH_PREPROCESSOR,
   ActiveStreamingTool,
   LlmAgent as Agent,
+  AgentControlledContextCompactor,
   AgentTool,
   AgentTransferLlmRequestProcessor,
   ApigeeLlm,
   AuthCredentialTypes,
   AuthHandler,
+  AuthPreprocessor,
   AuthProviderRegistry,
   BaseAgent,
   BaseCodeExecutor,
@@ -146,6 +192,7 @@ export {
   BuiltInCodeExecutor,
   CONTENT_REQUEST_PROCESSOR,
   CodeExecutionLanguage,
+  ConsolidateContextTool,
   ContentRequestProcessor,
   Context,
   ContextCompactionTrigger,
@@ -157,18 +204,21 @@ export {
   ExitLoopTool,
   FileContentEncoding,
   FunctionTool,
+  GCPSkillRegistry,
   GOOGLE_MAPS_GROUNDING,
   GOOGLE_SEARCH,
   Gemini,
   GoogleLLMVariant,
   GoogleMapsGroundingTool,
   GoogleSearchTool,
+  INTERACTIONS_REQUEST_PROCESSOR,
   InMemoryArtifactService,
   InMemoryCredentialService,
   InMemoryMemoryService,
   InMemoryPolicyEngine,
   InMemoryRunner,
   InMemorySessionService,
+  InteractionsRequestProcessor,
   InvocationContext,
   LLMRegistry,
   LOAD_ARTIFACTS,
@@ -188,6 +238,9 @@ export {
   OAuth2CredentialExchanger,
   OAuth2DiscoveryManager,
   OAuthGrantType,
+  OpenAPIToolset,
+  OpenApiSpecParser,
+  OperationParser,
   PRELOAD_MEMORY,
   ParallelAgent,
   PluginManager,
@@ -195,17 +248,22 @@ export {
   PreloadMemoryTool,
   REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
   ReadonlyContext,
+  RestApiTool,
   RoutedAgent,
   RoutedLlm,
   Runner,
+  SearchSkillsTool,
   SecurityPlugin,
   SequentialAgent,
   SessionStateCredentialService,
   SkillToolset,
   State,
   StreamingMode,
+  Task,
   TokenBasedContextCompactor,
+  ToolAuthHandler,
   ToolConfirmation,
+  TrajectoryThoughtPruningCompactor,
   TruncatingContextCompactor,
   URL_CONTEXT,
   UrlContextTool,
@@ -214,10 +272,17 @@ export {
   VertexRagRetrievalTool,
   createEvent,
   createEventActions,
+  createRestApiTool,
+  createResumabilityConfig,
   createSession,
+  determineAgentForResumption,
+  findEventByFunctionCallId,
+  findEventByLastFunctionResponseId,
+  findMatchingFunctionCall,
   functionsExportedForTestingOnly,
   geminiInitParams,
   getAskUserConfirmationFunctionCalls,
+  getClientLabels,
   getFunctionCalls,
   getFunctionResponses,
   getLogger,
@@ -232,16 +297,23 @@ export {
   isFinalResponse,
   isFunctionTool,
   isGemini2OrAbove,
+  isGemini3xFlashLive,
   isLlmAgent,
   isLoopAgent,
   isParallelAgent,
+  isRoutableLlmAgent,
   isRoutedAgent,
   isRunner,
   isSequentialAgent,
+  loadAllSkillsInDir,
+  loadSkillFromDir,
+  loadSkillFromZipBuffer,
+  runWithClientLabel,
   setLogLevel,
   setLogger,
   stringifyContent,
   toStructuredEvents,
+  validateSkillDir,
   version,
   zodObjectToSchema
 };

package/dist/web/context/agent_controlled_context_compactor.js

@@ -0,0 +1,81 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isCompactedEvent } from "../events/compacted_event.js";
+import { createEvent } from "../events/event.js";
+import { ContextCompactionTrigger } from "../plugins/base_plugin.js";
+class AgentControlledContextCompactor {
+  constructor(options) {
+    this.trigger = ContextCompactionTrigger.AgentControlled;
+    this.summarizer = options.summarizer;
+  }
+  shouldCompact(invocationContext) {
+    return invocationContext.session.state["temp:consolidate_context"] === true;
+  }
+  async compact(invocationContext) {
+    const events = invocationContext.session.events;
+    const activeEvents = this.getActiveEvents(events);
+    const consolidateToolCallIndex = activeEvents.reduce(
+      (acc, e, idx) => {
+        var _a, _b;
+        return ((_b = (_a = e.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some(
+          (p) => {
+            var _a2;
+            return ((_a2 = p.functionCall) == null ? void 0 : _a2.name) === "consolidate_context";
+          }
+        )) ? idx : acc;
+      },
+      -1
+    );
+    if (consolidateToolCallIndex <= 0) {
+      this.clearFlags(invocationContext);
+      return;
+    }
+    const eventsToCompact = activeEvents.slice(0, consolidateToolCallIndex);
+    const detail = invocationContext.session.state["temp:consolidate_context_detail"];
+    if (detail) {
+      eventsToCompact.push(
+        createEvent({
+          author: "system",
+          timestamp: eventsToCompact[eventsToCompact.length - 1].timestamp,
+          content: {
+            role: "user",
+            parts: [
+              {
+                text: "CRITICAL INSTRUCTION FOR SUMMARY: Please summarize the history. Focus especially on: ".concat(detail)
+              }
+            ]
+          }
+        })
+      );
+    }
+    try {
+      const compactedEvent = await this.summarizer.summarize(eventsToCompact);
+      invocationContext.session.events.push(compactedEvent);
+    } catch (error) {
+      console.error("Compaction failed:", error);
+    } finally {
+      this.clearFlags(invocationContext);
+    }
+  }
+  clearFlags(invocationContext) {
+    delete invocationContext.session.state["temp:consolidate_context"];
+    delete invocationContext.session.state["temp:consolidate_context_detail"];
+  }
+  getActiveEvents(events) {
+    const latest = events.filter(isCompactedEvent).pop();
+    return latest ? [
+      latest,
+      ...events.filter(
+        (e) => !isCompactedEvent(e) && e.timestamp > latest.endTime
+      )
+    ] : events;
+  }
+}
+export {
+  AgentControlledContextCompactor
+};

package/dist/web/context/summarizers/llm_summarizer.js

@@ -13,10 +13,21 @@ import {
 import { stringifyContent } from "../../events/event.js";
 const DEFAULT_PROMPT = "The following is a conversation history between a user and an AI agent. Please summarize the conversation, focusing on key information and decisions made, as well as any unresolved questions or tasks. The summary should be concise and capture the essence of the interaction.";
 class LlmSummarizer {
+  /**
+   * @param options - Configuration specifying the LLM and optional prompt.
+   */
   constructor(options) {
     this.llm = options.llm;
     this.prompt = options.prompt || DEFAULT_PROMPT;
   }
+  /**
+   * Summarizes a list of events into a single {@link CompactedEvent} using the
+   * configured LLM.
+   *
+   * @param events - The events to summarize. Must be non-empty.
+   * @returns A promise resolving to the compacted representation.
+   * @throws {Error} If `events` is empty or the LLM returns no content.
+   */
   async summarize(events) {
     var _a, _b, _c, _d, _e, _f;
     if (events.length === 0) {

package/dist/web/context/token_based_context_compactor.js

@@ -5,8 +5,9 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { getContents } from "../agents/processors/content_processor_utils.js";
 import { isCompactedEvent } from "../events/compacted_event.js";
-import { stringifyContent } from "../events/event.js";
+const CHARS_PER_TOKEN = 4;
 class TokenBasedContextCompactor {
   constructor(options) {
     this.tokenThreshold = options.tokenThreshold;
@@ -38,11 +39,14 @@ class TokenBasedContextCompactor {
     if (rawEvents.length <= this.eventRetentionSize) {
       return false;
     }
-    let totalTokens = 0;
-    for (const event of activeEvents) {
-      totalTokens += getEventTokens(event);
+    const promptTokenCount = latestPromptTokenCount(
+      activeEvents,
+      invocationContext
+    );
+    if (promptTokenCount === void 0) {
+      return false;
     }
-    return totalTokens > this.tokenThreshold;
+    return promptTokenCount > this.tokenThreshold;
   }
   async compact(invocationContext) {
     const events = invocationContext.session.events;
@@ -75,20 +79,48 @@ class TokenBasedContextCompactor {
       compactedEvent.actions = {
         stateDelta: {},
         artifactDelta: {},
-        requestedAuthConfigs: [],
+        requestedAuthConfigs: {},
         requestedToolConfirmations: {}
       };
     }
     invocationContext.session.events.push(compactedEvent);
   }
 }
-function getEventTokens(event) {
+function latestPromptTokenCount(activeEvents, invocationContext) {
+  var _a;
+  for (let i = activeEvents.length - 1; i >= 0; i--) {
+    const count = (_a = activeEvents[i].usageMetadata) == null ? void 0 : _a.promptTokenCount;
+    if (count !== void 0) {
+      return count;
+    }
+  }
+  return estimatePromptTokenCount(activeEvents, invocationContext);
+}
+function estimatePromptTokenCount(activeEvents, invocationContext) {
   var _a;
-  if (((_a = event.usageMetadata) == null ? void 0 : _a.promptTokenCount) !== void 0) {
-    return event.usageMetadata.promptTokenCount;
+  const contents = getContents(
+    activeEvents,
+    invocationContext.agent.name,
+    invocationContext.branch
+  );
+  let totalChars = 0;
+  for (const content of contents) {
+    for (const part of (_a = content.parts) != null ? _a : []) {
+      if (part.text) {
+        totalChars += part.text.length;
+      }
+      if (part.functionCall) {
+        totalChars += JSON.stringify(part.functionCall).length;
+      }
+      if (part.functionResponse) {
+        totalChars += JSON.stringify(part.functionResponse).length;
+      }
+    }
+  }
+  if (totalChars <= 0) {
+    return void 0;
   }
-  const contentStr = stringifyContent(event);
-  return Math.ceil(contentStr.length / 4);
+  return Math.ceil(totalChars / CHARS_PER_TOKEN);
 }
 function hasFunctionCall(event) {
   var _a, _b;

package/dist/web/context/trajectory_thought_pruning_compactor.js

@@ -0,0 +1,43 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { hasThoughts, pruneThoughts } from "../events/event.js";
+class TrajectoryThoughtPruningCompactor {
+  constructor(options) {
+    if (options.eventRetentionSize < 0) {
+      throw new Error("eventRetentionSize must be a non-negative integer.");
+    }
+    this.eventRetentionSize = options.eventRetentionSize;
+  }
+  shouldCompact(invocationContext) {
+    const events = invocationContext.session.events;
+    if (events.length <= this.eventRetentionSize) {
+      return false;
+    }
+    const olderEvents = events.slice(
+      0,
+      events.length - this.eventRetentionSize
+    );
+    return olderEvents.some((event) => hasThoughts(event));
+  }
+  compact(invocationContext) {
+    const events = invocationContext.session.events;
+    if (events.length <= this.eventRetentionSize) {
+      return;
+    }
+    const pruneLimit = events.length - this.eventRetentionSize;
+    for (let i = 0; i < pruneLimit; i++) {
+      const event = events[i];
+      if (hasThoughts(event)) {
+        events[i] = pruneThoughts(event);
+      }
+    }
+  }
+}
+export {
+  TrajectoryThoughtPruningCompactor
+};

package/dist/web/events/event.js

@@ -38,7 +38,7 @@ function createEvent(params = {}) {
   });
 }
 function isFinalResponse(event) {
-  if (event.actions.skipSummarization || event.longRunningToolIds && event.longRunningToolIds.length > 0) {
+  if (event.actions.skipSummarization || event.longRunningToolIds && event.longRunningToolIds.length > 0 || event.actions.requestedAuthConfigs && Object.keys(event.actions.requestedAuthConfigs).length > 0) {
     return true;
   }
   return getFunctionCalls(event).length === 0 && getFunctionResponses(event).length === 0 && !event.partial && !hasTrailingCodeExecutionResult(event);
@@ -83,6 +83,24 @@ function stringifyContent(event) {
     return (_a2 = part.text) != null ? _a2 : "";
   }).join("");
 }
+function hasThoughts(event) {
+  var _a, _b;
+  return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some((part) => part.thought === true));
+}
+function pruneThoughts(event) {
+  var _a;
+  if (!((_a = event.content) == null ? void 0 : _a.parts)) {
+    return event;
+  }
+  const prunedParts = event.content.parts.filter(
+    (part) => part.thought !== true
+  );
+  return __spreadProps(__spreadValues({}, event), {
+    content: __spreadProps(__spreadValues({}, event.content), {
+      parts: prunedParts
+    })
+  });
+}
 const ASCII_LETTERS_AND_NUMBERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 function createNewEventId() {
   let id = "";
@@ -122,8 +140,10 @@ export {
   createNewEventId,
   getFunctionCalls,
   getFunctionResponses,
+  hasThoughts,
   hasTrailingCodeExecutionResult,
   isFinalResponse,
+  pruneThoughts,
   stringifyContent,
   transformToCamelCaseEvent,
   transformToSnakeCaseEvent

package/dist/web/integrations/agent_registry/agent_registry_mcp_toolset.js

@@ -31,6 +31,19 @@ import {
 import { MCPTool } from "../../tools/mcp/mcp_tool.js";
 import { GCP_MCP_SERVER_DESTINATION_ID } from "./types.js";
 class AgentRegistrySingleMCPToolset extends BaseToolset {
+  /**
+   * @param options - Configuration for the MCP toolset.
+   * @param options.destinationResourceId - Telemetry identifier injected as
+   *   `gcp.mcp.server.destination.id` into each resolved tool's custom metadata.
+   * @param options.connectionParams - HTTP connection parameters for the MCP server.
+   * @param options.toolFilter - Optional predicate or list of tool names to include.
+   *   When omitted, all tools from the server are returned.
+   * @param options.prefix - Optional prefix prepended to each tool name (e.g. `myServer_toolName`).
+   * @param options.headerProvider - Optional async function called immediately before each
+   *   {@link getTools} invocation to supply or refresh request headers (e.g. GCP auth tokens).
+   * @param options.authScheme - Optional auth scheme forwarded to each resolved tool.
+   * @param options.authCredential - Optional credential forwarded to each resolved tool.
+   */
   constructor(options) {
     super(options.toolFilter || [], options.prefix);
     this.destinationResourceId = options.destinationResourceId;
@@ -40,8 +53,14 @@ class AgentRegistrySingleMCPToolset extends BaseToolset {
     this.authCredential = options.authCredential;
   }
   /**
-   * Connects to the underlying MCP server, retrieves tool definitions, prefixes tool names,
-   * and injects destination telemetry metadata.
+   * Connects to the underlying MCP server, retrieves tool definitions, prefixes
+   * tool names, and injects destination telemetry metadata into each tool.
+   *
+   * The `headerProvider`, if configured, is invoked immediately before the
+   * connection is established so that tokens are always fresh.
+   *
+   * @param context - Optional readonly agent context passed to the header provider.
+   * @returns The resolved and optionally filtered list of {@link MCPTool} instances.
    */
   async getTools(context) {
     var _a, _b, _c;

package/dist/web/models/gemini_llm_connection.js

@@ -16,15 +16,20 @@ var __asyncGenerator = (__this, __arguments, generator) => {
   }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
   return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
 };
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { LiveResponseAggregator } from "../utils/live_connection_utils.js";
 import { logger } from "../utils/logger.js";
+import { isGemini3xFlashLive } from "../utils/model_name.js";
 class GeminiLlmConnection {
-  constructor(geminiSession) {
+  constructor(geminiSession, modelVersion, messageQueue) {
     this.geminiSession = geminiSession;
+    this.modelVersion = modelVersion;
+    this.messageQueue = messageQueue;
   }
   /**
    * Sends the conversation history to the gemini model.
@@ -43,9 +48,10 @@ class GeminiLlmConnection {
       }
     );
     if (contents.length > 0) {
+      const isGemini3x = isGemini3xFlashLive(this.modelVersion);
       this.geminiSession.sendClientContent({
         turns: contents,
-        turnComplete: contents[contents.length - 1].role === "user"
+        turnComplete: isGemini3x ? true : contents[contents.length - 1].role === "user"
       });
     } else {
       logger.info("no content is sent");
@@ -72,10 +78,16 @@ class GeminiLlmConnection {
       });
     } else {
       logger.debug("Sending LLM new content", content);
-      this.geminiSession.sendClientContent({
-        turns: [content],
-        turnComplete: true
-      });
+      const isGemini3x = isGemini3xFlashLive(this.modelVersion);
+      if (isGemini3x && content.parts.length === 1 && content.parts[0].text) {
+        logger.debug("Using sendRealtimeInput for Gemini 3.x text input");
+        this.geminiSession.sendRealtimeInput({ text: content.parts[0].text });
+      } else {
+        this.geminiSession.sendClientContent({
+          turns: [content],
+          turnComplete: true
+        });
+      }
     }
   }
   /**
@@ -84,8 +96,36 @@ class GeminiLlmConnection {
    * @param blob The blob to send to the model.
    */
   async sendRealtime(blob) {
+    var _a, _b, _c;
     logger.debug("Sending LLM Blob:", blob);
-    this.geminiSession.sendRealtimeInput({ media: blob });
+    const isGemini3x = isGemini3xFlashLive(this.modelVersion);
+    const isNativeAudio = (_a = this.modelVersion) == null ? void 0 : _a.includes("native-audio");
+    if (isGemini3x || isNativeAudio) {
+      if ((_b = blob.mimeType) == null ? void 0 : _b.startsWith("audio/")) {
+        this.geminiSession.sendRealtimeInput({ audio: blob });
+      } else if ((_c = blob.mimeType) == null ? void 0 : _c.startsWith("image/")) {
+        this.geminiSession.sendRealtimeInput({ video: blob });
+      } else {
+        logger.warn(
+          "Blob not sent. Unknown or empty mime type for sendRealtimeInput:",
+          blob.mimeType
+        );
+      }
+    } else {
+      this.geminiSession.sendRealtimeInput({ media: blob });
+    }
+  }
+  /**
+   * Sends an activity start signal to the model.
+   */
+  async sendActivityStart() {
+    this.geminiSession.sendRealtimeInput({ activityStart: {} });
+  }
+  /**
+   * Sends an activity end signal to the model.
+   */
+  async sendActivityEnd() {
+    this.geminiSession.sendRealtimeInput({ activityEnd: {} });
   }
   /**
    * Builds a full text response.
@@ -94,21 +134,37 @@ class GeminiLlmConnection {
    * partial.
    *
    * @param text The text to be included in the response.
+   * @param isThought Whether the text is a thought.
+   * @param groundingMetadata The grounding metadata to include.
    * @returns An LlmResponse containing the full text.
    */
-  buildFullTextResponse(text) {
-    return {
-      content: {
-        role: "model",
-        parts: [{ text }]
-      }
-    };
-  }
-  // TODO(b/425992518): GenAI SDK inconsistent API, missing methods.
-  // eslint-disable-next-line require-yield
   receive() {
     return __asyncGenerator(this, null, function* () {
-      throw new Error("Not Implemented.");
+      if (!this.messageQueue) {
+        throw new Error("Message queue is not initialized.");
+      }
+      const aggregator = new LiveResponseAggregator(this.modelVersion);
+      try {
+        for (var iter = __forAwait(this.messageQueue), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const message = temp.value;
+          logger.debug("Got LLM Live message:", message);
+          for (const response of aggregator.processMessage(message)) {
+            yield response;
+          }
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      for (const response of aggregator.close()) {
+        yield response;
+      }
     });
   }
   /**