@google/adk 1.6.0 → 2.1.0

package/dist/esm/agents/llm_agent.js

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -7,7 +9,12 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 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,
@@ -16,6 +23,7 @@ import {
   isFinalResponse,
   populateClientFunctionCallId
 } from "../events/event.js";
+import { isDefaultEventActions } from "../events/event_actions.js";
 import { isBaseLlm } from "../models/base_llm.js";
 import { LLMRegistry } from "../models/registry.js";
 import { isBaseTool } from "../tools/base_tool.js";
@@ -27,6 +35,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 {
@@ -36,6 +45,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";
@@ -45,48 +55,113 @@ 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: ${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);
 }
-const LLM_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.llmAgent");
+__name(convertToolUnionToTools, "convertToolUnionToTools");
+const LLM_AGENT_SIGNATURE_SYMBOL = /* @__PURE__ */ 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({
+      ...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,
@@ -108,8 +183,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);
     }
@@ -131,13 +206,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 ${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;
     }
   }
   /**
@@ -161,6 +237,16 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
     }
     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 FinishTaskTool(this.outputSchema);
+    }
+    return this._finishTaskTool;
+  }
   /**
    * The resolved instruction field to construct instruction for this
    * agent.
@@ -233,7 +319,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
@@ -242,7 +328,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
@@ -251,7 +337,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.
@@ -259,7 +345,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.
@@ -302,14 +388,53 @@ 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 ${this.name}`, e);
+        event.actions.stateDelta[this.outputKey] = resultStr;
+        return;
+      }
+      try {
+        result = this.validateOutput(parsed);
+      } catch (e) {
+        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 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* runLlmAgentAsNode(this, ctx, nodeInput);
+  }
   async *runAsyncImpl(context2) {
     var _a2, _b2;
     while (true) {
@@ -329,7 +454,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
       if (!lastEvent) {
         break;
       }
-      const isEmptyMetadataEvent = lastEvent.author === this.name && !lastEvent.partial && (!((_b2 = lastEvent.content) == null ? void 0 : _b2.parts) || lastEvent.content.parts.length === 0);
+      const isEmptyMetadataEvent = lastEvent.author === this.name && !lastEvent.partial && (!((_b2 = lastEvent.content) == null ? void 0 : _b2.parts) || lastEvent.content.parts.length === 0) && isDefaultEventActions(lastEvent.actions);
       if (isFinalResponse(lastEvent) && !(isEmptyMetadataEvent && stepHadToolCalls)) {
         break;
       }
@@ -369,10 +494,350 @@ 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
-  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) {
+            logger.error(
+              `Max live reconnection attempts reached (${reconnectAttempts}).`,
+              err
+            );
+            throw err;
+          }
+          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) => {
+        logger.error("Error in live send loop:", error);
+        sendError = error;
+        sendAbort.abort(error);
+        connection.close().catch((err) => {
+          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;
+          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 Context({ invocationContext });
+      const tools = (await convertToolUnionToTools(
+        toolUnion,
+        new 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)) {
+          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);
+  }
+  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) {
+        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
+      });
+      for await (const event of this.postprocessLive(
+        invocationContext,
+        llmRequest,
+        llmResponse,
+        modelResponseEvent
+      )) {
+        yield event;
+        if (event.content && getFunctionResponses(event).length > 0) {
+          await connection.sendContent(event.content);
+        }
+        const taskCompleted = 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 = 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 createEvent({
+        ...modelResponseEvent,
+        liveSessionResumptionUpdate: llmResponse.liveSessionResumptionUpdate
+      });
+      return;
+    }
+    if (llmResponse.inputTranscription) {
+      yield createEvent({
+        ...modelResponseEvent,
+        inputTranscription: llmResponse.inputTranscription,
+        partial: llmResponse.partial
+      });
+      return;
+    }
+    if (llmResponse.outputTranscription) {
+      yield createEvent({
+        ...modelResponseEvent,
+        outputTranscription: llmResponse.outputTranscription,
+        partial: llmResponse.partial
+      });
+      return;
+    }
+    const mergedEvent = createEvent({
+      ...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 = 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;
   }
   async *runOneStepAsync(invocationContext) {
     var _a2, _b2, _c;
@@ -393,22 +858,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 = (await convertToolUnionToTools(
         toolUnion,
         new ReadonlyContext(invocationContext)
@@ -425,18 +900,13 @@ 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* 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,
@@ -460,7 +930,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
               yield event;
             }
           }
-        };
+        }, "responsesGenerator");
         yield* this.runAndHandleError(
           responsesGenerator.call(this),
           invocationContext,
@@ -484,7 +954,8 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
         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 = createEvent({
@@ -515,13 +986,32 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
       invocationContext.endInvocation = true;
       return;
     }
-    const functionResponseEvent = 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 (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;
     }
@@ -567,7 +1057,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 ${agentName} not found in the agent tree.`);
@@ -739,10 +1229,12 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
   // --------------------------------------------------------------------------
   // #END LlmFlow Logic
   // --------------------------------------------------------------------------
-  // TODO - b/425992518: omitted Py LlmAgent features.
-  // - code_executor
-  // - configurable agents by yaml config
-}
+  // TODO - b/425992518: LlmAgent features not implemented yet.
+  // - codeExecutor
+  // - configuring agents from a YAML file
+};
+__name(_LlmAgent, "LlmAgent");
+let LlmAgent = _LlmAgent;
 export {
   LlmAgent,
   isLlmAgent