@google/adk 1.6.0 → 2.0.0

package/dist/web/agents/llm_agent.js

@@ -1,6 +1,8 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -20,6 +22,8 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __await = function(promise, isYieldStar) {
   this[0] = promise;
   this[1] = isYieldStar;
@@ -71,7 +75,12 @@ var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")])
  */
 var _a, _b;
 import { context, trace } from "@opentelemetry/api";
+import { FinishTaskTool } from "../tools/finish_task_tool.js";
 import { FunctionTool } from "../tools/function_tool.js";
+import { AsyncQueue } from "../utils/async_queue.js";
+import { isBaseNode } from "../workflow/base_node.js";
+import { NodeTool } from "../workflow/nodes/node_tool.js";
+import { runLlmAgentAsNode } from "../workflow/run_llm_agent_as_node.js";
 import {
   createEvent,
   createNewEventId,
@@ -91,6 +100,7 @@ import {
   traceCallLlm,
   tracer
 } from "../telemetry/tracing.js";
+import { parseWithSchema } from "../utils/schema.js";
 import { isZodObject, zodObjectToSchema } from "../utils/simple_zod_to_json.js";
 import { BaseAgent } from "./base_agent.js";
 import {
@@ -100,6 +110,7 @@ import {
   handleFunctionCallsAsync
 } from "./functions.js";
 import { AUTH_PREPROCESSOR } from "../auth/auth_preprocessor.js";
+import { requireAgent } from "./invocation_context.js";
 import { AGENT_TRANSFER_LLM_REQUEST_PROCESSOR } from "./processors/agent_transfer_llm_request_processor.js";
 import { BASIC_LLM_REQUEST_PROCESSOR } from "./processors/basic_llm_request_processor.js";
 import { CODE_EXECUTION_REQUEST_PROCESSOR } from "./processors/code_execution_request_processor.js";
@@ -109,48 +120,112 @@ import { IDENTITY_LLM_REQUEST_PROCESSOR } from "./processors/identity_llm_reques
 import { INSTRUCTIONS_LLM_REQUEST_PROCESSOR } from "./processors/instructions_llm_request_processor.js";
 import { INTERACTIONS_REQUEST_PROCESSOR } from "./processors/interactions_request_processor.js";
 import { REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR } from "./processors/request_confirmation_llm_request_processor.js";
+import { REQUEST_INPUT_LLM_REQUEST_PROCESSOR } from "./processors/request_input_llm_request_processor.js";
 import { TOOL_FILTER_REQUEST_PROCESSOR } from "./processors/tool_filter_request_processor.js";
 import { ReadonlyContext } from "./readonly_context.js";
 import { StreamingMode } from "./run_config.js";
+const MAX_LIVE_RECONNECT_ATTEMPTS = 5;
+const TRANSFER_AGENT_DELAY_MS = 1e3;
+const _LiveReconnectSignal = class _LiveReconnectSignal extends Error {
+  constructor(reason) {
+    super("live reconnect requested: ".concat(reason));
+    this.reason = reason;
+    this.name = "LiveReconnectSignal";
+  }
+};
+__name(_LiveReconnectSignal, "LiveReconnectSignal");
+let LiveReconnectSignal = _LiveReconnectSignal;
+function isRecoverableLiveError(err) {
+  var _a2;
+  if (err instanceof LiveReconnectSignal) return true;
+  if (!(err instanceof Error)) return false;
+  const code = err.code;
+  if (code === 1006 || code === 1011 || code === 1012) {
+    return true;
+  }
+  const message = (_a2 = err.message) != null ? _a2 : "";
+  return /ConnectionClosed|connection closed|ECONNRESET|socket hang up/i.test(
+    message
+  );
+}
+__name(isRecoverableLiveError, "isRecoverableLiveError");
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(sleep, "sleep");
+const LIVE_KEYS = [
+  "responseModalities",
+  "speechConfig",
+  "outputAudioTranscription",
+  "inputAudioTranscription",
+  "realtimeInputConfig",
+  "contextWindowCompression",
+  "proactivity",
+  "enableAffectiveDialog"
+];
+function applyLiveRunConfig(runConfig, llmRequest) {
+  var _a2;
+  if (!runConfig) return;
+  const liveConfig = (_a2 = llmRequest.liveConnectConfig) != null ? _a2 : llmRequest.liveConnectConfig = {};
+  for (const k of LIVE_KEYS) {
+    if (runConfig[k] !== void 0) {
+      liveConfig[k] = runConfig[k];
+    }
+  }
+}
+__name(applyLiveRunConfig, "applyLiveRunConfig");
 const ADK_AGENT_NAME_LABEL_KEY = "adk_agent_name";
 async function convertToolUnionToTools(toolUnion, context2) {
   if (isBaseTool(toolUnion)) {
     return [toolUnion];
   }
+  if (isBaseNode(toolUnion)) {
+    return [new NodeTool(toolUnion)];
+  }
   return await toolUnion.getTools(context2);
 }
+__name(convertToolUnionToTools, "convertToolUnionToTools");
 const LLM_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.llmAgent");
 function isLlmAgent(obj) {
   return typeof obj === "object" && obj !== null && LLM_AGENT_SIGNATURE_SYMBOL in obj && obj[LLM_AGENT_SIGNATURE_SYMBOL] === true;
 }
-class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
+__name(isLlmAgent, "isLlmAgent");
+const _LlmAgent = class _LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
   constructor(config) {
-    var _a2, _b2, _c, _d, _e, _f, _g, _h, _i;
-    super(config);
+    var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    super(__spreadProps(__spreadValues({}, config), {
+      rerunOnResume: (_a2 = config.rerunOnResume) != null ? _a2 : true,
+      waitForOutput: (_b2 = config.waitForOutput) != null ? _b2 : config.mode === "task"
+    }));
     /** A unique symbol to identify ADK LLM agent class. */
     this[_a] = true;
     this.model = config.model;
-    this.instruction = (_a2 = config.instruction) != null ? _a2 : "";
-    this.globalInstruction = (_b2 = config.globalInstruction) != null ? _b2 : "";
-    this.tools = (_c = config.tools) != null ? _c : [];
+    this.instruction = (_c = config.instruction) != null ? _c : "";
+    this.globalInstruction = (_d = config.globalInstruction) != null ? _d : "";
+    this.tools = (_e = config.tools) != null ? _e : [];
     this.generateContentConfig = config.generateContentConfig;
-    this.disallowTransferToParent = (_d = config.disallowTransferToParent) != null ? _d : false;
-    this.disallowTransferToPeers = (_e = config.disallowTransferToPeers) != null ? _e : false;
-    this.includeContents = (_f = config.includeContents) != null ? _f : "default";
+    this.disallowTransferToParent = (_f = config.disallowTransferToParent) != null ? _f : false;
+    this.disallowTransferToPeers = (_g = config.disallowTransferToPeers) != null ? _g : false;
+    this.includeContents = (_h = config.includeContents) != null ? _h : "default";
+    this.includeContentsExplicit = config.includeContents !== void 0;
+    this.inputSchemaSource = config.inputSchema;
+    this.outputSchemaSource = config.outputSchema;
     this.inputSchema = isZodObject(config.inputSchema) ? zodObjectToSchema(config.inputSchema) : config.inputSchema;
     this.outputSchema = isZodObject(config.outputSchema) ? zodObjectToSchema(config.outputSchema) : config.outputSchema;
+    this.mode = config.mode;
     this.outputKey = config.outputKey;
     this.beforeModelCallback = config.beforeModelCallback;
     this.afterModelCallback = config.afterModelCallback;
     this.beforeToolCallback = config.beforeToolCallback;
     this.afterToolCallback = config.afterToolCallback;
     this.codeExecutor = config.codeExecutor;
-    this.requestProcessors = (_g = config.requestProcessors) != null ? _g : [
+    this.requestProcessors = (_i = config.requestProcessors) != null ? _i : [
       BASIC_LLM_REQUEST_PROCESSOR,
       AUTH_PREPROCESSOR,
       IDENTITY_LLM_REQUEST_PROCESSOR,
       INSTRUCTIONS_LLM_REQUEST_PROCESSOR,
       REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
+      REQUEST_INPUT_LLM_REQUEST_PROCESSOR,
       CONTENT_REQUEST_PROCESSOR,
       INTERACTIONS_REQUEST_PROCESSOR,
       CODE_EXECUTION_REQUEST_PROCESSOR,
@@ -172,8 +247,8 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
         );
       }
     }
-    this.responseProcessors = (_h = config.responseProcessors) != null ? _h : [];
-    const agentTransferDisabled = this.disallowTransferToParent && this.disallowTransferToPeers && !((_i = this.subAgents) == null ? void 0 : _i.length);
+    this.responseProcessors = (_j = config.responseProcessors) != null ? _j : [];
+    const agentTransferDisabled = this.disallowTransferToParent && this.disallowTransferToPeers && !((_k = this.subAgents) == null ? void 0 : _k.length);
     if (!agentTransferDisabled) {
       this.requestProcessors.push(AGENT_TRANSFER_LLM_REQUEST_PROCESSOR);
     }
@@ -195,13 +270,14 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
       this.generateContentConfig = {};
     }
     if (this.outputSchema) {
-      if (!this.disallowTransferToParent || !this.disallowTransferToPeers) {
+      const transferRequested = config.disallowTransferToParent === false || config.disallowTransferToPeers === false || !!((_l = this.subAgents) == null ? void 0 : _l.length);
+      if (transferRequested) {
         logger.warn(
           "Invalid config for agent ".concat(this.name, ": outputSchema cannot co-exist with agent transfer configurations. Setting disallowTransferToParent=true, disallowTransferToPeers=true")
         );
-        this.disallowTransferToParent = true;
-        this.disallowTransferToPeers = true;
       }
+      this.disallowTransferToParent = true;
+      this.disallowTransferToPeers = true;
     }
   }
   /**
@@ -225,6 +301,16 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
     }
     throw new Error("No model found for ".concat(this.name, "."));
   }
+  /**
+   * The `finish_task` tool for this agent (task mode). Lazily created and cached
+   * so its declaration (derived from `outputSchema`) is stable across turns.
+   */
+  get finishTaskTool() {
+    if (!this._finishTaskTool) {
+      this._finishTaskTool = new FinishTaskTool(this.outputSchema);
+    }
+    return this._finishTaskTool;
+  }
   /**
    * The resolved instruction field to construct instruction for this
    * agent.
@@ -297,7 +383,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
    * This method is only for use by Agent Development Kit.
    */
   get canonicalBeforeModelCallbacks() {
-    return LlmAgent.normalizeCallbackArray(this.beforeModelCallback);
+    return _LlmAgent.normalizeCallbackArray(this.beforeModelCallback);
   }
   /**
    * The resolved afterModelCallback field as a list of
@@ -306,7 +392,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
    * This method is only for use by Agent Development Kit.
    */
   get canonicalAfterModelCallbacks() {
-    return LlmAgent.normalizeCallbackArray(this.afterModelCallback);
+    return _LlmAgent.normalizeCallbackArray(this.afterModelCallback);
   }
   /**
    * The resolved beforeToolCallback field as a list of
@@ -315,7 +401,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
    * This method is only for use by Agent Development Kit.
    */
   get canonicalBeforeToolCallbacks() {
-    return LlmAgent.normalizeCallbackArray(this.beforeToolCallback);
+    return _LlmAgent.normalizeCallbackArray(this.beforeToolCallback);
   }
   /**
    * The resolved afterToolCallback field as a list of AfterToolCallback.
@@ -323,7 +409,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
    * This method is only for use by Agent Development Kit.
    */
   get canonicalAfterToolCallbacks() {
-    return LlmAgent.normalizeCallbackArray(this.afterToolCallback);
+    return _LlmAgent.normalizeCallbackArray(this.afterToolCallback);
   }
   /**
    * Saves the agent's final response to the session state if configured.
@@ -366,14 +452,55 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
       if (!resultStr.trim()) {
         return;
       }
+      let parsed;
       try {
-        result = JSON.parse(resultStr);
+        parsed = JSON.parse(resultStr);
       } catch (e) {
         logger.error("Error parsing output for agent ".concat(this.name), e);
+        event.actions.stateDelta[this.outputKey] = resultStr;
+        return;
+      }
+      try {
+        result = this.validateOutput(parsed);
+      } catch (e) {
+        logger.error(
+          "Output for agent ".concat(this.name, " does not satisfy its output schema"),
+          e
+        );
+        result = parsed;
       }
     }
     event.actions.stateDelta[this.outputKey] = result;
   }
+  /**
+   * Validates a value against this agent's output schema, in whichever dialect
+   * it was declared, and returns the parsed value.
+   *
+   * Prefers the schema as supplied ({@link outputSchemaSource}) over the genai
+   * form derived from it, since the conversion drops constraints Zod can
+   * express and genai cannot.
+   *
+   * @throws if the value does not satisfy the schema.
+   */
+  validateOutput(value) {
+    var _a2;
+    return parseWithSchema((_a2 = this.outputSchemaSource) != null ? _a2 : this.outputSchema, value);
+  }
+  /**
+   * Runs this agent as a workflow node.
+   *
+   * Where {@link BaseAgent.runImpl} delegates straight to `runAsync`, an
+   * `LlmAgent` has a node input to inject into the conversation, instruction
+   * placeholders to resolve against it, a reply to promote to node output, and
+   * — in `task` mode — a `finish_task` round-trip to drive. All of that lives
+   * in `runLlmAgentAsNode`, mirroring adk-python's `LlmAgent._run_impl`
+   * delegating to `run_llm_agent_as_node`.
+   */
+  runImpl(ctx, nodeInput) {
+    return __asyncGenerator(this, null, function* () {
+      yield* __yieldStar(runLlmAgentAsNode(this, ctx, nodeInput));
+    });
+  }
   runAsyncImpl(context2) {
     return __asyncGenerator(this, null, function* () {
       var _a2, _b2;
@@ -461,11 +588,423 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
    * times. Subsequent reconnects skip `sendHistory` because the server
    * already holds the conversation state associated with the handle.
    */
-  // eslint-disable-next-line require-yield
-  runLiveFlow(_invocationContext) {
+  runLiveFlow(invocationContext) {
     return __asyncGenerator(this, null, function* () {
-      yield new __await(Promise.resolve());
-      throw new Error("LlmAgent.runLiveFlow not implemented");
+      var _a2, _b2, _c, _d;
+      if (!invocationContext.liveRequestQueue) {
+        throw new Error("liveRequestQueue is required for LlmAgent.runLiveFlow.");
+      }
+      const llmRequest = {
+        contents: [],
+        toolsDict: {},
+        liveConnectConfig: {}
+      };
+      try {
+        for (var iter = __forAwait(this.runLivePreprocess(
+          invocationContext,
+          llmRequest
+        )), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const event = temp.value;
+          yield event;
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      if (invocationContext.endInvocation || ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted)) {
+        return;
+      }
+      applyLiveRunConfig(invocationContext.runConfig, llmRequest);
+      const llm = this.canonicalModel;
+      let reconnectAttempts = 0;
+      while (true) {
+        if ((_b2 = invocationContext.abortSignal) == null ? void 0 : _b2.aborted) {
+          return;
+        }
+        const handle = invocationContext.liveSessionResumptionHandle;
+        if (handle) {
+          (_c = llmRequest.liveConnectConfig) != null ? _c : llmRequest.liveConnectConfig = {};
+          llmRequest.liveConnectConfig.sessionResumption = {
+            handle,
+            transparent: true
+          };
+        }
+        let connection;
+        try {
+          connection = yield new __await(llm.connect(llmRequest));
+        } catch (err) {
+          if (isRecoverableLiveError(err) && invocationContext.liveSessionResumptionHandle) {
+            reconnectAttempts += 1;
+            if (reconnectAttempts > MAX_LIVE_RECONNECT_ATTEMPTS) {
+              logger.error(
+                "Max live reconnection attempts reached (".concat(reconnectAttempts, ")."),
+                err
+              );
+              throw err;
+            }
+            logger.info(
+              "Live connect failed (attempt ".concat(reconnectAttempts, "); retrying with session handle."),
+              err
+            );
+            continue;
+          }
+          throw err;
+        }
+        if (llmRequest.contents.length > 0 && !invocationContext.liveSessionResumptionHandle) {
+          yield new __await(connection.sendHistory(llmRequest.contents));
+        }
+        let sendError;
+        const sendAbort = new AbortController();
+        const combinedAbort = invocationContext.abortSignal ? AbortSignal.any([invocationContext.abortSignal, sendAbort.signal]) : sendAbort.signal;
+        const sendTask = this.runSendLoop(
+          connection,
+          invocationContext.liveRequestQueue,
+          combinedAbort,
+          invocationContext.abortSignal
+        );
+        sendTask.catch((error2) => {
+          logger.error("Error in live send loop:", error2);
+          sendError = error2;
+          sendAbort.abort(error2);
+          connection.close().catch((err) => {
+            logger.warn("Error closing connection after send loop failure:", err);
+          });
+        });
+        let reconnect = false;
+        try {
+          yield* __yieldStar(this.runReceiveLoop(
+            invocationContext,
+            connection,
+            llmRequest,
+            sendAbort
+          ));
+        } catch (err) {
+          const canReconnect = !!invocationContext.liveSessionResumptionHandle && (err instanceof LiveReconnectSignal || isRecoverableLiveError(err));
+          if (canReconnect) {
+            reconnect = true;
+            logger.info(
+              "Live connection closed; will reconnect with session handle.",
+              err
+            );
+          } else {
+            yield new __await(this.teardownLiveConnection(sendAbort, connection, sendTask));
+            throw err;
+          }
+        }
+        yield new __await(this.teardownLiveConnection(sendAbort, connection, sendTask));
+        if ((_d = invocationContext.abortSignal) == null ? void 0 : _d.aborted) {
+          return;
+        }
+        if (sendError) {
+          throw sendError;
+        }
+        if (!reconnect) {
+          return;
+        }
+        reconnectAttempts += 1;
+        if (reconnectAttempts > MAX_LIVE_RECONNECT_ATTEMPTS) {
+          throw new Error(
+            "Max live reconnection attempts reached (".concat(reconnectAttempts, ").")
+          );
+        }
+      }
+    });
+  }
+  runLivePreprocess(invocationContext, llmRequest) {
+    return __asyncGenerator(this, null, function* () {
+      var _a2, _b2;
+      for (const processor of this.requestProcessors) {
+        try {
+          for (var iter = __forAwait(processor.runAsync(
+            invocationContext,
+            llmRequest
+          )), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+            const event = temp.value;
+            if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+              return;
+            }
+            yield event;
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+      }
+      for (const toolUnion of this.tools) {
+        const toolContext = new Context({ invocationContext });
+        const tools = (yield new __await(convertToolUnionToTools(
+          toolUnion,
+          new ReadonlyContext(invocationContext)
+        ))).filter(
+          (tool) => !llmRequest.allowedTools || llmRequest.allowedTools.includes(tool.name)
+        );
+        for (const tool of tools) {
+          yield new __await(tool.processLlmRequest({ toolContext, llmRequest }));
+          if ((_b2 = invocationContext.abortSignal) == null ? void 0 : _b2.aborted) {
+            return;
+          }
+        }
+      }
+    });
+  }
+  async runSendLoop(connection, liveRequestQueue, sendAbortSignal, invocationAbortSignal) {
+    while (true) {
+      if ((sendAbortSignal == null ? void 0 : sendAbortSignal.aborted) || (invocationAbortSignal == null ? void 0 : invocationAbortSignal.aborted)) {
+        return;
+      }
+      let liveRequest;
+      try {
+        liveRequest = await liveRequestQueue.get(sendAbortSignal);
+      } catch (error) {
+        if ((sendAbortSignal == null ? void 0 : sendAbortSignal.aborted) || (invocationAbortSignal == null ? void 0 : invocationAbortSignal.aborted)) {
+          return;
+        }
+        throw error;
+      }
+      try {
+        await this.dispatchLiveRequest(connection, liveRequest);
+      } catch (error) {
+        if ((sendAbortSignal == null ? void 0 : sendAbortSignal.aborted) || (invocationAbortSignal == null ? void 0 : invocationAbortSignal.aborted)) {
+          logger.debug("Send failed after teardown:", error);
+          return;
+        }
+        logger.error("Error dispatching live request to model:", error);
+        throw error;
+      }
+      await Promise.resolve();
+      if (liveRequest.close) {
+        return;
+      }
+    }
+  }
+  async dispatchLiveRequest(connection, liveRequest) {
+    var _a2, _b2;
+    if (liveRequest.close) {
+      await connection.close();
+      return;
+    }
+    if (liveRequest.activityStart) {
+      await ((_a2 = connection.sendActivityStart) == null ? void 0 : _a2.call(connection));
+      return;
+    }
+    if (liveRequest.activityEnd) {
+      await ((_b2 = connection.sendActivityEnd) == null ? void 0 : _b2.call(connection));
+      return;
+    }
+    if (liveRequest.blob) {
+      await connection.sendRealtime(liveRequest.blob);
+      return;
+    }
+    if (liveRequest.content) {
+      await connection.sendContent(liveRequest.content);
+    }
+  }
+  /**
+   * Tears down a live attempt: stops the send loop, closes the connection
+   * (swallowing close errors), and waits for the send task to settle. Used
+   * before reconnecting or propagating an error.
+   */
+  async teardownLiveConnection(sendAbort, connection, sendTask) {
+    sendAbort.abort();
+    try {
+      await connection.close();
+    } catch (error) {
+      logger.warn("Error closing live connection:", error);
+    }
+    await sendTask.catch(() => void 0);
+  }
+  runReceiveLoop(invocationContext, connection, llmRequest, sendAbort) {
+    return __asyncGenerator(this, null, function* () {
+      var _a2, _b2, _c, _d;
+      try {
+        for (var iter3 = __forAwait(connection.receive()), more3, temp3, error3; more3 = !(temp3 = yield new __await(iter3.next())).done; more3 = false) {
+          const llmResponse = temp3.value;
+          if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+            return;
+          }
+          if (sendAbort.signal.aborted) {
+            return;
+          }
+          if ((_b2 = llmResponse.liveSessionResumptionUpdate) == null ? void 0 : _b2.newHandle) {
+            invocationContext.liveSessionResumptionHandle = llmResponse.liveSessionResumptionUpdate.newHandle;
+          }
+          if (llmResponse.goAway) {
+            logger.info("Received goAway from live server; triggering reconnect.");
+            throw new LiveReconnectSignal("goAway");
+          }
+          const author = llmResponse.inputTranscription || ((_c = llmResponse.content) == null ? void 0 : _c.role) === "user" ? "user" : this.name;
+          const modelResponseEvent = createEvent({
+            invocationId: invocationContext.invocationId,
+            author,
+            branch: invocationContext.branch
+          });
+          try {
+            for (var iter2 = __forAwait(this.postprocessLive(
+              invocationContext,
+              llmRequest,
+              llmResponse,
+              modelResponseEvent
+            )), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
+              const event = temp2.value;
+              yield event;
+              if (event.content && getFunctionResponses(event).length > 0) {
+                yield new __await(connection.sendContent(event.content));
+              }
+              const taskCompleted = getFunctionResponses(event).some(
+                (r) => r.name === "task_completed"
+              );
+              if (taskCompleted) {
+                yield new __await(sleep(TRANSFER_AGENT_DELAY_MS));
+                return;
+              }
+              const transferTo = (_d = event.actions) == null ? void 0 : _d.transferToAgent;
+              if (transferTo) {
+                yield new __await(sleep(TRANSFER_AGENT_DELAY_MS));
+                sendAbort.abort();
+                yield new __await(connection.close());
+                const agent = requireAgent(invocationContext);
+                const subAgent = agent.rootAgent.findAgent(transferTo);
+                if (subAgent) {
+                  const previousAgent = invocationContext.agent;
+                  invocationContext.agent = subAgent;
+                  const previousHandle = invocationContext.liveSessionResumptionHandle;
+                  invocationContext.liveSessionResumptionHandle = void 0;
+                  try {
+                    try {
+                      for (var iter = __forAwait(subAgent.runLive(
+                        invocationContext
+                      )), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+                        const subEvent = temp.value;
+                        yield subEvent;
+                      }
+                    } catch (temp) {
+                      error = [temp];
+                    } finally {
+                      try {
+                        more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+                      } finally {
+                        if (error)
+                          throw error[0];
+                      }
+                    }
+                  } finally {
+                    invocationContext.agent = previousAgent;
+                    invocationContext.liveSessionResumptionHandle = previousHandle;
+                  }
+                }
+                return;
+              }
+            }
+          } catch (temp2) {
+            error2 = [temp2];
+          } finally {
+            try {
+              more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
+            } finally {
+              if (error2)
+                throw error2[0];
+            }
+          }
+        }
+      } catch (temp3) {
+        error3 = [temp3];
+      } finally {
+        try {
+          more3 && (temp3 = iter3.return) && (yield new __await(temp3.call(iter3)));
+        } finally {
+          if (error3)
+            throw error3[0];
+        }
+      }
+    });
+  }
+  postprocessLive(invocationContext, llmRequest, llmResponse, modelResponseEvent) {
+    return __asyncGenerator(this, null, function* () {
+      for (const processor of this.responseProcessors) {
+        try {
+          for (var iter = __forAwait(processor.runAsync(
+            invocationContext,
+            llmResponse
+          )), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+            const event = temp.value;
+            yield event;
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+      }
+      if (!llmResponse.content && !llmResponse.errorCode && !llmResponse.interrupted && !llmResponse.turnComplete && !llmResponse.inputTranscription && !llmResponse.outputTranscription && !llmResponse.usageMetadata && !llmResponse.liveSessionResumptionUpdate) {
+        return;
+      }
+      if (llmResponse.liveSessionResumptionUpdate) {
+        yield createEvent(__spreadProps(__spreadValues({}, modelResponseEvent), {
+          liveSessionResumptionUpdate: llmResponse.liveSessionResumptionUpdate
+        }));
+        return;
+      }
+      if (llmResponse.inputTranscription) {
+        yield createEvent(__spreadProps(__spreadValues({}, modelResponseEvent), {
+          inputTranscription: llmResponse.inputTranscription,
+          partial: llmResponse.partial
+        }));
+        return;
+      }
+      if (llmResponse.outputTranscription) {
+        yield createEvent(__spreadProps(__spreadValues({}, modelResponseEvent), {
+          outputTranscription: llmResponse.outputTranscription,
+          partial: llmResponse.partial
+        }));
+        return;
+      }
+      const mergedEvent = createEvent(__spreadValues(__spreadValues({}, modelResponseEvent), llmResponse));
+      const functionCalls = getFunctionCalls(mergedEvent);
+      if (mergedEvent.content && functionCalls.length) {
+        populateClientFunctionCallId(mergedEvent);
+        mergedEvent.longRunningToolIds = Array.from(
+          getLongRunningFunctionCalls(functionCalls, llmRequest.toolsDict)
+        );
+      }
+      yield mergedEvent;
+      if (!functionCalls.length) {
+        return;
+      }
+      const functionResponseEvent = yield new __await(handleFunctionCallsAsync({
+        invocationContext,
+        functionCallEvent: mergedEvent,
+        toolsDict: llmRequest.toolsDict,
+        beforeToolCallbacks: this.canonicalBeforeToolCallbacks,
+        afterToolCallbacks: this.canonicalAfterToolCallbacks
+      }));
+      if (!functionResponseEvent) {
+        return;
+      }
+      const authEvent = generateAuthEvent(
+        invocationContext,
+        functionResponseEvent
+      );
+      if (authEvent) {
+        yield authEvent;
+      }
+      yield functionResponseEvent;
     });
   }
   runOneStepAsync(invocationContext) {
@@ -500,22 +1039,32 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
         }
       }
       const allTools = [...this.tools];
-      if (this.outputSchema && allTools.length > 0 && !canUseOutputSchemaWithTools(this.canonicalModel.model)) {
+      if (this.mode === "task") {
+        allTools.push(this.finishTaskTool);
+      } else if (this.outputSchema && allTools.length > 0 && !canUseOutputSchemaWithTools(this.canonicalModel.model)) {
         const setModelResponseTool = new FunctionTool({
           name: "set_model_response",
           description: "Call this tool to submit your final response conforming to the output schema. Use this tool only when you have collected all the information and are ready to return the final answer.",
           parameters: this.outputSchema,
-          execute: async (args, toolContext) => {
+          execute: /* @__PURE__ */ __name(async (args, toolContext) => {
             if (toolContext) {
               toolContext.actions.skipSummarization = true;
             }
             return JSON.stringify(args);
-          }
+          }, "execute")
         });
         allTools.push(setModelResponseTool);
       }
+      const modelResponseEvent = createEvent({
+        invocationId: invocationContext.invocationId,
+        author: this.name,
+        branch: invocationContext.branch
+      });
       for (const toolUnion of allTools) {
-        const toolContext = new Context({ invocationContext });
+        const toolContext = new Context({
+          invocationContext,
+          eventActions: modelResponseEvent.actions
+        });
         const tools = (yield new __await(convertToolUnionToTools(
           toolUnion,
           new ReadonlyContext(invocationContext)
@@ -532,11 +1081,6 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
       if (invocationContext.endInvocation || ((_c = invocationContext.abortSignal) == null ? void 0 : _c.aborted)) {
         return;
       }
-      const modelResponseEvent = createEvent({
-        invocationId: invocationContext.invocationId,
-        author: this.name,
-        branch: invocationContext.branch
-      });
       const span = tracer.startSpan("call_llm");
       const ctx = trace.setSpan(context.active(), span);
       yield* __yieldStar(runAsyncGeneratorWithOtelContext(
@@ -544,7 +1088,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
         this,
         function() {
           return __asyncGenerator(this, null, function* () {
-            const responsesGenerator = function() {
+            const responsesGenerator = /* @__PURE__ */ __name(function() {
               return __asyncGenerator(this, null, function* () {
                 var _a3, _b3;
                 try {
@@ -594,7 +1138,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
                   }
                 }
               });
-            };
+            }, "responsesGenerator");
             yield* __yieldStar(this.runAndHandleError(
               responsesGenerator.call(this),
               invocationContext,
@@ -633,7 +1177,8 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
           }
         }
       }
-      if ((!llmResponse.content || ((_b2 = llmResponse.content.parts) == null ? void 0 : _b2.length) === 0) && !llmResponse.errorCode && !llmResponse.interrupted) {
+      const isUsageOnlyReport = !llmResponse.content && !!llmResponse.usageMetadata;
+      if ((!llmResponse.content || ((_b2 = llmResponse.content.parts) == null ? void 0 : _b2.length) === 0) && !llmResponse.errorCode && !llmResponse.interrupted && !isUsageOnlyReport) {
         return;
       }
       const mergedEvent = createEvent(__spreadValues(__spreadValues({}, modelResponseEvent), llmResponse));
@@ -661,13 +1206,44 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
         invocationContext.endInvocation = true;
         return;
       }
-      const functionResponseEvent = yield new __await(handleFunctionCallsAsync({
-        invocationContext,
-        functionCallEvent: mergedEvent,
-        toolsDict: llmRequest.toolsDict,
-        beforeToolCallbacks: this.canonicalBeforeToolCallbacks,
-        afterToolCallbacks: this.canonicalAfterToolCallbacks
-      }));
+      const eventQueue = new AsyncQueue();
+      invocationContext.eventQueue = eventQueue;
+      const toolTask = (async () => {
+        try {
+          const event = await handleFunctionCallsAsync({
+            invocationContext,
+            functionCallEvent: mergedEvent,
+            toolsDict: llmRequest.toolsDict,
+            beforeToolCallbacks: this.canonicalBeforeToolCallbacks,
+            afterToolCallbacks: this.canonicalAfterToolCallbacks
+          });
+          return { event };
+        } catch (error4) {
+          return { event: null, error: error4 };
+        } finally {
+          eventQueue.close();
+        }
+      })();
+      try {
+        for (var iter2 = __forAwait(eventQueue), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
+          const queuedEvent = temp2.value;
+          yield queuedEvent;
+        }
+      } catch (temp2) {
+        error2 = [temp2];
+      } finally {
+        try {
+          more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
+        } finally {
+          if (error2)
+            throw error2[0];
+        }
+      }
+      const { event: functionResponseEvent, error: toolError } = yield new __await(toolTask);
+      invocationContext.eventQueue = void 0;
+      if (toolError) {
+        throw toolError;
+      }
       if (!functionResponseEvent || ((_e = invocationContext.abortSignal) == null ? void 0 : _e.aborted)) {
         return;
       }
@@ -693,21 +1269,21 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
       if (nextAgentName) {
         const nextAgent = this.getAgentByName(invocationContext, nextAgentName);
         try {
-          for (var iter2 = __forAwait(nextAgent.runAsync(invocationContext)), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
-            const event = temp2.value;
+          for (var iter3 = __forAwait(nextAgent.runAsync(invocationContext)), more3, temp3, error3; more3 = !(temp3 = yield new __await(iter3.next())).done; more3 = false) {
+            const event = temp3.value;
             if ((_f = invocationContext.abortSignal) == null ? void 0 : _f.aborted) {
               return;
             }
             yield event;
           }
-        } catch (temp2) {
-          error2 = [temp2];
+        } catch (temp3) {
+          error3 = [temp3];
         } finally {
           try {
-            more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
+            more3 && (temp3 = iter3.return) && (yield new __await(temp3.call(iter3)));
           } finally {
-            if (error2)
-              throw error2[0];
+            if (error3)
+              throw error3[0];
           }
         }
       }
@@ -726,7 +1302,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
    * @throws Error if the agent is not found.
    */
   getAgentByName(invocationContext, agentName) {
-    const rootAgent = invocationContext.agent.rootAgent;
+    const rootAgent = requireAgent(invocationContext).rootAgent;
     const agentToRun = rootAgent.findAgent(agentName);
     if (!agentToRun) {
       throw new Error("Agent ".concat(agentName, " not found in the agent tree."));
@@ -929,7 +1505,9 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
   // TODO - b/425992518: omitted Py LlmAgent features.
   // - code_executor
   // - configurable agents by yaml config
-}
+};
+__name(_LlmAgent, "LlmAgent");
+let LlmAgent = _LlmAgent;
 export {
   LlmAgent,
   isLlmAgent