@google/adk 1.6.0 → 2.1.0

package/dist/web/agents/llm_agent.js

@@ -1,936 +0,0 @@
-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 { FunctionTool } from "../tools/function_tool.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 { 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 { 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 { 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,
-      AUTH_PREPROCESSOR,
-      IDENTITY_LLM_REQUEST_PROCESSOR,
-      INSTRUCTIONS_LLM_REQUEST_PROCESSOR,
-      REQUEST_CONFIRMATION_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 = (_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.
-   * @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;
-      }
-      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, _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.
-   */
-  // 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];
-          }
-        }
-      }
-      const allTools = [...this.tools];
-      if (this.outputSchema && allTools.length > 0 && !canUseOutputSchemaWithTools(this.canonicalModel.model)) {
-        const setModelResponseTool = new FunctionTool({
-          name: "set_model_response",
-          description: "Call this tool to submit your final response conforming to the output schema. Use this tool only when you have collected all the information and are ready to return the final answer.",
-          parameters: this.outputSchema,
-          execute: async (args, toolContext) => {
-            if (toolContext) {
-              toolContext.actions.skipSummarization = true;
-            }
-            return JSON.stringify(args);
-          }
-        });
-        allTools.push(setModelResponseTool);
-      }
-      for (const toolUnion of allTools) {
-        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) || 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 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 || ((_b2 = llmResponse.content.parts) == null ? void 0 : _b2.length) === 0) && !llmResponse.errorCode && !llmResponse.interrupted) {
-        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 functionResponseEvent = yield new __await(handleFunctionCallsAsync({
-        invocationContext,
-        functionCallEvent: mergedEvent,
-        toolsDict: llmRequest.toolsDict,
-        beforeToolCallbacks: this.canonicalBeforeToolCallbacks,
-        afterToolCallbacks: this.canonicalAfterToolCallbacks
-      }));
-      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 iter2 = __forAwait(nextAgent.runAsync(invocationContext)), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
-            const event = temp2.value;
-            if ((_f = invocationContext.abortSignal) == null ? void 0 : _f.aborted) {
-              return;
-            }
-            yield event;
-          }
-        } catch (temp2) {
-          error2 = [temp2];
-        } finally {
-          try {
-            more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
-          } finally {
-            if (error2)
-              throw error2[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
-};