@google/adk 1.6.0 → 2.0.0

package/dist/cjs/agents/llm_agent.js

@@ -9,6 +9,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -29,7 +30,12 @@ __export(llm_agent_exports, {
 });
 module.exports = __toCommonJS(llm_agent_exports);
 var import_api = require("@opentelemetry/api");
+var import_finish_task_tool = require("../tools/finish_task_tool.js");
 var import_function_tool = require("../tools/function_tool.js");
+var import_async_queue = require("../utils/async_queue.js");
+var import_base_node = require("../workflow/base_node.js");
+var import_node_tool = require("../workflow/nodes/node_tool.js");
+var import_run_llm_agent_as_node = require("../workflow/run_llm_agent_as_node.js");
 var import_event = require("../events/event.js");
 var import_base_llm = require("../models/base_llm.js");
 var import_registry = require("../models/registry.js");
@@ -38,10 +44,12 @@ var import_logger = require("../utils/logger.js");
 var import_output_schema_utils = require("../utils/output_schema_utils.js");
 var import_context = require("./context.js");
 var import_tracing = require("../telemetry/tracing.js");
+var import_schema = require("../utils/schema.js");
 var import_simple_zod_to_json = require("../utils/simple_zod_to_json.js");
 var import_base_agent = require("./base_agent.js");
 var import_functions = require("./functions.js");
 var import_auth_preprocessor = require("../auth/auth_preprocessor.js");
+var import_invocation_context = require("./invocation_context.js");
 var import_agent_transfer_llm_request_processor = require("./processors/agent_transfer_llm_request_processor.js");
 var import_basic_llm_request_processor = require("./processors/basic_llm_request_processor.js");
 var import_code_execution_request_processor = require("./processors/code_execution_request_processor.js");
@@ -51,6 +59,7 @@ var import_identity_llm_request_processor = require("./processors/identity_llm_r
 var import_instructions_llm_request_processor = require("./processors/instructions_llm_request_processor.js");
 var import_interactions_request_processor = require("./processors/interactions_request_processor.js");
 var import_request_confirmation_llm_request_processor = require("./processors/request_confirmation_llm_request_processor.js");
+var import_request_input_llm_request_processor = require("./processors/request_input_llm_request_processor.js");
 var import_tool_filter_request_processor = require("./processors/tool_filter_request_processor.js");
 var import_readonly_context = require("./readonly_context.js");
 var import_run_config = require("./run_config.js");
@@ -60,45 +69,109 @@ var import_run_config = require("./run_config.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a, _b;
+const MAX_LIVE_RECONNECT_ATTEMPTS = 5;
+const TRANSFER_AGENT_DELAY_MS = 1e3;
+const _LiveReconnectSignal = class _LiveReconnectSignal extends Error {
+  constructor(reason) {
+    super(`live reconnect requested: ${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 ((0, import_base_tool.isBaseTool)(toolUnion)) {
     return [toolUnion];
   }
+  if ((0, import_base_node.isBaseNode)(toolUnion)) {
+    return [new import_node_tool.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 = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
+__name(isLlmAgent, "isLlmAgent");
+const _LlmAgent = class _LlmAgent extends (_b = import_base_agent.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({
+      ...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 = (0, import_simple_zod_to_json.isZodObject)(config.inputSchema) ? (0, import_simple_zod_to_json.zodObjectToSchema)(config.inputSchema) : config.inputSchema;
     this.outputSchema = (0, import_simple_zod_to_json.isZodObject)(config.outputSchema) ? (0, import_simple_zod_to_json.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 : [
       import_basic_llm_request_processor.BASIC_LLM_REQUEST_PROCESSOR,
       import_auth_preprocessor.AUTH_PREPROCESSOR,
       import_identity_llm_request_processor.IDENTITY_LLM_REQUEST_PROCESSOR,
       import_instructions_llm_request_processor.INSTRUCTIONS_LLM_REQUEST_PROCESSOR,
       import_request_confirmation_llm_request_processor.REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
+      import_request_input_llm_request_processor.REQUEST_INPUT_LLM_REQUEST_PROCESSOR,
       import_content_request_processor.CONTENT_REQUEST_PROCESSOR,
       import_interactions_request_processor.INTERACTIONS_REQUEST_PROCESSOR,
       import_code_execution_request_processor.CODE_EXECUTION_REQUEST_PROCESSOR,
@@ -120,8 +193,8 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
         );
       }
     }
-    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(import_agent_transfer_llm_request_processor.AGENT_TRANSFER_LLM_REQUEST_PROCESSOR);
     }
@@ -143,13 +216,14 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
       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) {
         import_logger.logger.warn(
           `Invalid config for agent ${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;
     }
   }
   /**
@@ -173,6 +247,16 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     }
     throw new Error(`No model found for ${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 import_finish_task_tool.FinishTaskTool(this.outputSchema);
+    }
+    return this._finishTaskTool;
+  }
   /**
    * The resolved instruction field to construct instruction for this
    * agent.
@@ -245,7 +329,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
    * 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
@@ -254,7 +338,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
    * 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
@@ -263,7 +347,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
    * 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.
@@ -271,7 +355,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
    * 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.
@@ -314,14 +398,53 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
       if (!resultStr.trim()) {
         return;
       }
+      let parsed;
       try {
-        result = JSON.parse(resultStr);
+        parsed = JSON.parse(resultStr);
       } catch (e) {
         import_logger.logger.error(`Error parsing output for agent ${this.name}`, e);
+        event.actions.stateDelta[this.outputKey] = resultStr;
+        return;
+      }
+      try {
+        result = this.validateOutput(parsed);
+      } catch (e) {
+        import_logger.logger.error(
+          `Output for agent ${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 (0, import_schema.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`.
+   */
+  async *runImpl(ctx, nodeInput) {
+    yield* (0, import_run_llm_agent_as_node.runLlmAgentAsNode)(this, ctx, nodeInput);
+  }
   async *runAsyncImpl(context2) {
     var _a2, _b2;
     while (true) {
@@ -381,10 +504,350 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
    * times. Subsequent reconnects skip `sendHistory` because the server
    * already holds the conversation state associated with the handle.
    */
-  // eslint-disable-next-line require-yield
-  async *runLiveFlow(_invocationContext) {
-    await Promise.resolve();
-    throw new Error("LlmAgent.runLiveFlow not implemented");
+  async *runLiveFlow(invocationContext) {
+    var _a2, _b2, _c, _d;
+    if (!invocationContext.liveRequestQueue) {
+      throw new Error("liveRequestQueue is required for LlmAgent.runLiveFlow.");
+    }
+    const llmRequest = {
+      contents: [],
+      toolsDict: {},
+      liveConnectConfig: {}
+    };
+    for await (const event of this.runLivePreprocess(
+      invocationContext,
+      llmRequest
+    )) {
+      yield event;
+    }
+    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 = await llm.connect(llmRequest);
+      } catch (err) {
+        if (isRecoverableLiveError(err) && invocationContext.liveSessionResumptionHandle) {
+          reconnectAttempts += 1;
+          if (reconnectAttempts > MAX_LIVE_RECONNECT_ATTEMPTS) {
+            import_logger.logger.error(
+              `Max live reconnection attempts reached (${reconnectAttempts}).`,
+              err
+            );
+            throw err;
+          }
+          import_logger.logger.info(
+            `Live connect failed (attempt ${reconnectAttempts}); retrying with session handle.`,
+            err
+          );
+          continue;
+        }
+        throw err;
+      }
+      if (llmRequest.contents.length > 0 && !invocationContext.liveSessionResumptionHandle) {
+        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((error) => {
+        import_logger.logger.error("Error in live send loop:", error);
+        sendError = error;
+        sendAbort.abort(error);
+        connection.close().catch((err) => {
+          import_logger.logger.warn("Error closing connection after send loop failure:", err);
+        });
+      });
+      let reconnect = false;
+      try {
+        yield* this.runReceiveLoop(
+          invocationContext,
+          connection,
+          llmRequest,
+          sendAbort
+        );
+      } catch (err) {
+        const canReconnect = !!invocationContext.liveSessionResumptionHandle && (err instanceof LiveReconnectSignal || isRecoverableLiveError(err));
+        if (canReconnect) {
+          reconnect = true;
+          import_logger.logger.info(
+            "Live connection closed; will reconnect with session handle.",
+            err
+          );
+        } else {
+          await this.teardownLiveConnection(sendAbort, connection, sendTask);
+          throw err;
+        }
+      }
+      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 (${reconnectAttempts}).`
+        );
+      }
+    }
+  }
+  async *runLivePreprocess(invocationContext, llmRequest) {
+    var _a2, _b2;
+    for (const processor of this.requestProcessors) {
+      for await (const event of processor.runAsync(
+        invocationContext,
+        llmRequest
+      )) {
+        if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+          return;
+        }
+        yield event;
+      }
+    }
+    for (const toolUnion of this.tools) {
+      const toolContext = new import_context.Context({ invocationContext });
+      const tools = (await convertToolUnionToTools(
+        toolUnion,
+        new import_readonly_context.ReadonlyContext(invocationContext)
+      )).filter(
+        (tool) => !llmRequest.allowedTools || llmRequest.allowedTools.includes(tool.name)
+      );
+      for (const tool of tools) {
+        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)) {
+          import_logger.logger.debug("Send failed after teardown:", error);
+          return;
+        }
+        import_logger.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) {
+      import_logger.logger.warn("Error closing live connection:", error);
+    }
+    await sendTask.catch(() => void 0);
+  }
+  async *runReceiveLoop(invocationContext, connection, llmRequest, sendAbort) {
+    var _a2, _b2, _c, _d;
+    for await (const llmResponse of connection.receive()) {
+      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) {
+        import_logger.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 = (0, import_event.createEvent)({
+        invocationId: invocationContext.invocationId,
+        author,
+        branch: invocationContext.branch
+      });
+      for await (const event of this.postprocessLive(
+        invocationContext,
+        llmRequest,
+        llmResponse,
+        modelResponseEvent
+      )) {
+        yield event;
+        if (event.content && (0, import_event.getFunctionResponses)(event).length > 0) {
+          await connection.sendContent(event.content);
+        }
+        const taskCompleted = (0, import_event.getFunctionResponses)(event).some(
+          (r) => r.name === "task_completed"
+        );
+        if (taskCompleted) {
+          await sleep(TRANSFER_AGENT_DELAY_MS);
+          return;
+        }
+        const transferTo = (_d = event.actions) == null ? void 0 : _d.transferToAgent;
+        if (transferTo) {
+          await sleep(TRANSFER_AGENT_DELAY_MS);
+          sendAbort.abort();
+          await connection.close();
+          const agent = (0, import_invocation_context.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 {
+              for await (const subEvent of subAgent.runLive(
+                invocationContext
+              )) {
+                yield subEvent;
+              }
+            } finally {
+              invocationContext.agent = previousAgent;
+              invocationContext.liveSessionResumptionHandle = previousHandle;
+            }
+          }
+          return;
+        }
+      }
+    }
+  }
+  async *postprocessLive(invocationContext, llmRequest, llmResponse, modelResponseEvent) {
+    for (const processor of this.responseProcessors) {
+      for await (const event of processor.runAsync(
+        invocationContext,
+        llmResponse
+      )) {
+        yield event;
+      }
+    }
+    if (!llmResponse.content && !llmResponse.errorCode && !llmResponse.interrupted && !llmResponse.turnComplete && !llmResponse.inputTranscription && !llmResponse.outputTranscription && !llmResponse.usageMetadata && !llmResponse.liveSessionResumptionUpdate) {
+      return;
+    }
+    if (llmResponse.liveSessionResumptionUpdate) {
+      yield (0, import_event.createEvent)({
+        ...modelResponseEvent,
+        liveSessionResumptionUpdate: llmResponse.liveSessionResumptionUpdate
+      });
+      return;
+    }
+    if (llmResponse.inputTranscription) {
+      yield (0, import_event.createEvent)({
+        ...modelResponseEvent,
+        inputTranscription: llmResponse.inputTranscription,
+        partial: llmResponse.partial
+      });
+      return;
+    }
+    if (llmResponse.outputTranscription) {
+      yield (0, import_event.createEvent)({
+        ...modelResponseEvent,
+        outputTranscription: llmResponse.outputTranscription,
+        partial: llmResponse.partial
+      });
+      return;
+    }
+    const mergedEvent = (0, import_event.createEvent)({
+      ...modelResponseEvent,
+      ...llmResponse
+    });
+    const functionCalls = (0, import_event.getFunctionCalls)(mergedEvent);
+    if (mergedEvent.content && functionCalls.length) {
+      (0, import_event.populateClientFunctionCallId)(mergedEvent);
+      mergedEvent.longRunningToolIds = Array.from(
+        (0, import_functions.getLongRunningFunctionCalls)(functionCalls, llmRequest.toolsDict)
+      );
+    }
+    yield mergedEvent;
+    if (!functionCalls.length) {
+      return;
+    }
+    const functionResponseEvent = await (0, import_functions.handleFunctionCallsAsync)({
+      invocationContext,
+      functionCallEvent: mergedEvent,
+      toolsDict: llmRequest.toolsDict,
+      beforeToolCallbacks: this.canonicalBeforeToolCallbacks,
+      afterToolCallbacks: this.canonicalAfterToolCallbacks
+    });
+    if (!functionResponseEvent) {
+      return;
+    }
+    const authEvent = (0, import_functions.generateAuthEvent)(
+      invocationContext,
+      functionResponseEvent
+    );
+    if (authEvent) {
+      yield authEvent;
+    }
+    yield functionResponseEvent;
   }
   async *runOneStepAsync(invocationContext) {
     var _a2, _b2, _c;
@@ -405,22 +868,32 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
       }
     }
     const allTools = [...this.tools];
-    if (this.outputSchema && allTools.length > 0 && !(0, import_output_schema_utils.canUseOutputSchemaWithTools)(this.canonicalModel.model)) {
+    if (this.mode === "task") {
+      allTools.push(this.finishTaskTool);
+    } else if (this.outputSchema && allTools.length > 0 && !(0, import_output_schema_utils.canUseOutputSchemaWithTools)(this.canonicalModel.model)) {
       const setModelResponseTool = new import_function_tool.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 = (0, import_event.createEvent)({
+      invocationId: invocationContext.invocationId,
+      author: this.name,
+      branch: invocationContext.branch
+    });
     for (const toolUnion of allTools) {
-      const toolContext = new import_context.Context({ invocationContext });
+      const toolContext = new import_context.Context({
+        invocationContext,
+        eventActions: modelResponseEvent.actions
+      });
       const tools = (await convertToolUnionToTools(
         toolUnion,
         new import_readonly_context.ReadonlyContext(invocationContext)
@@ -437,18 +910,13 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     if (invocationContext.endInvocation || ((_c = invocationContext.abortSignal) == null ? void 0 : _c.aborted)) {
       return;
     }
-    const modelResponseEvent = (0, import_event.createEvent)({
-      invocationId: invocationContext.invocationId,
-      author: this.name,
-      branch: invocationContext.branch
-    });
     const span = import_tracing.tracer.startSpan("call_llm");
     const ctx = import_api.trace.setSpan(import_api.context.active(), span);
     yield* (0, import_tracing.runAsyncGeneratorWithOtelContext)(
       ctx,
       this,
       async function* () {
-        const responsesGenerator = async function* () {
+        const responsesGenerator = /* @__PURE__ */ __name(async function* () {
           var _a3, _b3;
           for await (const llmResponse of this.callLlmAsync(
             invocationContext,
@@ -472,7 +940,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
               yield event;
             }
           }
-        };
+        }, "responsesGenerator");
         yield* this.runAndHandleError(
           responsesGenerator.call(this),
           invocationContext,
@@ -496,7 +964,8 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
         yield event;
       }
     }
-    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 = (0, import_event.createEvent)({
@@ -527,13 +996,32 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
       invocationContext.endInvocation = true;
       return;
     }
-    const functionResponseEvent = await (0, import_functions.handleFunctionCallsAsync)({
-      invocationContext,
-      functionCallEvent: mergedEvent,
-      toolsDict: llmRequest.toolsDict,
-      beforeToolCallbacks: this.canonicalBeforeToolCallbacks,
-      afterToolCallbacks: this.canonicalAfterToolCallbacks
-    });
+    const eventQueue = new import_async_queue.AsyncQueue();
+    invocationContext.eventQueue = eventQueue;
+    const toolTask = (async () => {
+      try {
+        const event = await (0, import_functions.handleFunctionCallsAsync)({
+          invocationContext,
+          functionCallEvent: mergedEvent,
+          toolsDict: llmRequest.toolsDict,
+          beforeToolCallbacks: this.canonicalBeforeToolCallbacks,
+          afterToolCallbacks: this.canonicalAfterToolCallbacks
+        });
+        return { event };
+      } catch (error) {
+        return { event: null, error };
+      } finally {
+        eventQueue.close();
+      }
+    })();
+    for await (const queuedEvent of eventQueue) {
+      yield queuedEvent;
+    }
+    const { event: functionResponseEvent, error: toolError } = await toolTask;
+    invocationContext.eventQueue = void 0;
+    if (toolError) {
+      throw toolError;
+    }
     if (!functionResponseEvent || ((_e = invocationContext.abortSignal) == null ? void 0 : _e.aborted)) {
       return;
     }
@@ -579,7 +1067,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
    * @throws Error if the agent is not found.
    */
   getAgentByName(invocationContext, agentName) {
-    const rootAgent = invocationContext.agent.rootAgent;
+    const rootAgent = (0, import_invocation_context.requireAgent)(invocationContext).rootAgent;
     const agentToRun = rootAgent.findAgent(agentName);
     if (!agentToRun) {
       throw new Error(`Agent ${agentName} not found in the agent tree.`);
@@ -754,7 +1242,9 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
   // TODO - b/425992518: omitted Py LlmAgent features.
   // - code_executor
   // - configurable agents by yaml config
-}
+};
+__name(_LlmAgent, "LlmAgent");
+let LlmAgent = _LlmAgent;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LlmAgent,