@softactivate/adk 1.1.0

package/dist/web/agents/llm_agent.js

@@ -0,0 +1,907 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+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 __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 {
+  createEvent,
+  createNewEventId,
+  getFunctionCalls,
+  isFinalResponse
+} 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 { Context } from "./context.js";
+import {
+  runAsyncGeneratorWithOtelContext,
+  traceCallLlm,
+  tracer
+} from "../telemetry/tracing.js";
+import { isZodObject, zodObjectToSchema } from "../utils/simple_zod_to_json.js";
+import { BaseAgent } from "./base_agent.js";
+import {
+  generateAuthEvent,
+  generateRequestConfirmationEvent,
+  getLongRunningFunctionCalls,
+  handleFunctionCallsStreamingAsync,
+  populateClientFunctionCallId
+} from "./functions.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 { REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR } from "./processors/request_confirmation_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 ADK_AGENT_NAME_LABEL_KEY = "adk_agent_name";
+async function convertToolUnionToTools(toolUnion, context2) {
+  if (isBaseTool(toolUnion)) {
+    return [toolUnion];
+  }
+  return await toolUnion.getTools(context2);
+}
+const LLM_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.llmAgent");
+function isLlmAgent(obj) {
+  return typeof obj === "object" && obj !== null && LLM_AGENT_SIGNATURE_SYMBOL in obj && obj[LLM_AGENT_SIGNATURE_SYMBOL] === true;
+}
+class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
+  constructor(config) {
+    var _a2, _b2, _c, _d, _e, _f, _g, _h, _i;
+    super(config);
+    /** 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.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.inputSchema = isZodObject(config.inputSchema) ? zodObjectToSchema(config.inputSchema) : config.inputSchema;
+    this.outputSchema = isZodObject(config.outputSchema) ? zodObjectToSchema(config.outputSchema) : config.outputSchema;
+    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 : [
+      BASIC_LLM_REQUEST_PROCESSOR,
+      IDENTITY_LLM_REQUEST_PROCESSOR,
+      INSTRUCTIONS_LLM_REQUEST_PROCESSOR,
+      REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
+      CONTENT_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 = (_h = config.responseProcessors) != null ? _h : [];
+    const agentTransferDisabled = this.disallowTransferToParent && this.disallowTransferToPeers && !((_i = this.subAgents) == null ? void 0 : _i.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) {
+      if (!this.disallowTransferToParent || !this.disallowTransferToPeers) {
+        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 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.
+   */
+  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;
+      }
+      try {
+        result = JSON.parse(resultStr);
+      } catch (e) {
+        logger.error("Error parsing output for agent ".concat(this.name), e);
+      }
+    }
+    event.actions.stateDelta[this.outputKey] = result;
+  }
+  runAsyncImpl(context2) {
+    return __asyncGenerator(this, null, function* () {
+      var _a2;
+      while (true) {
+        let lastEvent = void 0;
+        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;
+            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 || isFinalResponse(lastEvent)) {
+          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
+  // --------------------------------------------------------------------------
+  // eslint-disable-next-line require-yield
+  runLiveFlow(_invocationContext) {
+    return __asyncGenerator(this, null, function* () {
+      yield new __await(Promise.resolve());
+      throw new Error("LlmAgent.runLiveFlow not implemented");
+    });
+  }
+  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];
+          }
+        }
+      }
+      for (const toolUnion of this.tools) {
+        const toolContext = new Context({ invocationContext });
+        const tools = (yield new __await(convertToolUnionToTools(
+          toolUnion,
+          new ReadonlyContext(invocationContext)
+        ))).filter((tool) => {
+          return !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;
+          }
+        }
+      }
+      if (invocationContext.endInvocation || ((_c = invocationContext.abortSignal) == null ? void 0 : _c.aborted)) {
+        return;
+      }
+      const modelResponseEvent = createEvent({
+        invocationId: invocationContext.invocationId,
+        author: this.name,
+        branch: invocationContext.branch
+      });
+      const span = tracer.startSpan("call_llm");
+      const ctx = trace.setSpan(context.active(), span);
+      yield* __yieldStar(runAsyncGeneratorWithOtelContext(
+        ctx,
+        this,
+        function() {
+          return __asyncGenerator(this, null, function* () {
+            const responsesGenerator = 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];
+                  }
+                }
+              });
+            };
+            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];
+          }
+        }
+      }
+      if (!llmResponse.content && !llmResponse.errorCode && !llmResponse.interrupted) {
+        return;
+      }
+      const mergedEvent = createEvent(__spreadValues(__spreadValues({}, modelResponseEvent), llmResponse));
+      if (mergedEvent.content) {
+        const functionCalls = getFunctionCalls(mergedEvent);
+        if (functionCalls == null ? void 0 : functionCalls.length) {
+          populateClientFunctionCallId(mergedEvent);
+          mergedEvent.longRunningToolIds = Array.from(
+            getLongRunningFunctionCalls(functionCalls, llmRequest.toolsDict)
+          );
+        }
+      }
+      yield mergedEvent;
+      if (!((_b2 = getFunctionCalls(mergedEvent)) == null ? void 0 : _b2.length)) {
+        return;
+      }
+      if ((_c = invocationContext.runConfig) == null ? void 0 : _c.pauseOnToolCalls) {
+        invocationContext.endInvocation = true;
+        return;
+      }
+      let functionResponseEvent = null;
+      let pendingEvent = null;
+      try {
+        for (var iter2 = __forAwait(handleFunctionCallsStreamingAsync({
+          invocationContext,
+          functionCallEvent: mergedEvent,
+          toolsDict: llmRequest.toolsDict,
+          beforeToolCallbacks: this.canonicalBeforeToolCallbacks,
+          afterToolCallbacks: this.canonicalAfterToolCallbacks
+        })), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
+          const event = temp2.value;
+          if ((_d = invocationContext.abortSignal) == null ? void 0 : _d.aborted) {
+            return;
+          }
+          if (pendingEvent) {
+            yield pendingEvent;
+          }
+          pendingEvent = event;
+        }
+      } catch (temp2) {
+        error2 = [temp2];
+      } finally {
+        try {
+          more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
+        } finally {
+          if (error2)
+            throw error2[0];
+        }
+      }
+      functionResponseEvent = pendingEvent;
+      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 = invocationContext.agent.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
+}
+export {
+  LlmAgent,
+  isLlmAgent
+};