@google/adk 0.3.0 → 0.5.0

package/dist/cjs/agents/llm_agent.js

@@ -1,6 +1,6 @@
 /**
   * @license
-  * Copyright 2025 Google LLC
+  * Copyright 2026 Google LLC
   * SPDX-License-Identifier: Apache-2.0
   */
 
@@ -25,37 +25,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var llm_agent_exports = {};
 __export(llm_agent_exports, {
   LlmAgent: () => LlmAgent,
-  REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR: () => REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
-  isLlmAgent: () => isLlmAgent,
-  responseProcessor: () => responseProcessor
+  isLlmAgent: () => isLlmAgent
 });
 module.exports = __toCommonJS(llm_agent_exports);
 var import_api = require("@opentelemetry/api");
-var import_lodash_es = require("lodash-es");
-var import_zod = require("zod");
-var import_base_code_executor = require("../code_executors/base_code_executor.js");
-var import_built_in_code_executor = require("../code_executors/built_in_code_executor.js");
-var import_code_execution_utils = require("../code_executors/code_execution_utils.js");
-var import_code_executor_context = require("../code_executors/code_executor_context.js");
 var import_event = require("../events/event.js");
-var import_event_actions = require("../events/event_actions.js");
 var import_base_llm = require("../models/base_llm.js");
-var import_llm_request = require("../models/llm_request.js");
 var import_registry = require("../models/registry.js");
-var import_state = require("../sessions/state.js");
 var import_base_tool = require("../tools/base_tool.js");
-var import_function_tool = require("../tools/function_tool.js");
-var import_tool_confirmation = require("../tools/tool_confirmation.js");
-var import_tool_context = require("../tools/tool_context.js");
-var import_env_aware_utils = require("../utils/env_aware_utils.js");
 var import_logger = require("../utils/logger.js");
+var import_context = require("./context.js");
 var import_tracing = require("../telemetry/tracing.js");
+var import_simple_zod_to_json = require("../utils/simple_zod_to_json.js");
 var import_base_agent = require("./base_agent.js");
-var import_base_llm_processor = require("./base_llm_processor.js");
-var import_callback_context = require("./callback_context.js");
-var import_content_processor_utils = require("./content_processor_utils.js");
 var import_functions = require("./functions.js");
-var import_instructions = require("./instructions.js");
+var import_agent_transfer_llm_request_processor = require("./processors/agent_transfer_llm_request_processor.js");
+var import_basic_llm_request_processor = require("./processors/basic_llm_request_processor.js");
+var import_code_execution_request_processor = require("./processors/code_execution_request_processor.js");
+var import_content_request_processor = require("./processors/content_request_processor.js");
+var import_identity_llm_request_processor = require("./processors/identity_llm_request_processor.js");
+var import_instructions_llm_request_processor = require("./processors/instructions_llm_request_processor.js");
+var import_request_confirmation_llm_request_processor = require("./processors/request_confirmation_llm_request_processor.js");
 var import_readonly_context = require("./readonly_context.js");
 var import_run_config = require("./run_config.js");
 /**
@@ -66,651 +56,11 @@ var import_run_config = require("./run_config.js");
 var _a, _b;
 const ADK_AGENT_NAME_LABEL_KEY = "adk_agent_name";
 async function convertToolUnionToTools(toolUnion, context2) {
-  if (toolUnion instanceof import_base_tool.BaseTool) {
+  if ((0, import_base_tool.isBaseTool)(toolUnion)) {
     return [toolUnion];
   }
   return await toolUnion.getTools(context2);
 }
-class BasicLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
-  // eslint-disable-next-line require-yield
-  async *runAsync(invocationContext, llmRequest) {
-    var _a2;
-    const agent = invocationContext.agent;
-    if (!isLlmAgent(agent)) {
-      return;
-    }
-    llmRequest.model = agent.canonicalModel.model;
-    llmRequest.config = { ...(_a2 = agent.generateContentConfig) != null ? _a2 : {} };
-    if (agent.outputSchema) {
-      (0, import_llm_request.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 import_base_llm_processor.BaseLlmRequestProcessor {
-  // eslint-disable-next-line require-yield
-  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}"`);
-    }
-    (0, import_llm_request.appendInstructions)(llmRequest, si);
-  }
-}
-const IDENTITY_LLM_REQUEST_PROCESSOR = new IdentityLlmRequestProcessor();
-class InstructionsLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
-  /**
-   * Handles instructions and global instructions for LLM flow.
-   */
-  // eslint-disable-next-line require-yield
-  async *runAsync(invocationContext, llmRequest) {
-    const agent = invocationContext.agent;
-    if (!(agent instanceof LlmAgent) || !(agent.rootAgent instanceof LlmAgent)) {
-      return;
-    }
-    const rootAgent = agent.rootAgent;
-    if (isLlmAgent(rootAgent) && rootAgent.globalInstruction) {
-      const { instruction, requireStateInjection } = await rootAgent.canonicalGlobalInstruction(
-        new import_readonly_context.ReadonlyContext(invocationContext)
-      );
-      let instructionWithState = instruction;
-      if (requireStateInjection) {
-        instructionWithState = await (0, import_instructions.injectSessionState)(
-          instruction,
-          new import_readonly_context.ReadonlyContext(invocationContext)
-        );
-      }
-      (0, import_llm_request.appendInstructions)(llmRequest, [instructionWithState]);
-    }
-    if (agent.instruction) {
-      const { instruction, requireStateInjection } = await agent.canonicalInstruction(
-        new import_readonly_context.ReadonlyContext(invocationContext)
-      );
-      let instructionWithState = instruction;
-      if (requireStateInjection) {
-        instructionWithState = await (0, import_instructions.injectSessionState)(
-          instruction,
-          new import_readonly_context.ReadonlyContext(invocationContext)
-        );
-      }
-      (0, import_llm_request.appendInstructions)(llmRequest, [instructionWithState]);
-    }
-  }
-}
-const INSTRUCTIONS_LLM_REQUEST_PROCESSOR = new InstructionsLlmRequestProcessor();
-class ContentRequestProcessor {
-  // eslint-disable-next-line require-yield
-  async *runAsync(invocationContext, llmRequest) {
-    const agent = invocationContext.agent;
-    if (!agent || !isLlmAgent(agent)) {
-      return;
-    }
-    if (agent.includeContents === "default") {
-      llmRequest.contents = (0, import_content_processor_utils.getContents)(
-        invocationContext.session.events,
-        agent.name,
-        invocationContext.branch
-      );
-    } else {
-      llmRequest.contents = (0, import_content_processor_utils.getCurrentTurnContents)(
-        invocationContext.session.events,
-        agent.name,
-        invocationContext.branch
-      );
-    }
-    return;
-  }
-}
-const CONTENT_REQUEST_PROCESSOR = new ContentRequestProcessor();
-class AgentTransferLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
-  constructor() {
-    super(...arguments);
-    this.toolName = "transfer_to_agent";
-    this.tool = new import_function_tool.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: import_zod.z.object({
-        agentName: import_zod.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;
-        return "Transfer queued";
-      }
-    });
-  }
-  // eslint-disable-next-line require-yield
-  async *runAsync(invocationContext, llmRequest) {
-    if (!(invocationContext.agent instanceof LlmAgent)) {
-      return;
-    }
-    const transferTargets = this.getTransferTargets(invocationContext.agent);
-    if (!transferTargets.length) {
-      return;
-    }
-    (0, import_llm_request.appendInstructions)(llmRequest, [
-      this.buildTargetAgentsInstructions(
-        invocationContext.agent,
-        transferTargets
-      )
-    ]);
-    const toolContext = new import_tool_context.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 || !isLlmAgent(agent.parentAgent)) {
-      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 import_base_llm_processor.BaseLlmRequestProcessor {
-  /** Handles tool confirmation information to build the LLM request. */
-  async *runAsync(invocationContext) {
-    const agent = invocationContext.agent;
-    if (!isLlmAgent(agent)) {
-      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 = (0, import_event.getFunctionResponses)(event);
-      if (!responses) {
-        continue;
-      }
-      let foundConfirmation = false;
-      for (const functionResponse of responses) {
-        if (functionResponse.name !== import_functions.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 import_tool_confirmation.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 = (0, import_event.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 = (0, import_event.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 import_readonly_context.ReadonlyContext(invocationContext)
-      );
-      const toolsDict = Object.fromEntries(
-        toolsList.map((tool) => [tool.name, tool])
-      );
-      const functionResponseEvent = await (0, import_functions.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 CodeExecutionRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
-  async *runAsync(invocationContext, llmRequest) {
-    if (!(invocationContext.agent instanceof LlmAgent)) {
-      return;
-    }
-    if (!invocationContext.agent.codeExecutor) {
-      return;
-    }
-    for await (const event of runPreProcessor(invocationContext, llmRequest)) {
-      yield event;
-    }
-    if (!(0, import_base_code_executor.isBaseCodeExecutor)(invocationContext.agent.codeExecutor)) {
-      return;
-    }
-    for (const content of llmRequest.contents) {
-      const delimeters = invocationContext.agent.codeExecutor.codeBlockDelimiters.length ? invocationContext.agent.codeExecutor.codeBlockDelimiters[0] : ["", ""];
-      (0, import_code_execution_utils.convertCodeExecutionParts)(
-        content,
-        delimeters,
-        invocationContext.agent.codeExecutor.executionResultDelimiters
-      );
-    }
-  }
-}
-const DATA_FILE_UTIL_MAP = {
-  "text/csv": {
-    extension: ".csv",
-    loaderCodeTemplate: "pd.read_csv('{filename}')"
-  }
-};
-const DATA_FILE_HELPER_LIB = `
-import pandas as pd
-
-def explore_df(df: pd.DataFrame) -> None:
-  """Prints some information about a pandas DataFrame."""
-
-  with pd.option_context(
-      'display.max_columns', None, 'display.expand_frame_repr', False
-  ):
-    # Print the column names to never encounter KeyError when selecting one.
-    df_dtypes = df.dtypes
-
-    # Obtain information about data types and missing values.
-    df_nulls = (len(df) - df.isnull().sum()).apply(
-        lambda x: f'{x} / {df.shape[0]} non-null'
-    )
-
-    # Explore unique total values in columns using \`.unique()\`.
-    df_unique_count = df.apply(lambda x: len(x.unique()))
-
-    # Explore unique values in columns using \`.unique()\`.
-    df_unique = df.apply(lambda x: crop(str(list(x.unique()))))
-
-    df_info = pd.concat(
-        (
-            df_dtypes.rename('Dtype'),
-            df_nulls.rename('Non-Null Count'),
-            df_unique_count.rename('Unique Values Count'),
-            df_unique.rename('Unique Values'),
-        ),
-        axis=1,
-    )
-    df_info.index.name = 'Columns'
-    print(f"""Total rows: {df.shape[0]}
-Total columns: {df.shape[1]}
-
-{df_info}""")
-`;
-class CodeExecutionResponseProcessor {
-  /**
-   * Processes the LLM response asynchronously.
-   *
-   * @param invocationContext The invocation context
-   * @param llmResponse The LLM response to process
-   * @returns An async generator yielding events
-   */
-  async *runAsync(invocationContext, llmResponse) {
-    if (llmResponse.partial) {
-      return;
-    }
-    for await (const event of runPostProcessor(
-      invocationContext,
-      llmResponse
-    )) {
-      yield event;
-    }
-  }
-}
-const responseProcessor = new CodeExecutionResponseProcessor();
-async function* runPreProcessor(invocationContext, llmRequest) {
-  const agent = invocationContext.agent;
-  if (!isLlmAgent(agent)) {
-    return;
-  }
-  const codeExecutor = agent.codeExecutor;
-  if (!codeExecutor || !(0, import_base_code_executor.isBaseCodeExecutor)(codeExecutor)) {
-    return;
-  }
-  if ((0, import_built_in_code_executor.isBuiltInCodeExecutor)(codeExecutor)) {
-    codeExecutor.processLlmRequest(llmRequest);
-    return;
-  }
-  if (!codeExecutor.optimizeDataFile) {
-    return;
-  }
-  const codeExecutorContext = new import_code_executor_context.CodeExecutorContext(
-    new import_state.State(invocationContext.session.state)
-  );
-  if (codeExecutorContext.getErrorCount(invocationContext.invocationId) >= codeExecutor.errorRetryAttempts) {
-    return;
-  }
-  const allInputFiles = extractAndReplaceInlineFiles(
-    codeExecutorContext,
-    llmRequest
-  );
-  const processedFileNames = new Set(
-    codeExecutorContext.getProcessedFileNames()
-  );
-  const filesToProcess = allInputFiles.filter(
-    (f) => !processedFileNames.has(f.name)
-  );
-  for (const file of filesToProcess) {
-    const codeStr = getDataFilePreprocessingCode(file);
-    if (!codeStr) {
-      return;
-    }
-    const codeContent = {
-      role: "model",
-      parts: [
-        { text: `Processing input file: \`${file.name}\`` },
-        (0, import_code_execution_utils.buildExecutableCodePart)(codeStr)
-      ]
-    };
-    llmRequest.contents.push((0, import_lodash_es.cloneDeep)(codeContent));
-    yield (0, import_event.createEvent)({
-      invocationId: invocationContext.invocationId,
-      author: agent.name,
-      branch: invocationContext.branch,
-      content: codeContent
-    });
-    const executionId = getOrSetExecutionId(
-      invocationContext,
-      codeExecutorContext
-    );
-    const codeExecutionResult = await codeExecutor.executeCode({
-      invocationContext,
-      codeExecutionInput: {
-        code: codeStr,
-        inputFiles: [file],
-        executionId
-      }
-    });
-    codeExecutorContext.updateCodeExecutionResult({
-      invocationId: invocationContext.invocationId,
-      code: codeStr,
-      resultStdout: codeExecutionResult.stdout,
-      resultStderr: codeExecutionResult.stderr
-    });
-    codeExecutorContext.addProcessedFileNames([file.name]);
-    const executionResultEvent = await postProcessCodeExecutionResult(
-      invocationContext,
-      codeExecutorContext,
-      codeExecutionResult
-    );
-    yield executionResultEvent;
-    llmRequest.contents.push((0, import_lodash_es.cloneDeep)(executionResultEvent.content));
-  }
-}
-async function* runPostProcessor(invocationContext, llmResponse) {
-  const agent = invocationContext.agent;
-  if (!isLlmAgent(agent)) {
-    return;
-  }
-  const codeExecutor = agent.codeExecutor;
-  if (!codeExecutor || !(0, import_base_code_executor.isBaseCodeExecutor)(codeExecutor)) {
-    return;
-  }
-  if (!llmResponse || !llmResponse.content) {
-    return;
-  }
-  if ((0, import_built_in_code_executor.isBuiltInCodeExecutor)(codeExecutor)) {
-    return;
-  }
-  const codeExecutorContext = new import_code_executor_context.CodeExecutorContext(
-    new import_state.State(invocationContext.session.state)
-  );
-  if (codeExecutorContext.getErrorCount(invocationContext.invocationId) >= codeExecutor.errorRetryAttempts) {
-    return;
-  }
-  const responseContent = llmResponse.content;
-  const codeStr = (0, import_code_execution_utils.extractCodeAndTruncateContent)(
-    responseContent,
-    codeExecutor.codeBlockDelimiters
-  );
-  if (!codeStr) {
-    return;
-  }
-  yield (0, import_event.createEvent)({
-    invocationId: invocationContext.invocationId,
-    author: agent.name,
-    branch: invocationContext.branch,
-    content: responseContent
-  });
-  const executionId = getOrSetExecutionId(
-    invocationContext,
-    codeExecutorContext
-  );
-  const codeExecutionResult = await codeExecutor.executeCode({
-    invocationContext,
-    codeExecutionInput: {
-      code: codeStr,
-      inputFiles: codeExecutorContext.getInputFiles(),
-      executionId
-    }
-  });
-  codeExecutorContext.updateCodeExecutionResult({
-    invocationId: invocationContext.invocationId,
-    code: codeStr,
-    resultStdout: codeExecutionResult.stdout,
-    resultStderr: codeExecutionResult.stderr
-  });
-  yield await postProcessCodeExecutionResult(
-    invocationContext,
-    codeExecutorContext,
-    codeExecutionResult
-  );
-  llmResponse.content = void 0;
-}
-function extractAndReplaceInlineFiles(codeExecutorContext, llmRequest) {
-  var _a2;
-  const allInputFiles = codeExecutorContext.getInputFiles();
-  const savedFileNames = new Set(allInputFiles.map((f) => f.name));
-  for (let i = 0; i < llmRequest.contents.length; i++) {
-    const content = llmRequest.contents[i];
-    if (content.role !== "user" || !content.parts) {
-      continue;
-    }
-    for (let j = 0; j < content.parts.length; j++) {
-      const part = content.parts[j];
-      const mimeType = (_a2 = part.inlineData) == null ? void 0 : _a2.mimeType;
-      if (!mimeType || !part.inlineData || !DATA_FILE_UTIL_MAP[mimeType]) {
-        continue;
-      }
-      const fileName = `data_${i + 1}_${j + 1}${DATA_FILE_UTIL_MAP[mimeType].extension}`;
-      part.text = `
-Available file: \`${fileName}\`
-`;
-      const file = {
-        name: fileName,
-        content: (0, import_env_aware_utils.base64Decode)(part.inlineData.data),
-        mimeType
-      };
-      if (!savedFileNames.has(fileName)) {
-        codeExecutorContext.addInputFiles([file]);
-        allInputFiles.push(file);
-      }
-    }
-  }
-  return allInputFiles;
-}
-function getOrSetExecutionId(invocationContext, codeExecutorContext) {
-  var _a2;
-  const agent = invocationContext.agent;
-  if (!isLlmAgent(agent) || !((_a2 = agent.codeExecutor) == null ? void 0 : _a2.stateful)) {
-    return void 0;
-  }
-  let executionId = codeExecutorContext.getExecutionId();
-  if (!executionId) {
-    executionId = invocationContext.session.id;
-    codeExecutorContext.setExecutionId(executionId);
-  }
-  return executionId;
-}
-async function postProcessCodeExecutionResult(invocationContext, codeExecutorContext, codeExecutionResult) {
-  if (!invocationContext.artifactService) {
-    throw new Error("Artifact service is not initialized.");
-  }
-  const resultContent = {
-    role: "model",
-    parts: [(0, import_code_execution_utils.buildCodeExecutionResultPart)(codeExecutionResult)]
-  };
-  const eventActions = (0, import_event_actions.createEventActions)({
-    stateDelta: codeExecutorContext.getStateDelta()
-  });
-  if (codeExecutionResult.stderr) {
-    codeExecutorContext.incrementErrorCount(invocationContext.invocationId);
-  } else {
-    codeExecutorContext.resetErrorCount(invocationContext.invocationId);
-  }
-  for (const outputFile of codeExecutionResult.outputFiles) {
-    const version = await invocationContext.artifactService.saveArtifact({
-      appName: invocationContext.appName || "",
-      userId: invocationContext.userId || "",
-      sessionId: invocationContext.session.id,
-      filename: outputFile.name,
-      artifact: {
-        inlineData: { data: outputFile.content, mimeType: outputFile.mimeType }
-      }
-    });
-    eventActions.artifactDelta[outputFile.name] = version;
-  }
-  return (0, import_event.createEvent)({
-    invocationId: invocationContext.invocationId,
-    author: invocationContext.agent.name,
-    branch: invocationContext.branch,
-    content: resultContent,
-    actions: eventActions
-  });
-}
-function getDataFilePreprocessingCode(file) {
-  function getNormalizedFileName(fileName) {
-    const [varName2] = fileName.split(".");
-    let normalizedName = varName2.replace(/[^a-zA-Z0-9_]/g, "_");
-    if (/^\d/.test(normalizedName)) {
-      normalizedName = "_" + normalizedName;
-    }
-    return normalizedName;
-  }
-  if (!DATA_FILE_UTIL_MAP[file.mimeType]) {
-    return void 0;
-  }
-  const varName = getNormalizedFileName(file.name);
-  const loaderCode = DATA_FILE_UTIL_MAP[file.mimeType].loaderCodeTemplate.replace("{filename}", file.name);
-  return `
-${DATA_FILE_HELPER_LIB}
-
-# Load the dataframe.
-${varName} = ${loaderCode}
-
-# Use \`explore_df\` to guide my analysis.
-explore_df(${varName})
-`;
-}
-const CODE_EXECUTION_REQUEST_PROCESSOR = new CodeExecutionRequestProcessor();
 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;
@@ -729,8 +79,8 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     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.inputSchema = (0, import_simple_zod_to_json.isZodObject)(config.inputSchema) ? (0, import_simple_zod_to_json.zodObjectToSchema)(config.inputSchema) : config.inputSchema;
+    this.outputSchema = (0, import_simple_zod_to_json.isZodObject)(config.outputSchema) ? (0, import_simple_zod_to_json.zodObjectToSchema)(config.outputSchema) : config.outputSchema;
     this.outputKey = config.outputKey;
     this.beforeModelCallback = config.beforeModelCallback;
     this.afterModelCallback = config.afterModelCallback;
@@ -738,17 +88,17 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     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
+      import_basic_llm_request_processor.BASIC_LLM_REQUEST_PROCESSOR,
+      import_identity_llm_request_processor.IDENTITY_LLM_REQUEST_PROCESSOR,
+      import_instructions_llm_request_processor.INSTRUCTIONS_LLM_REQUEST_PROCESSOR,
+      import_request_confirmation_llm_request_processor.REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
+      import_content_request_processor.CONTENT_REQUEST_PROCESSOR,
+      import_code_execution_request_processor.CODE_EXECUTION_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);
+      this.requestProcessors.push(import_agent_transfer_llm_request_processor.AGENT_TRANSFER_LLM_REQUEST_PROCESSOR);
     }
     if (config.generateContentConfig) {
       if (config.generateContentConfig.tools) {
@@ -775,16 +125,6 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
         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`
-        );
-      }
     }
   }
   /**
@@ -1005,7 +345,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
       }
     }
     for (const toolUnion of this.tools) {
-      const toolContext = new import_tool_context.ToolContext({ invocationContext });
+      const toolContext = new import_context.Context({ invocationContext });
       const tools = await convertToolUnionToTools(
         toolUnion,
         new import_readonly_context.ReadonlyContext(invocationContext)
@@ -1028,28 +368,36 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
       ctx,
       this,
       async function* () {
-        for await (const llmResponse of this.callLlmAsync(
-          invocationContext,
-          llmRequest,
-          modelResponseEvent
-        )) {
-          for await (const event of this.postprocess(
+        const responsesGenerator = async function* () {
+          for await (const llmResponse of this.callLlmAsync(
             invocationContext,
             llmRequest,
-            llmResponse,
             modelResponseEvent
           )) {
-            modelResponseEvent.id = (0, import_event.createNewEventId)();
-            modelResponseEvent.timestamp = (/* @__PURE__ */ new Date()).getTime();
-            yield event;
+            for await (const event of this.postprocess(
+              invocationContext,
+              llmRequest,
+              llmResponse,
+              modelResponseEvent
+            )) {
+              modelResponseEvent.id = (0, import_event.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;
+    var _a2, _b2;
     for (const processor of this.responseProcessors) {
       for await (const event of processor.runAsync(
         invocationContext,
@@ -1078,6 +426,10 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     if (!((_a2 = (0, import_event.getFunctionCalls)(mergedEvent)) == null ? void 0 : _a2.length)) {
       return;
     }
+    if ((_b2 = invocationContext.runConfig) == null ? void 0 : _b2.pauseOnToolCalls) {
+      invocationContext.endInvocation = true;
+      return;
+    }
     const functionResponseEvent = await (0, import_functions.handleFunctionCallsAsync)({
       invocationContext,
       functionCallEvent: mergedEvent,
@@ -1102,6 +454,8 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     });
     if (toolConfirmationEvent) {
       yield toolConfirmationEvent;
+      invocationContext.endInvocation = true;
+      return;
     }
     yield functionResponseEvent;
     const nextAgentName = functionResponseEvent.actions.transferToAgent;
@@ -1158,12 +512,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
         /* stream= */
         ((_e = invocationContext.runConfig) == null ? void 0 : _e.streamingMode) === import_run_config.StreamingMode.SSE
       );
-      for await (const llmResponse of this.runAndHandleError(
-        responsesGenerator,
-        invocationContext,
-        llmRequest,
-        modelResponseEvent
-      )) {
+      for await (const llmResponse of responsesGenerator) {
         (0, import_tracing.traceCallLlm)({
           invocationContext,
           eventId: modelResponseEvent.id,
@@ -1180,7 +529,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     }
   }
   async handleBeforeModelCallback(invocationContext, llmRequest, modelResponseEvent) {
-    const callbackContext = new import_callback_context.CallbackContext({
+    const callbackContext = new import_context.Context({
       invocationContext,
       eventActions: modelResponseEvent.actions
     });
@@ -1203,7 +552,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     return void 0;
   }
   async handleAfterModelCallback(invocationContext, llmResponse, modelResponseEvent) {
-    const callbackContext = new import_callback_context.CallbackContext({
+    const callbackContext = new import_context.Context({
       invocationContext,
       eventActions: modelResponseEvent.actions
     });
@@ -1231,7 +580,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
         yield response;
       }
     } catch (modelError) {
-      const callbackContext = new import_callback_context.CallbackContext({
+      const callbackContext = new import_context.Context({
         invocationContext,
         eventActions: modelResponseEvent.actions
       });
@@ -1244,11 +593,29 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
         if (onModelErrorCallbackResponse) {
           yield onModelErrorCallbackResponse;
         } else {
-          const errorResponse = JSON.parse(modelError.message);
-          yield {
-            errorCode: String(errorResponse.error.code),
-            errorMessage: errorResponse.error.message
-          };
+          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 (0, import_event.createEvent)({
+              invocationId: invocationContext.invocationId,
+              author: this.name,
+              errorCode,
+              errorMessage
+            });
+          } else {
+            yield {
+              errorCode,
+              errorMessage
+            };
+          }
         }
       } else {
         import_logger.logger.error("Unknown error during response generation", modelError);
@@ -1266,7 +633,5 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LlmAgent,
-  REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
-  isLlmAgent,
-  responseProcessor
+  isLlmAgent
 });