@google/adk 0.3.0 → 0.5.0

package/dist/cjs/agents/loop_agent.js

@@ -1,6 +1,6 @@
 /**
   * @license
-  * Copyright 2025 Google LLC
+  * Copyright 2026 Google LLC
   * SPDX-License-Identifier: Apache-2.0
   */
 

package/dist/cjs/agents/parallel_agent.js

@@ -1,6 +1,6 @@
 /**
   * @license
-  * Copyright 2025 Google LLC
+  * Copyright 2026 Google LLC
   * SPDX-License-Identifier: Apache-2.0
   */
 

package/dist/cjs/agents/processors/agent_transfer_llm_request_processor.js

@@ -0,0 +1,132 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_transfer_llm_request_processor_exports = {};
+__export(agent_transfer_llm_request_processor_exports, {
+  AGENT_TRANSFER_LLM_REQUEST_PROCESSOR: () => AGENT_TRANSFER_LLM_REQUEST_PROCESSOR,
+  AgentTransferLlmRequestProcessor: () => AgentTransferLlmRequestProcessor
+});
+module.exports = __toCommonJS(agent_transfer_llm_request_processor_exports);
+var import_zod = require("zod");
+var import_llm_request = require("../../models/llm_request.js");
+var import_function_tool = require("../../tools/function_tool.js");
+var import_context = require("../context.js");
+var import_llm_agent = require("../llm_agent.js");
+var import_base_llm_processor = require("./base_llm_processor.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 (!(0, import_llm_agent.isLlmAgent)(invocationContext.agent)) {
+      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_context.Context({ 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((t) => this.buildTargetAgentsInfo(t)).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 || !(0, import_llm_agent.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();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_TRANSFER_LLM_REQUEST_PROCESSOR,
+  AgentTransferLlmRequestProcessor
+});

package/dist/cjs/agents/{base_llm_processor.js → processors/base_llm_processor.js}

@@ -1,6 +1,6 @@
 /**
   * @license
-  * Copyright 2025 Google LLC
+  * Copyright 2026 Google LLC
   * SPDX-License-Identifier: Apache-2.0
   */
 

package/dist/cjs/agents/processors/basic_llm_request_processor.js

@@ -0,0 +1,68 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var basic_llm_request_processor_exports = {};
+__export(basic_llm_request_processor_exports, {
+  BASIC_LLM_REQUEST_PROCESSOR: () => BASIC_LLM_REQUEST_PROCESSOR,
+  BasicLlmRequestProcessor: () => BasicLlmRequestProcessor
+});
+module.exports = __toCommonJS(basic_llm_request_processor_exports);
+var import_llm_request = require("../../models/llm_request.js");
+var import_llm_agent = require("../llm_agent.js");
+var import_base_llm_processor = require("./base_llm_processor.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BasicLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  // eslint-disable-next-line require-yield
+  async *runAsync(invocationContext, llmRequest) {
+    var _a;
+    const agent = invocationContext.agent;
+    if (!(0, import_llm_agent.isLlmAgent)(agent)) {
+      return;
+    }
+    llmRequest.model = agent.canonicalModel.model;
+    llmRequest.config = { ...(_a = agent.generateContentConfig) != null ? _a : {} };
+    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();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BASIC_LLM_REQUEST_PROCESSOR,
+  BasicLlmRequestProcessor
+});

package/dist/cjs/agents/processors/code_execution_request_processor.js

@@ -0,0 +1,389 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var code_execution_request_processor_exports = {};
+__export(code_execution_request_processor_exports, {
+  CODE_EXECUTION_REQUEST_PROCESSOR: () => CODE_EXECUTION_REQUEST_PROCESSOR,
+  CodeExecutionRequestProcessor: () => CodeExecutionRequestProcessor,
+  CodeExecutionResponseProcessor: () => CodeExecutionResponseProcessor,
+  responseProcessor: () => responseProcessor
+});
+module.exports = __toCommonJS(code_execution_request_processor_exports);
+var import_lodash_es = require("lodash-es");
+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_state = require("../../sessions/state.js");
+var import_env_aware_utils = require("../../utils/env_aware_utils.js");
+var import_llm_agent = require("../llm_agent.js");
+var import_base_llm_processor = require("./base_llm_processor.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class CodeExecutionRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  async *runAsync(invocationContext, llmRequest) {
+    if (!(0, import_llm_agent.isLlmAgent)(invocationContext.agent)) {
+      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 (!(0, import_llm_agent.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 (!(0, import_llm_agent.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 _a;
+  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 = (_a = part.inlineData) == null ? void 0 : _a.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 _a;
+  const agent = invocationContext.agent;
+  if (!(0, import_llm_agent.isLlmAgent)(agent) || !((_a = agent.codeExecutor) == null ? void 0 : _a.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();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CODE_EXECUTION_REQUEST_PROCESSOR,
+  CodeExecutionRequestProcessor,
+  CodeExecutionResponseProcessor,
+  responseProcessor
+});

package/dist/cjs/agents/processors/content_request_processor.js

@@ -0,0 +1,66 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var content_request_processor_exports = {};
+__export(content_request_processor_exports, {
+  CONTENT_REQUEST_PROCESSOR: () => CONTENT_REQUEST_PROCESSOR,
+  ContentRequestProcessor: () => ContentRequestProcessor
+});
+module.exports = __toCommonJS(content_request_processor_exports);
+var import_content_processor_utils = require("../content_processor_utils.js");
+var import_llm_agent = require("../llm_agent.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ContentRequestProcessor {
+  // eslint-disable-next-line require-yield
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    if (!agent || !(0, import_llm_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();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONTENT_REQUEST_PROCESSOR,
+  ContentRequestProcessor
+});