@google/adk 0.1.0

package/dist/esm/agents/llm_agent.js

@@ -0,0 +1,828 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from "zod";
+import { createEvent, createNewEventId, getFunctionCalls, getFunctionResponses, isFinalResponse } from "../events/event.js";
+import { BaseLlm } from "../models/base_llm.js";
+import { appendInstructions, setOutputSchema } from "../models/llm_request.js";
+import { LLMRegistry } from "../models/registry.js";
+import { BaseTool } from "../tools/base_tool.js";
+import { FunctionTool } from "../tools/function_tool.js";
+import { ToolConfirmation } from "../tools/tool_confirmation.js";
+import { ToolContext } from "../tools/tool_context.js";
+import { logger } from "../utils/logger.js";
+import { BaseAgent } from "./base_agent.js";
+import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
+import { CallbackContext } from "./callback_context.js";
+import { getContents, getCurrentTurnContents } from "./content_processor_utils.js";
+import { generateAuthEvent, generateRequestConfirmationEvent, getLongRunningFunctionCalls, handleFunctionCallList, handleFunctionCallsAsync, populateClientFunctionCallId, REQUEST_CONFIRMATION_FUNCTION_CALL_NAME } from "./functions.js";
+import { injectSessionState } from "./instructions.js";
+import { ReadonlyContext } from "./readonly_context.js";
+const ADK_AGENT_NAME_LABEL_KEY = "adk_agent_name";
+async function convertToolUnionToTools(toolUnion, context) {
+  if (toolUnion instanceof BaseTool) {
+    return [toolUnion];
+  }
+  return await toolUnion.getTools(context);
+}
+class BasicLlmRequestProcessor extends BaseLlmRequestProcessor {
+  async *runAsync(invocationContext, llmRequest) {
+    var _a;
+    const agent = invocationContext.agent;
+    if (!(agent instanceof LlmAgent)) {
+      return;
+    }
+    llmRequest.model = agent.canonicalModel.model;
+    llmRequest.config = { ...(_a = agent.generateContentConfig) != null ? _a : {} };
+    if (agent.outputSchema) {
+      setOutputSchema(llmRequest, agent.outputSchema);
+    }
+    if (invocationContext.runConfig) {
+      llmRequest.liveConnectConfig.responseModalities = invocationContext.runConfig.responseModalities;
+      llmRequest.liveConnectConfig.speechConfig = invocationContext.runConfig.speechConfig;
+      llmRequest.liveConnectConfig.outputAudioTranscription = invocationContext.runConfig.outputAudioTranscription;
+      llmRequest.liveConnectConfig.inputAudioTranscription = invocationContext.runConfig.inputAudioTranscription;
+      llmRequest.liveConnectConfig.realtimeInputConfig = invocationContext.runConfig.realtimeInputConfig;
+      llmRequest.liveConnectConfig.enableAffectiveDialog = invocationContext.runConfig.enableAffectiveDialog;
+      llmRequest.liveConnectConfig.proactivity = invocationContext.runConfig.proactivity;
+    }
+  }
+}
+const BASIC_LLM_REQUEST_PROCESSOR = new BasicLlmRequestProcessor();
+class IdentityLlmRequestProcessor extends BaseLlmRequestProcessor {
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    const si = [`You are an agent. Your internal name is "${agent.name}".`];
+    if (agent.description) {
+      si.push(`The description about you is "${agent.description}"`);
+    }
+    appendInstructions(llmRequest, si);
+  }
+}
+const IDENTITY_LLM_REQUEST_PROCESSOR = new IdentityLlmRequestProcessor();
+class InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
+  /**
+   * Handles instructions and global instructions for LLM flow.
+   */
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    if (!(agent instanceof LlmAgent) || !(agent.rootAgent instanceof LlmAgent)) {
+      return;
+    }
+    const rootAgent = agent.rootAgent;
+    if (rootAgent instanceof LlmAgent && rootAgent.globalInstruction) {
+      const { instruction, requireStateInjection } = await rootAgent.canonicalGlobalInstruction(
+        new ReadonlyContext(invocationContext)
+      );
+      let instructionWithState = instruction;
+      if (requireStateInjection) {
+        instructionWithState = await injectSessionState(
+          instruction,
+          new ReadonlyContext(invocationContext)
+        );
+      }
+      appendInstructions(llmRequest, [instructionWithState]);
+    }
+    if (agent.instruction) {
+      const { instruction, requireStateInjection } = await agent.canonicalInstruction(
+        new ReadonlyContext(invocationContext)
+      );
+      let instructionWithState = instruction;
+      if (requireStateInjection) {
+        instructionWithState = await injectSessionState(
+          instruction,
+          new ReadonlyContext(invocationContext)
+        );
+      }
+      appendInstructions(llmRequest, [instructionWithState]);
+    }
+  }
+}
+const INSTRUCTIONS_LLM_REQUEST_PROCESSOR = new InstructionsLlmRequestProcessor();
+class ContentRequestProcessor {
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    if (!agent || !(agent instanceof LlmAgent)) {
+      return;
+    }
+    if (agent.includeContents === "default") {
+      llmRequest.contents = getContents(
+        invocationContext.session.events,
+        agent.name,
+        invocationContext.branch
+      );
+    } else {
+      llmRequest.contents = getCurrentTurnContents(
+        invocationContext.session.events,
+        agent.name,
+        invocationContext.branch
+      );
+    }
+    return;
+  }
+}
+const CONTENT_REQUEST_PROCESSOR = new ContentRequestProcessor();
+class AgentTransferLlmRequestProcessor extends BaseLlmRequestProcessor {
+  constructor() {
+    super(...arguments);
+    this.toolName = "transfer_to_agent";
+    this.tool = new FunctionTool({
+      name: this.toolName,
+      description: "Transfer the question to another agent. This tool hands off control to another agent when it is more suitable to answer the user question according to the agent description.",
+      parameters: z.object({
+        agentName: z.string().describe("the agent name to transfer to.")
+      }),
+      execute: function(args, toolContext) {
+        if (!toolContext) {
+          throw new Error("toolContext is required.");
+        }
+        toolContext.actions.transferToAgent = args.agentName;
+      }
+    });
+  }
+  async *runAsync(invocationContext, llmRequest) {
+    if (!(invocationContext.agent instanceof LlmAgent)) {
+      return;
+    }
+    const transferTargets = this.getTransferTargets(invocationContext.agent);
+    if (!transferTargets.length) {
+      return;
+    }
+    appendInstructions(llmRequest, [
+      this.buildTargetAgentsInstructions(
+        invocationContext.agent,
+        transferTargets
+      )
+    ]);
+    const toolContext = new ToolContext({ invocationContext });
+    await this.tool.processLlmRequest({ toolContext, llmRequest });
+  }
+  buildTargetAgentsInfo(targetAgent) {
+    return `
+Agent name: ${targetAgent.name}
+Agent description: ${targetAgent.description}
+`;
+  }
+  buildTargetAgentsInstructions(agent, targetAgents) {
+    let instructions = `
+You have a list of other agents to transfer to:
+
+${targetAgents.map(this.buildTargetAgentsInfo).join("\n")}
+
+If you are the best to answer the question according to your description, you
+can answer it.
+
+If another agent is better for answering the question according to its
+description, call \`${this.toolName}\` function to transfer the
+question to that agent. When transferring, do not generate any text other than
+the function call.
+`;
+    if (agent.parentAgent && !agent.disallowTransferToParent) {
+      instructions += `
+Your parent agent is ${agent.parentAgent.name}. If neither the other agents nor
+you are best for answering the question according to the descriptions, transfer
+to your parent agent.
+`;
+    }
+    return instructions;
+  }
+  getTransferTargets(agent) {
+    const targets = [];
+    targets.push(...agent.subAgents);
+    if (!agent.parentAgent || !(agent.parentAgent instanceof LlmAgent)) {
+      return targets;
+    }
+    if (!agent.disallowTransferToParent) {
+      targets.push(agent.parentAgent);
+    }
+    if (!agent.disallowTransferToPeers) {
+      targets.push(
+        ...agent.parentAgent.subAgents.filter(
+          (peerAgent) => peerAgent.name !== agent.name
+        )
+      );
+    }
+    return targets;
+  }
+}
+const AGENT_TRANSFER_LLM_REQUEST_PROCESSOR = new AgentTransferLlmRequestProcessor();
+class RequestConfirmationLlmRequestProcessor extends BaseLlmRequestProcessor {
+  /** Handles tool confirmation information to build the LLM request. */
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    if (!(agent instanceof LlmAgent)) {
+      return;
+    }
+    const events = invocationContext.session.events;
+    if (!events || events.length === 0) {
+      return;
+    }
+    const requestConfirmationFunctionResponses = {};
+    let confirmationEventIndex = -1;
+    for (let i = events.length - 1; i >= 0; i--) {
+      const event = events[i];
+      if (event.author !== "user") {
+        continue;
+      }
+      const responses = getFunctionResponses(event);
+      if (!responses) {
+        continue;
+      }
+      let foundConfirmation = false;
+      for (const functionResponse of responses) {
+        if (functionResponse.name !== REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
+          continue;
+        }
+        foundConfirmation = true;
+        let toolConfirmation = null;
+        if (functionResponse.response && Object.keys(functionResponse.response).length === 1 && "response" in functionResponse.response) {
+          toolConfirmation = JSON.parse(functionResponse.response["response"]);
+        } else if (functionResponse.response) {
+          toolConfirmation = new ToolConfirmation({
+            hint: functionResponse.response["hint"],
+            payload: functionResponse.response["payload"],
+            confirmed: functionResponse.response["confirmed"]
+          });
+        }
+        if (functionResponse.id && toolConfirmation) {
+          requestConfirmationFunctionResponses[functionResponse.id] = toolConfirmation;
+        }
+      }
+      if (foundConfirmation) {
+        confirmationEventIndex = i;
+        break;
+      }
+    }
+    if (Object.keys(requestConfirmationFunctionResponses).length === 0) {
+      return;
+    }
+    for (let i = confirmationEventIndex - 1; i >= 0; i--) {
+      const event = events[i];
+      const functionCalls = getFunctionCalls(event);
+      if (!functionCalls) {
+        continue;
+      }
+      const toolsToResumeWithConfirmation = {};
+      const toolsToResumeWithArgs = {};
+      for (const functionCall of functionCalls) {
+        if (!functionCall.id || !(functionCall.id in requestConfirmationFunctionResponses)) {
+          continue;
+        }
+        const args = functionCall.args;
+        if (!args || !("originalFunctionCall" in args)) {
+          continue;
+        }
+        const originalFunctionCall = args["originalFunctionCall"];
+        if (originalFunctionCall.id) {
+          toolsToResumeWithConfirmation[originalFunctionCall.id] = requestConfirmationFunctionResponses[functionCall.id];
+          toolsToResumeWithArgs[originalFunctionCall.id] = originalFunctionCall;
+        }
+      }
+      if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+        continue;
+      }
+      for (let j = events.length - 1; j > confirmationEventIndex; j--) {
+        const eventToCheck = events[j];
+        const functionResponses = getFunctionResponses(eventToCheck);
+        if (!functionResponses) {
+          continue;
+        }
+        for (const fr of functionResponses) {
+          if (fr.id && fr.id in toolsToResumeWithConfirmation) {
+            delete toolsToResumeWithConfirmation[fr.id];
+            delete toolsToResumeWithArgs[fr.id];
+          }
+        }
+        if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+          break;
+        }
+      }
+      if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+        continue;
+      }
+      const toolsList = await agent.canonicalTools(new ReadonlyContext(invocationContext));
+      const toolsDict = Object.fromEntries(toolsList.map((tool) => [tool.name, tool]));
+      const functionResponseEvent = await handleFunctionCallList({
+        invocationContext,
+        functionCalls: Object.values(toolsToResumeWithArgs),
+        toolsDict,
+        beforeToolCallbacks: agent.canonicalBeforeToolCallbacks,
+        afterToolCallbacks: agent.canonicalAfterToolCallbacks,
+        filters: new Set(Object.keys(toolsToResumeWithConfirmation)),
+        toolConfirmationDict: toolsToResumeWithConfirmation
+      });
+      if (functionResponseEvent) {
+        yield functionResponseEvent;
+      }
+      return;
+    }
+  }
+}
+const REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR = new RequestConfirmationLlmRequestProcessor();
+class LlmAgent extends BaseAgent {
+  constructor(config) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    super(config);
+    this.model = config.model;
+    this.instruction = (_a = config.instruction) != null ? _a : "";
+    this.globalInstruction = (_b = config.globalInstruction) != null ? _b : "";
+    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 = config.inputSchema;
+    this.outputSchema = config.outputSchema;
+    this.outputKey = config.outputKey;
+    this.beforeModelCallback = config.beforeModelCallback;
+    this.afterModelCallback = config.afterModelCallback;
+    this.beforeToolCallback = config.beforeToolCallback;
+    this.afterToolCallback = config.afterToolCallback;
+    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
+    ];
+    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 ${this.name}: outputSchema cannot co-exist with agent transfer configurations. Setting disallowTransferToParent=true, disallowTransferToPeers=true`
+        );
+        this.disallowTransferToParent = true;
+        this.disallowTransferToPeers = true;
+      }
+      if (this.subAgents && this.subAgents.length > 0) {
+        throw new Error(
+          `Invalid config for agent ${this.name}: if outputSchema is set, subAgents must be empty to disable agent transfer.`
+        );
+      }
+      if (this.tools && this.tools.length > 0) {
+        throw new Error(
+          `Invalid config for agent ${this.name}: if outputSchema is set, tools must be empty`
+        );
+      }
+    }
+  }
+  /**
+   * The resolved BaseLlm instance.
+   *
+   * When not set, the agent will inherit the model from its ancestor.
+   */
+  get canonicalModel() {
+    if (this.model instanceof BaseLlm) {
+      return this.model;
+    }
+    if (typeof this.model === "string" && this.model) {
+      return LLMRegistry.newLlm(this.model);
+    }
+    let ancestorAgent = this.parentAgent;
+    while (ancestorAgent) {
+      if (ancestorAgent instanceof LlmAgent) {
+        return ancestorAgent.canonicalModel;
+      }
+      ancestorAgent = ancestorAgent.parentAgent;
+    }
+    throw new Error(`No model found for ${this.name}.`);
+  }
+  /**
+   * The resolved self.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 self.instruction field.
+   */
+  async canonicalInstruction(context) {
+    if (typeof this.instruction === "string") {
+      return { instruction: this.instruction, requireStateInjection: true };
+    }
+    return {
+      instruction: await this.instruction(context),
+      requireStateInjection: false
+    };
+  }
+  /**
+   * The resolved self.instruction 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 self.global_instruction field.
+   */
+  async canonicalGlobalInstruction(context) {
+    if (typeof this.globalInstruction === "string") {
+      return { instruction: this.globalInstruction, requireStateInjection: true };
+    }
+    return {
+      instruction: await this.globalInstruction(context),
+      requireStateInjection: false
+    };
+  }
+  /**
+   * The resolved self.tools field as a list of BaseTool based on the context.
+   *
+   * This method is only for use by Agent Development Kit.
+   */
+  async canonicalTools(context) {
+    const resolvedTools = [];
+    for (const toolUnion of this.tools) {
+      const tools = await convertToolUnionToTools(toolUnion, context);
+      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 self.before_model_callback 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 self.after_model_callback 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 self.before_tool_callback 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 self.after_tool_callback 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 _a, _b;
+    if (event.author !== this.name) {
+      logger.debug(
+        `Skipping output save for agent ${this.name}: event authored by ${event.author}`
+      );
+      return;
+    }
+    if (!this.outputKey) {
+      logger.debug(
+        `Skipping output save for agent ${this.name}: outputKey is not set`
+      );
+      return;
+    }
+    if (!isFinalResponse(event)) {
+      logger.debug(
+        `Skipping output save for agent ${this.name}: event is not a final response`
+      );
+      return;
+    }
+    if (!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length)) {
+      logger.debug(
+        `Skipping output save for agent ${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 ${this.name}`, e);
+      }
+    }
+    event.actions.stateDelta[this.outputKey] = result;
+  }
+  async *runAsyncImpl(context) {
+    while (true) {
+      let lastEvent = void 0;
+      for await (const event of this.runOneStepAsync(context)) {
+        lastEvent = event;
+        this.maybeSaveOutputToState(event);
+        yield event;
+      }
+      if (!lastEvent || isFinalResponse(lastEvent)) {
+        break;
+      }
+      if (lastEvent.partial) {
+        logger.warn("The last event is partial, which is not expected.");
+        break;
+      }
+    }
+  }
+  async *runLiveImpl(context) {
+    for await (const event of this.runLiveFlow(context)) {
+      this.maybeSaveOutputToState(event);
+      yield event;
+    }
+    if (context.endInvocation) {
+      return;
+    }
+  }
+  // --------------------------------------------------------------------------
+  // #START LlmFlow Logic
+  // --------------------------------------------------------------------------
+  async *runLiveFlow(invocationContext) {
+    await Promise.resolve();
+    throw new Error("LlmAgent.runLiveFlow not implemented");
+  }
+  async *runOneStepAsync(invocationContext) {
+    const llmRequest = {
+      contents: [],
+      toolsDict: {},
+      liveConnectConfig: {}
+    };
+    for (const processor of this.requestProcessors) {
+      for await (const event of processor.runAsync(invocationContext, llmRequest)) {
+        yield event;
+      }
+    }
+    for (const toolUnion of this.tools) {
+      const toolContext = new ToolContext({ invocationContext });
+      const tools = await convertToolUnionToTools(
+        toolUnion,
+        new ReadonlyContext(invocationContext)
+      );
+      for (const tool of tools) {
+        await tool.processLlmRequest({ toolContext, llmRequest });
+      }
+    }
+    if (invocationContext.endInvocation) {
+      return;
+    }
+    const modelResponseEvent = createEvent({
+      invocationId: invocationContext.invocationId,
+      author: this.name,
+      branch: invocationContext.branch
+    });
+    for await (const llmResponse of this.callLlmAsync(
+      invocationContext,
+      llmRequest,
+      modelResponseEvent
+    )) {
+      for await (const event of this.postprocess(
+        invocationContext,
+        llmRequest,
+        llmResponse,
+        modelResponseEvent
+      )) {
+        modelResponseEvent.id = createNewEventId();
+        modelResponseEvent.timestamp = (/* @__PURE__ */ new Date()).getTime();
+        yield event;
+      }
+    }
+  }
+  async *postprocess(invocationContext, llmRequest, llmResponse, modelResponseEvent) {
+    var _a;
+    for (const processor of this.responseProcessors) {
+      for await (const event of processor.runAsync(invocationContext, llmResponse)) {
+        yield event;
+      }
+    }
+    if (!llmResponse.content && !llmResponse.errorCode && !llmResponse.interrupted) {
+      return;
+    }
+    const mergedEvent = createEvent({
+      ...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 (!((_a = getFunctionCalls(mergedEvent)) == null ? void 0 : _a.length)) {
+      return;
+    }
+    const functionResponseEvent = await handleFunctionCallsAsync({
+      invocationContext,
+      functionCallEvent: mergedEvent,
+      toolsDict: llmRequest.toolsDict,
+      beforeToolCallbacks: this.canonicalBeforeToolCallbacks,
+      afterToolCallbacks: this.canonicalAfterToolCallbacks
+    });
+    if (!functionResponseEvent) {
+      return;
+    }
+    const authEvent = generateAuthEvent(invocationContext, functionResponseEvent);
+    if (authEvent) {
+      yield authEvent;
+    }
+    const toolConfirmationEvent = generateRequestConfirmationEvent({
+      invocationContext,
+      functionCallEvent: mergedEvent,
+      functionResponseEvent
+    });
+    if (toolConfirmationEvent) {
+      yield toolConfirmationEvent;
+    }
+    yield functionResponseEvent;
+    const nextAgentName = functionResponseEvent.actions.transferToAgent;
+    if (nextAgentName) {
+      const nextAgent = this.getAgentByName(invocationContext, nextAgentName);
+      for await (const event of nextAgent.runAsync(invocationContext)) {
+        yield event;
+      }
+    }
+  }
+  /**
+   * 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 ${agentName} not found in the agent tree.`);
+    }
+    return agentToRun;
+  }
+  async *callLlmAsync(invocationContext, llmRequest, modelResponseEvent) {
+    var _a, _b, _c, _d;
+    const beforeModelResponse = await this.handleBeforeModelCallback(
+      invocationContext,
+      llmRequest,
+      modelResponseEvent
+    );
+    if (beforeModelResponse) {
+      yield beforeModelResponse;
+      return;
+    }
+    (_a = llmRequest.config) != null ? _a : llmRequest.config = {};
+    (_c = (_b = llmRequest.config).labels) != null ? _c : _b.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 ((_d = invocationContext.runConfig) == null ? void 0 : _d.supportCfc) {
+      throw new Error("CFC is not yet supported in callLlmAsync");
+    } else {
+      invocationContext.incrementLlmCallCount();
+      const responsesGenerator = llm.generateContentAsync(llmRequest);
+      for await (const llmResponse of this.runAndHandleError(
+        responsesGenerator,
+        invocationContext,
+        llmRequest,
+        modelResponseEvent
+      )) {
+        const alteredLlmResponse = await this.handleAfterModelCallback(
+          invocationContext,
+          llmResponse,
+          modelResponseEvent
+        );
+        yield alteredLlmResponse != null ? alteredLlmResponse : llmResponse;
+      }
+    }
+  }
+  async handleBeforeModelCallback(invocationContext, llmRequest, modelResponseEvent) {
+    const callbackContext = new CallbackContext(
+      { invocationContext, eventActions: modelResponseEvent.actions }
+    );
+    const beforeModelCallbackResponse = await invocationContext.pluginManager.runBeforeModelCallback(
+      { callbackContext, llmRequest }
+    );
+    if (beforeModelCallbackResponse) {
+      return beforeModelCallbackResponse;
+    }
+    for (const callback of this.canonicalBeforeModelCallbacks) {
+      const callbackResponse = await callback({ context: callbackContext, request: llmRequest });
+      if (callbackResponse) {
+        return callbackResponse;
+      }
+    }
+    return void 0;
+  }
+  async handleAfterModelCallback(invocationContext, llmResponse, modelResponseEvent) {
+    const callbackContext = new CallbackContext(
+      { 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 (callbackResponse) {
+        return callbackResponse;
+      }
+    }
+    return void 0;
+  }
+  async *runAndHandleError(responseGenerator, invocationContext, llmRequest, modelResponseEvent) {
+    try {
+      for await (const response of responseGenerator) {
+        yield response;
+      }
+    } catch (modelError) {
+      const callbackContext = new CallbackContext(
+        { invocationContext, eventActions: modelResponseEvent.actions }
+      );
+      if (modelError instanceof Error) {
+        const onModelErrorCallbackResponse = await invocationContext.pluginManager.runOnModelErrorCallback({
+          callbackContext,
+          llmRequest,
+          error: modelError
+        });
+        if (onModelErrorCallbackResponse) {
+          yield onModelErrorCallbackResponse;
+        } else {
+          const errorResponse = JSON.parse(modelError.message);
+          yield {
+            errorCode: String(errorResponse.error.code),
+            errorMessage: errorResponse.error.message
+          };
+        }
+      } 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,
+  REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR
+};