@google/adk 2.0.0 → 2.2.0

package/dist/web/agents/llm_agent.js

@@ -1,1514 +0,0 @@
-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;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  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;
-};
-var __asyncGenerator = (__this, __arguments, generator) => {
-  var resume = (k, v, yes, no) => {
-    try {
-      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
-      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
-    } catch (e) {
-      no(e);
-    }
-  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
-  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
-};
-var __yieldStar = (value) => {
-  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
-  if (obj == null) {
-    obj = value[__knownSymbol("iterator")]();
-    method = (k) => it[k] = (x) => obj[k](x);
-  } else {
-    obj = obj.call(value);
-    method = (k) => it[k] = (v) => {
-      if (isAwait) {
-        isAwait = false;
-        if (k === "throw") throw v;
-        return v;
-      }
-      isAwait = true;
-      return {
-        done: false,
-        value: new __await(new Promise((resolve) => {
-          var x = obj[k](v);
-          if (!(x instanceof Object)) __typeError("Object expected");
-          resolve(x);
-        }), 1)
-      };
-    };
-  }
-  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
-    throw x;
-  }, "return" in obj && method("return"), it;
-};
-var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-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,
-  getFunctionCalls,
-  getFunctionResponses,
-  isFinalResponse,
-  populateClientFunctionCallId
-} from "../events/event.js";
-import { isBaseLlm } from "../models/base_llm.js";
-import { LLMRegistry } from "../models/registry.js";
-import { isBaseTool } from "../tools/base_tool.js";
-import { logger } from "../utils/logger.js";
-import { canUseOutputSchemaWithTools } from "../utils/output_schema_utils.js";
-import { Context } from "./context.js";
-import {
-  runAsyncGeneratorWithOtelContext,
-  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 {
-  generateAuthEvent,
-  generateRequestConfirmationEvent,
-  getLongRunningFunctionCalls,
-  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";
-import { CONTENT_REQUEST_PROCESSOR } from "./processors/content_request_processor.js";
-import { ContextCompactorRequestProcessor } from "./processors/context_compactor_request_processor.js";
-import { IDENTITY_LLM_REQUEST_PROCESSOR } from "./processors/identity_llm_request_processor.js";
-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;
-}
-__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, _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 = (_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 = (_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 = (_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,
-      TOOL_FILTER_REQUEST_PROCESSOR
-    ];
-    if (!config.requestProcessors && config.contextCompactors && config.contextCompactors.length > 0) {
-      const contentIndex = this.requestProcessors.indexOf(
-        CONTENT_REQUEST_PROCESSOR
-      );
-      if (contentIndex !== -1) {
-        this.requestProcessors.splice(
-          contentIndex,
-          0,
-          new ContextCompactorRequestProcessor(config.contextCompactors)
-        );
-      } else {
-        this.requestProcessors.push(
-          new ContextCompactorRequestProcessor(config.contextCompactors)
-        );
-      }
-    }
-    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);
-    }
-    if (config.generateContentConfig) {
-      if (config.generateContentConfig.tools) {
-        throw new Error("All tools must be set via LlmAgent.tools.");
-      }
-      if (config.generateContentConfig.systemInstruction) {
-        throw new Error(
-          "System instruction must be set via LlmAgent.instruction."
-        );
-      }
-      if (config.generateContentConfig.responseSchema) {
-        throw new Error(
-          "Response schema must be set via LlmAgent.output_schema."
-        );
-      }
-    } else {
-      this.generateContentConfig = {};
-    }
-    if (this.outputSchema) {
-      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;
-    }
-  }
-  /**
-   * The resolved BaseLlm instance.
-   *
-   * When not set, the agent will inherit the model from its ancestor.
-   */
-  get canonicalModel() {
-    if (isBaseLlm(this.model)) {
-      return this.model;
-    }
-    if (typeof this.model === "string" && this.model) {
-      return LLMRegistry.newLlm(this.model);
-    }
-    let ancestorAgent = this.parentAgent;
-    while (ancestorAgent) {
-      if (isLlmAgent(ancestorAgent)) {
-        return ancestorAgent.canonicalModel;
-      }
-      ancestorAgent = ancestorAgent.parentAgent;
-    }
-    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.
-   *
-   * This method is only for use by Agent Development Kit.
-   * @param context The context to retrieve the session state.
-   * @returns The resolved instruction field.
-   */
-  async canonicalInstruction(context2) {
-    if (typeof this.instruction === "string") {
-      return { instruction: this.instruction, requireStateInjection: true };
-    }
-    return {
-      instruction: await this.instruction(context2),
-      requireStateInjection: false
-    };
-  }
-  /**
-   * The resolved globalInstruction field to construct global instruction.
-   *
-   * This method is only for use by Agent Development Kit.
-   * @param context The context to retrieve the session state.
-   * @returns The resolved globalInstruction field.
-   * @deprecated Use GlobalInstructionPlugin instead.
-   */
-  async canonicalGlobalInstruction(context2) {
-    if (typeof this.globalInstruction === "string") {
-      return {
-        instruction: this.globalInstruction,
-        requireStateInjection: true
-      };
-    }
-    return {
-      instruction: await this.globalInstruction(context2),
-      requireStateInjection: false
-    };
-  }
-  /**
-   * The resolved tools field as a list of BaseTool based on the context.
-   *
-   * This method is only for use by Agent Development Kit.
-   */
-  async canonicalTools(context2) {
-    const resolvedTools = [];
-    for (const toolUnion of this.tools) {
-      const tools = await convertToolUnionToTools(toolUnion, context2);
-      resolvedTools.push(...tools);
-    }
-    return resolvedTools;
-  }
-  /**
-   * Normalizes a callback or an array of callbacks into an array of callbacks.
-   *
-   * @param callback The callback or an array of callbacks.
-   * @returns An array of callbacks.
-   */
-  static normalizeCallbackArray(callback) {
-    if (!callback) {
-      return [];
-    }
-    if (Array.isArray(callback)) {
-      return callback;
-    }
-    return [callback];
-  }
-  /**
-   * The resolved beforeModelCallback field as a list of
-   * SingleBeforeModelCallback.
-   *
-   * This method is only for use by Agent Development Kit.
-   */
-  get canonicalBeforeModelCallbacks() {
-    return _LlmAgent.normalizeCallbackArray(this.beforeModelCallback);
-  }
-  /**
-   * The resolved afterModelCallback field as a list of
-   * SingleAfterModelCallback.
-   *
-   * This method is only for use by Agent Development Kit.
-   */
-  get canonicalAfterModelCallbacks() {
-    return _LlmAgent.normalizeCallbackArray(this.afterModelCallback);
-  }
-  /**
-   * The resolved beforeToolCallback field as a list of
-   * BeforeToolCallback.
-   *
-   * This method is only for use by Agent Development Kit.
-   */
-  get canonicalBeforeToolCallbacks() {
-    return _LlmAgent.normalizeCallbackArray(this.beforeToolCallback);
-  }
-  /**
-   * The resolved afterToolCallback field as a list of AfterToolCallback.
-   *
-   * This method is only for use by Agent Development Kit.
-   */
-  get canonicalAfterToolCallbacks() {
-    return _LlmAgent.normalizeCallbackArray(this.afterToolCallback);
-  }
-  /**
-   * Saves the agent's final response to the session state if configured.
-   *
-   * It extracts the text content from the final response event, optionally
-   * parses it as JSON based on the output schema, and stores the result in the
-   * session state using the specified output key.
-   *
-   * @param event The event to process.
-   */
-  maybeSaveOutputToState(event) {
-    var _a2, _b2;
-    if (event.author !== this.name) {
-      logger.debug(
-        "Skipping output save for agent ".concat(this.name, ": event authored by ").concat(event.author)
-      );
-      return;
-    }
-    if (!this.outputKey) {
-      logger.debug(
-        "Skipping output save for agent ".concat(this.name, ": outputKey is not set")
-      );
-      return;
-    }
-    if (!isFinalResponse(event)) {
-      logger.debug(
-        "Skipping output save for agent ".concat(this.name, ": event is not a final response")
-      );
-      return;
-    }
-    if (!((_b2 = (_a2 = event.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b2.length)) {
-      logger.debug(
-        "Skipping output save for agent ".concat(this.name, ": event content is empty")
-      );
-      return;
-    }
-    const resultStr = event.content.parts.map((part) => part.text ? part.text : "").join("");
-    let result = resultStr;
-    if (this.outputSchema) {
-      if (!resultStr.trim()) {
-        return;
-      }
-      let parsed;
-      try {
-        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;
-      while (true) {
-        let lastEvent = void 0;
-        let stepHadToolCalls = false;
-        try {
-          for (var iter = __forAwait(this.runOneStepAsync(context2)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-            const event = temp.value;
-            if ((_a2 = context2.abortSignal) == null ? void 0 : _a2.aborted) {
-              return;
-            }
-            lastEvent = event;
-            if (getFunctionCalls(event).length > 0 || getFunctionResponses(event).length > 0) {
-              stepHadToolCalls = true;
-            }
-            this.maybeSaveOutputToState(event);
-            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 (!lastEvent) {
-          break;
-        }
-        const isEmptyMetadataEvent = lastEvent.author === this.name && !lastEvent.partial && (!((_b2 = lastEvent.content) == null ? void 0 : _b2.parts) || lastEvent.content.parts.length === 0);
-        if (isFinalResponse(lastEvent) && !(isEmptyMetadataEvent && stepHadToolCalls)) {
-          break;
-        }
-        if (lastEvent.partial) {
-          logger.warn("The last event is partial, which is not expected.");
-          break;
-        }
-      }
-    });
-  }
-  runLiveImpl(context2) {
-    return __asyncGenerator(this, null, function* () {
-      var _a2;
-      try {
-        for (var iter = __forAwait(this.runLiveFlow(context2)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-          const event = temp.value;
-          if ((_a2 = context2.abortSignal) == null ? void 0 : _a2.aborted) {
-            return;
-          }
-          this.maybeSaveOutputToState(event);
-          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 (context2.endInvocation) {
-        return;
-      }
-    });
-  }
-  // --------------------------------------------------------------------------
-  // #START LlmFlow Logic
-  // --------------------------------------------------------------------------
-  /**
-   * Runs the bidirectional (live) flow for this agent.
-   *
-   * Establishes a live connection to the model, drains the invocation's
-   * `liveRequestQueue` into the connection on a parallel task, and yields
-   * events derived from server messages until the queue closes, the model
-   * finishes, or an agent transfer occurs.
-   *
-   * If the live connection drops (network failure, server `goAway`) and a
-   * session resumption handle has been observed, the flow transparently
-   * reconnects using that handle up to {@link MAX_LIVE_RECONNECT_ATTEMPTS}
-   * times. Subsequent reconnects skip `sendHistory` because the server
-   * already holds the conversation state associated with the handle.
-   */
-  runLiveFlow(invocationContext) {
-    return __asyncGenerator(this, null, function* () {
-      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) {
-    return __asyncGenerator(this, null, function* () {
-      var _a2, _b2, _c;
-      const llmRequest = {
-        contents: [],
-        toolsDict: {},
-        liveConnectConfig: {}
-      };
-      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];
-          }
-        }
-      }
-      const allTools = [...this.tools];
-      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: /* @__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,
-          eventActions: modelResponseEvent.actions
-        });
-        const tools = (yield new __await(convertToolUnionToTools(
-          toolUnion,
-          new ReadonlyContext(invocationContext)
-        ))).filter((tool) => {
-          return !llmRequest.allowedTools || llmRequest.allowedTools.includes(tool.name) || tool.name === "set_model_response";
-        });
-        for (const tool of tools) {
-          yield new __await(tool.processLlmRequest({ toolContext, llmRequest }));
-          if ((_b2 = invocationContext.abortSignal) == null ? void 0 : _b2.aborted) {
-            return;
-          }
-        }
-      }
-      if (invocationContext.endInvocation || ((_c = invocationContext.abortSignal) == null ? void 0 : _c.aborted)) {
-        return;
-      }
-      const span = tracer.startSpan("call_llm");
-      const ctx = trace.setSpan(context.active(), span);
-      yield* __yieldStar(runAsyncGeneratorWithOtelContext(
-        ctx,
-        this,
-        function() {
-          return __asyncGenerator(this, null, function* () {
-            const responsesGenerator = /* @__PURE__ */ __name(function() {
-              return __asyncGenerator(this, null, function* () {
-                var _a3, _b3;
-                try {
-                  for (var iter3 = __forAwait(this.callLlmAsync(
-                    invocationContext,
-                    llmRequest,
-                    modelResponseEvent
-                  )), more3, temp3, error3; more3 = !(temp3 = yield new __await(iter3.next())).done; more3 = false) {
-                    const llmResponse = temp3.value;
-                    if ((_a3 = invocationContext.abortSignal) == null ? void 0 : _a3.aborted) {
-                      return;
-                    }
-                    try {
-                      for (var iter2 = __forAwait(this.postprocess(
-                        invocationContext,
-                        llmRequest,
-                        llmResponse,
-                        modelResponseEvent
-                      )), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
-                        const event = temp2.value;
-                        if ((_b3 = invocationContext.abortSignal) == null ? void 0 : _b3.aborted) {
-                          return;
-                        }
-                        modelResponseEvent.id = createNewEventId();
-                        modelResponseEvent.timestamp = (/* @__PURE__ */ new Date()).getTime();
-                        yield event;
-                      }
-                    } 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];
-                  }
-                }
-              });
-            }, "responsesGenerator");
-            yield* __yieldStar(this.runAndHandleError(
-              responsesGenerator.call(this),
-              invocationContext,
-              llmRequest,
-              modelResponseEvent
-            ));
-          });
-        }
-      ));
-      span.end();
-    });
-  }
-  postprocess(invocationContext, llmRequest, llmResponse, modelResponseEvent) {
-    return __asyncGenerator(this, null, function* () {
-      var _a2, _b2, _c, _d, _e, _f;
-      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;
-            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];
-          }
-        }
-      }
-      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));
-      if (mergedEvent.content) {
-        const functionCalls = getFunctionCalls(mergedEvent);
-        const setModelResponseCall = functionCalls.find(
-          (call) => call.name === "set_model_response"
-        );
-        if (setModelResponseCall) {
-          const args = setModelResponseCall.args;
-          mergedEvent.content.parts = [{ text: JSON.stringify(args) }];
-          mergedEvent.actions.skipSummarization = true;
-        } else if (functionCalls && functionCalls.length) {
-          populateClientFunctionCallId(mergedEvent);
-          mergedEvent.longRunningToolIds = Array.from(
-            getLongRunningFunctionCalls(functionCalls, llmRequest.toolsDict)
-          );
-        }
-      }
-      yield mergedEvent;
-      if (!((_c = getFunctionCalls(mergedEvent)) == null ? void 0 : _c.length)) {
-        return;
-      }
-      if ((_d = invocationContext.runConfig) == null ? void 0 : _d.pauseOnToolCalls) {
-        invocationContext.endInvocation = true;
-        return;
-      }
-      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;
-      }
-      const authEvent = generateAuthEvent(
-        invocationContext,
-        functionResponseEvent
-      );
-      if (authEvent) {
-        yield authEvent;
-      }
-      const toolConfirmationEvent = generateRequestConfirmationEvent({
-        invocationContext,
-        functionCallEvent: mergedEvent,
-        functionResponseEvent
-      });
-      if (toolConfirmationEvent) {
-        yield toolConfirmationEvent;
-        invocationContext.endInvocation = true;
-        return;
-      }
-      yield functionResponseEvent;
-      const nextAgentName = functionResponseEvent.actions.transferToAgent;
-      if (nextAgentName) {
-        const nextAgent = this.getAgentByName(invocationContext, nextAgentName);
-        try {
-          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 (temp3) {
-          error3 = [temp3];
-        } finally {
-          try {
-            more3 && (temp3 = iter3.return) && (yield new __await(temp3.call(iter3)));
-          } finally {
-            if (error3)
-              throw error3[0];
-          }
-        }
-      }
-    });
-  }
-  /**
-   * Retrieves an agent from the agent tree by its name.
-   *
-   * Performing a depth-first search to locate the agent with the given name.
-   * - Starts searching from the root agent of the current invocation context.
-   * - Traverses down the agent tree to find the specified agent.
-   *
-   * @param invocationContext The current invocation context.
-   * @param agentName The name of the agent to retrieve.
-   * @returns The agent with the given name.
-   * @throws Error if the agent is not found.
-   */
-  getAgentByName(invocationContext, agentName) {
-    const rootAgent = requireAgent(invocationContext).rootAgent;
-    const agentToRun = rootAgent.findAgent(agentName);
-    if (!agentToRun) {
-      throw new Error("Agent ".concat(agentName, " not found in the agent tree."));
-    }
-    return agentToRun;
-  }
-  callLlmAsync(invocationContext, llmRequest, modelResponseEvent) {
-    return __asyncGenerator(this, null, function* () {
-      var _a2, _b2, _c, _d, _e, _f, _g, _h;
-      const beforeModelResponse = yield new __await(this.handleBeforeModelCallback(
-        invocationContext,
-        llmRequest,
-        modelResponseEvent
-      ));
-      if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
-        return;
-      }
-      if (beforeModelResponse) {
-        yield beforeModelResponse;
-        return;
-      }
-      (_b2 = llmRequest.config) != null ? _b2 : llmRequest.config = {};
-      (_d = (_c = llmRequest.config).labels) != null ? _d : _c.labels = {};
-      if (!llmRequest.config.labels[ADK_AGENT_NAME_LABEL_KEY]) {
-        llmRequest.config.labels[ADK_AGENT_NAME_LABEL_KEY] = this.name;
-      }
-      const llm = this.canonicalModel;
-      if ((_e = invocationContext.runConfig) == null ? void 0 : _e.supportCfc) {
-        throw new Error("CFC is not yet supported in callLlmAsync");
-      } else {
-        invocationContext.incrementLlmCallCount();
-        const responsesGenerator = llm.generateContentAsync(
-          llmRequest,
-          /* stream= */
-          ((_f = invocationContext.runConfig) == null ? void 0 : _f.streamingMode) === StreamingMode.SSE,
-          invocationContext.abortSignal
-        );
-        try {
-          for (var iter = __forAwait(responsesGenerator), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-            const llmResponse = temp.value;
-            traceCallLlm({
-              invocationContext,
-              eventId: modelResponseEvent.id,
-              llmRequest,
-              llmResponse
-            });
-            if ((_g = invocationContext.abortSignal) == null ? void 0 : _g.aborted) {
-              return;
-            }
-            const alteredLlmResponse = yield new __await(this.handleAfterModelCallback(
-              invocationContext,
-              llmResponse,
-              modelResponseEvent
-            ));
-            if ((_h = invocationContext.abortSignal) == null ? void 0 : _h.aborted) {
-              return;
-            }
-            yield alteredLlmResponse != null ? alteredLlmResponse : llmResponse;
-          }
-        } catch (temp) {
-          error = [temp];
-        } finally {
-          try {
-            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-          } finally {
-            if (error)
-              throw error[0];
-          }
-        }
-      }
-    });
-  }
-  async handleBeforeModelCallback(invocationContext, llmRequest, modelResponseEvent) {
-    var _a2, _b2;
-    const callbackContext = new Context({
-      invocationContext,
-      eventActions: modelResponseEvent.actions
-    });
-    const beforeModelCallbackResponse = await invocationContext.pluginManager.runBeforeModelCallback({
-      callbackContext,
-      llmRequest
-    });
-    if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
-      return;
-    }
-    if (beforeModelCallbackResponse) {
-      return beforeModelCallbackResponse;
-    }
-    for (const callback of this.canonicalBeforeModelCallbacks) {
-      const callbackResponse = await callback({
-        context: callbackContext,
-        request: llmRequest
-      });
-      if ((_b2 = invocationContext.abortSignal) == null ? void 0 : _b2.aborted) {
-        return;
-      }
-      if (callbackResponse) {
-        return callbackResponse;
-      }
-    }
-    return void 0;
-  }
-  async handleAfterModelCallback(invocationContext, llmResponse, modelResponseEvent) {
-    var _a2;
-    const callbackContext = new Context({
-      invocationContext,
-      eventActions: modelResponseEvent.actions
-    });
-    const afterModelCallbackResponse = await invocationContext.pluginManager.runAfterModelCallback({
-      callbackContext,
-      llmResponse
-    });
-    if (afterModelCallbackResponse) {
-      return afterModelCallbackResponse;
-    }
-    for (const callback of this.canonicalAfterModelCallbacks) {
-      const callbackResponse = await callback({
-        context: callbackContext,
-        response: llmResponse
-      });
-      if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
-        return;
-      }
-      if (callbackResponse) {
-        return callbackResponse;
-      }
-    }
-    return void 0;
-  }
-  runAndHandleError(responseGenerator, invocationContext, llmRequest, modelResponseEvent) {
-    return __asyncGenerator(this, null, function* () {
-      var _a2;
-      try {
-        try {
-          for (var iter = __forAwait(responseGenerator), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-            const response = temp.value;
-            if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
-              return;
-            }
-            yield response;
-          }
-        } catch (temp) {
-          error = [temp];
-        } finally {
-          try {
-            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-          } finally {
-            if (error)
-              throw error[0];
-          }
-        }
-      } catch (modelError) {
-        const callbackContext = new Context({
-          invocationContext,
-          eventActions: modelResponseEvent.actions
-        });
-        if (modelError instanceof Error) {
-          const onModelErrorCallbackResponse = yield new __await(invocationContext.pluginManager.runOnModelErrorCallback({
-            callbackContext,
-            llmRequest,
-            error: modelError
-          }));
-          if (onModelErrorCallbackResponse) {
-            yield onModelErrorCallbackResponse;
-          } else {
-            let errorCode = "UNKNOWN_ERROR";
-            let errorMessage = modelError.message;
-            try {
-              const errorResponse = JSON.parse(modelError.message);
-              if (errorResponse == null ? void 0 : errorResponse.error) {
-                errorCode = String(errorResponse.error.code || "UNKNOWN_ERROR");
-                errorMessage = errorResponse.error.message || errorMessage;
-              }
-            } catch (e) {
-            }
-            if (modelResponseEvent.actions) {
-              yield createEvent({
-                invocationId: invocationContext.invocationId,
-                author: this.name,
-                errorCode,
-                errorMessage
-              });
-            } else {
-              yield {
-                errorCode,
-                errorMessage
-              };
-            }
-          }
-        } else {
-          logger.error("Unknown error during response generation", modelError);
-          throw modelError;
-        }
-      }
-    });
-  }
-  // --------------------------------------------------------------------------
-  // #END LlmFlow Logic
-  // --------------------------------------------------------------------------
-  // TODO - b/425992518: omitted Py LlmAgent features.
-  // - code_executor
-  // - configurable agents by yaml config
-};
-__name(_LlmAgent, "LlmAgent");
-let LlmAgent = _LlmAgent;
-export {
-  LlmAgent,
-  isLlmAgent
-};