@softactivate/adk 1.1.0

package/dist/esm/agents/llm_agent.js

@@ -0,0 +1,708 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @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 ${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 ${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 ${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 (!((_b2 = (_a2 = event.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b2.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(context2) {
+    var _a2;
+    while (true) {
+      let lastEvent = void 0;
+      for await (const event of this.runOneStepAsync(context2)) {
+        if ((_a2 = context2.abortSignal) == null ? void 0 : _a2.aborted) {
+          return;
+        }
+        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(context2) {
+    var _a2;
+    for await (const event of this.runLiveFlow(context2)) {
+      if ((_a2 = context2.abortSignal) == null ? void 0 : _a2.aborted) {
+        return;
+      }
+      this.maybeSaveOutputToState(event);
+      yield event;
+    }
+    if (context2.endInvocation) {
+      return;
+    }
+  }
+  // --------------------------------------------------------------------------
+  // #START LlmFlow Logic
+  // --------------------------------------------------------------------------
+  // eslint-disable-next-line require-yield
+  async *runLiveFlow(_invocationContext) {
+    await Promise.resolve();
+    throw new Error("LlmAgent.runLiveFlow not implemented");
+  }
+  async *runOneStepAsync(invocationContext) {
+    var _a2, _b2, _c;
+    const llmRequest = {
+      contents: [],
+      toolsDict: {},
+      liveConnectConfig: {}
+    };
+    for (const processor of this.requestProcessors) {
+      for await (const event of processor.runAsync(
+        invocationContext,
+        llmRequest
+      )) {
+        if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+          return;
+        }
+        yield event;
+      }
+    }
+    for (const toolUnion of this.tools) {
+      const toolContext = new Context({ invocationContext });
+      const tools = (await convertToolUnionToTools(
+        toolUnion,
+        new ReadonlyContext(invocationContext)
+      )).filter((tool) => {
+        return !llmRequest.allowedTools || llmRequest.allowedTools.includes(tool.name);
+      });
+      for (const tool of tools) {
+        await tool.processLlmRequest({ toolContext, llmRequest });
+        if ((_b2 = invocationContext.abortSignal) == null ? void 0 : _b2.aborted) {
+          return;
+        }
+      }
+    }
+    if (invocationContext.endInvocation || ((_c = invocationContext.abortSignal) == null ? void 0 : _c.aborted)) {
+      return;
+    }
+    const modelResponseEvent = createEvent({
+      invocationId: invocationContext.invocationId,
+      author: this.name,
+      branch: invocationContext.branch
+    });
+    const span = tracer.startSpan("call_llm");
+    const ctx = trace.setSpan(context.active(), span);
+    yield* runAsyncGeneratorWithOtelContext(
+      ctx,
+      this,
+      async function* () {
+        const responsesGenerator = async function* () {
+          var _a3, _b3;
+          for await (const llmResponse of this.callLlmAsync(
+            invocationContext,
+            llmRequest,
+            modelResponseEvent
+          )) {
+            if ((_a3 = invocationContext.abortSignal) == null ? void 0 : _a3.aborted) {
+              return;
+            }
+            for await (const event of this.postprocess(
+              invocationContext,
+              llmRequest,
+              llmResponse,
+              modelResponseEvent
+            )) {
+              if ((_b3 = invocationContext.abortSignal) == null ? void 0 : _b3.aborted) {
+                return;
+              }
+              modelResponseEvent.id = createNewEventId();
+              modelResponseEvent.timestamp = (/* @__PURE__ */ new Date()).getTime();
+              yield event;
+            }
+          }
+        };
+        yield* this.runAndHandleError(
+          responsesGenerator.call(this),
+          invocationContext,
+          llmRequest,
+          modelResponseEvent
+        );
+      }
+    );
+    span.end();
+  }
+  async *postprocess(invocationContext, llmRequest, llmResponse, modelResponseEvent) {
+    var _a2, _b2, _c, _d, _e, _f;
+    for (const processor of this.responseProcessors) {
+      for await (const event of processor.runAsync(
+        invocationContext,
+        llmResponse
+      )) {
+        if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+          return;
+        }
+        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 (!((_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;
+    for await (const event of handleFunctionCallsStreamingAsync({
+      invocationContext,
+      functionCallEvent: mergedEvent,
+      toolsDict: llmRequest.toolsDict,
+      beforeToolCallbacks: this.canonicalBeforeToolCallbacks,
+      afterToolCallbacks: this.canonicalAfterToolCallbacks
+    })) {
+      if ((_d = invocationContext.abortSignal) == null ? void 0 : _d.aborted) {
+        return;
+      }
+      if (pendingEvent) {
+        yield pendingEvent;
+      }
+      pendingEvent = event;
+    }
+    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);
+      for await (const event of nextAgent.runAsync(invocationContext)) {
+        if ((_f = invocationContext.abortSignal) == null ? void 0 : _f.aborted) {
+          return;
+        }
+        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 _a2, _b2, _c, _d, _e, _f, _g, _h;
+    const beforeModelResponse = 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
+      );
+      for await (const llmResponse of responsesGenerator) {
+        traceCallLlm({
+          invocationContext,
+          eventId: modelResponseEvent.id,
+          llmRequest,
+          llmResponse
+        });
+        if ((_g = invocationContext.abortSignal) == null ? void 0 : _g.aborted) {
+          return;
+        }
+        const alteredLlmResponse = await this.handleAfterModelCallback(
+          invocationContext,
+          llmResponse,
+          modelResponseEvent
+        );
+        if ((_h = invocationContext.abortSignal) == null ? void 0 : _h.aborted) {
+          return;
+        }
+        yield alteredLlmResponse != null ? alteredLlmResponse : llmResponse;
+      }
+    }
+  }
+  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;
+  }
+  async *runAndHandleError(responseGenerator, invocationContext, llmRequest, modelResponseEvent) {
+    var _a2;
+    try {
+      for await (const response of responseGenerator) {
+        if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+          return;
+        }
+        yield response;
+      }
+    } catch (modelError) {
+      const callbackContext = new Context({
+        invocationContext,
+        eventActions: modelResponseEvent.actions
+      });
+      if (modelError instanceof Error) {
+        const onModelErrorCallbackResponse = 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 {
+          }
+          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
+};