@google/adk 0.5.0 → 0.6.0

package/dist/cjs/a2a/agent_executor.js

@@ -0,0 +1,221 @@
+/**
+  * @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_executor_exports = {};
+__export(agent_executor_exports, {
+  A2AAgentExecutor: () => A2AAgentExecutor
+});
+module.exports = __toCommonJS(agent_executor_exports);
+var import_runner = require("../runner/runner.js");
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
+var import_logger = require("../utils/logger.js");
+var import_a2a_event = require("./a2a_event.js");
+var import_event_processor_utils = require("./event_processor_utils.js");
+var import_executor_context = require("./executor_context.js");
+var import_metadata_converter_utils = require("./metadata_converter_utils.js");
+var import_part_converter_utils = require("./part_converter_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class A2AAgentExecutor {
+  constructor(config) {
+    this.config = config;
+    this.agentPartialArtifactIdsMap = {};
+  }
+  async execute(ctx, eventBus) {
+    var _a, _b;
+    const a2aUserMessage = ctx.userMessage;
+    if (!a2aUserMessage) {
+      throw new Error("message not provided");
+    }
+    const userId = `A2A_USER_${ctx.contextId}`;
+    const sessionId = ctx.contextId;
+    const genAIUserMessage = (0, import_part_converter_utils.toGenAIContent)(a2aUserMessage);
+    const adkRunner = await getAdkRunner(this.config.runner);
+    const session = await getAdkSession(
+      userId,
+      sessionId,
+      adkRunner.sessionService,
+      adkRunner.appName
+    );
+    const executorContext = (0, import_executor_context.createExecutorContext)({
+      session,
+      userContent: genAIUserMessage,
+      requestContext: ctx
+    });
+    try {
+      if (this.config.beforeExecuteCallback) {
+        await this.config.beforeExecuteCallback(ctx);
+      }
+      if (ctx.task) {
+        const inputRequiredEvent = (0, import_event_processor_utils.getTaskInputRequiredEvent)(
+          ctx.task,
+          genAIUserMessage
+        );
+        if (inputRequiredEvent) {
+          await this.publishFinalTaskStatus({
+            executorContext,
+            eventBus,
+            event: inputRequiredEvent
+          });
+          return;
+        }
+      }
+      if (!ctx.task) {
+        eventBus.publish(
+          (0, import_a2a_event.createTask)({
+            taskId: ctx.taskId,
+            contextId: ctx.contextId,
+            message: a2aUserMessage
+          })
+        );
+      }
+      eventBus.publish(
+        (0, import_a2a_event.createTaskWorkingEvent)({
+          taskId: ctx.taskId,
+          contextId: ctx.contextId
+        })
+      );
+      const adkEvents = [];
+      for await (const adkEvent of adkRunner.runAsync({
+        userId,
+        sessionId,
+        newMessage: genAIUserMessage,
+        runConfig: this.config.runConfig
+      })) {
+        adkEvents.push(adkEvent);
+        const a2aEvent = this.convertAdkEventToA2AEvent(
+          adkEvent,
+          executorContext
+        );
+        if (!a2aEvent) {
+          continue;
+        }
+        await ((_b = (_a = this.config).afterEventCallback) == null ? void 0 : _b.call(
+          _a,
+          executorContext,
+          adkEvent,
+          a2aEvent
+        ));
+        eventBus.publish(a2aEvent);
+      }
+      await this.publishFinalTaskStatus({
+        executorContext,
+        eventBus,
+        event: (0, import_event_processor_utils.getFinalTaskStatusUpdate)(adkEvents, executorContext)
+      });
+    } catch (e) {
+      const error = e;
+      await this.publishFinalTaskStatus({
+        executorContext,
+        eventBus,
+        error,
+        event: (0, import_a2a_event.createTaskFailedEvent)({
+          taskId: ctx.taskId,
+          contextId: ctx.contextId,
+          error: new Error(`Agent run failed: ${error.message}`),
+          metadata: (0, import_metadata_converter_utils.getA2ASessionMetadata)(executorContext)
+        })
+      });
+    }
+  }
+  // Task cancellation is not supported in this implementation yet.
+  async cancelTask(_taskId) {
+    throw new Error("Task cancellation is not supported yet.");
+  }
+  convertAdkEventToA2AEvent(adkEvent, executorContext) {
+    var _a;
+    const a2aParts = (0, import_part_converter_utils.toA2AParts)(
+      (_a = adkEvent.content) == null ? void 0 : _a.parts,
+      adkEvent.longRunningToolIds
+    );
+    if (a2aParts.length === 0) {
+      return void 0;
+    }
+    const artifactId = this.agentPartialArtifactIdsMap[adkEvent.author] || (0, import_env_aware_utils.randomUUID)();
+    const a2aEvent = (0, import_a2a_event.createTaskArtifactUpdateEvent)({
+      taskId: executorContext.requestContext.taskId,
+      contextId: executorContext.requestContext.contextId,
+      artifactId,
+      parts: a2aParts,
+      metadata: (0, import_metadata_converter_utils.getA2AEventMetadata)(adkEvent, executorContext),
+      append: adkEvent.partial,
+      lastChunk: !adkEvent.partial
+    });
+    if (adkEvent.partial) {
+      this.agentPartialArtifactIdsMap[adkEvent.author] = artifactId;
+    } else {
+      delete this.agentPartialArtifactIdsMap[adkEvent.author];
+    }
+    return a2aEvent;
+  }
+  /**
+   * Writes the final status event to the queue.
+   */
+  async publishFinalTaskStatus({
+    executorContext,
+    eventBus,
+    event,
+    error
+  }) {
+    var _a, _b;
+    try {
+      await ((_b = (_a = this.config).afterExecuteCallback) == null ? void 0 : _b.call(_a, executorContext, event, error));
+    } catch (e) {
+      import_logger.logger.error("Error in afterExecuteCallback:", e);
+    }
+    eventBus.publish(event);
+  }
+}
+async function getAdkSession(userId, sessionId, sessionService, appName) {
+  const session = await sessionService.getSession({
+    appName,
+    userId,
+    sessionId
+  });
+  if (session) {
+    return session;
+  }
+  return sessionService.createSession({
+    appName,
+    userId,
+    sessionId
+  });
+}
+async function getAdkRunner(runnerOrConfig) {
+  if (typeof runnerOrConfig === "function") {
+    const result = await runnerOrConfig();
+    return getAdkRunner(result);
+  }
+  if ((0, import_runner.isRunner)(runnerOrConfig)) {
+    return runnerOrConfig;
+  }
+  return new import_runner.Runner(runnerOrConfig);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A2AAgentExecutor
+});

package/dist/cjs/a2a/agent_to_a2a.js

@@ -0,0 +1,115 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_to_a2a_exports = {};
+__export(agent_to_a2a_exports, {
+  toA2a: () => toA2a
+});
+module.exports = __toCommonJS(agent_to_a2a_exports);
+var import_sdk = require("@a2a-js/sdk");
+var import_server = require("@a2a-js/sdk/server");
+var import_express = require("@a2a-js/sdk/server/express");
+var import_express2 = __toESM(require("express"), 1);
+var import_run_config = require("../agents/run_config.js");
+var import_in_memory_session_service = require("../sessions/in_memory_session_service.js");
+var import_agent_card = require("./agent_card.js");
+var import_agent_executor = require("./agent_executor.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+async function toA2a(agent, options = {}) {
+  var _a, _b, _c, _d;
+  const host = (_a = options.host) != null ? _a : "localhost";
+  const port = (_b = options.port) != null ? _b : 8e3;
+  const protocol = (_c = options.protocol) != null ? _c : "http";
+  const basePath = options.basePath || "";
+  const rpcUrl = `${protocol}://${host}:${port}${basePath}`;
+  const agentCard = options.agentCard ? await (0, import_agent_card.resolveAgentCard)(options.agentCard) : await (0, import_agent_card.getA2AAgentCard)(agent, [
+    {
+      url: `${rpcUrl}/jsonrpc`,
+      transport: "JSONRPC"
+    },
+    {
+      url: `${rpcUrl}/rest`,
+      transport: "HTTP+JSON"
+    }
+  ]);
+  const agentExecutor = new import_agent_executor.A2AAgentExecutor({
+    runner: options.runner || {
+      agent,
+      appName: agent.name,
+      sessionService: options.sessionService || new import_in_memory_session_service.InMemorySessionService(),
+      memoryService: options.memoryService,
+      artifactService: options.artifactService
+    },
+    runConfig: {
+      streamingMode: import_run_config.StreamingMode.SSE
+    }
+  });
+  const requestHandler = new import_server.DefaultRequestHandler(
+    agentCard,
+    new import_server.InMemoryTaskStore(),
+    agentExecutor
+  );
+  const app = (_d = options.app) != null ? _d : (0, import_express2.default)();
+  if (!options.app) {
+    app.use(import_express2.default.urlencoded({ limit: "50mb", extended: true }));
+    app.use(import_express2.default.json({ limit: "50mb" }));
+  }
+  app.use(
+    `${basePath}/${import_sdk.AGENT_CARD_PATH}`,
+    (0, import_express.agentCardHandler)({ agentCardProvider: requestHandler })
+  );
+  app.use(
+    `${basePath}/rest`,
+    (0, import_express.restHandler)({
+      requestHandler,
+      userBuilder: import_express.UserBuilder.noAuthentication
+    })
+  );
+  app.use(
+    `${basePath}/jsonrpc`,
+    (0, import_express.jsonRpcHandler)({
+      requestHandler,
+      userBuilder: import_express.UserBuilder.noAuthentication
+    })
+  );
+  return app;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toA2a
+});

package/dist/cjs/a2a/event_processor_utils.js

@@ -0,0 +1,180 @@
+/**
+  * @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 event_processor_utils_exports = {};
+__export(event_processor_utils_exports, {
+  getFinalTaskStatusUpdate: () => getFinalTaskStatusUpdate,
+  getTaskInputRequiredEvent: () => getTaskInputRequiredEvent
+});
+module.exports = __toCommonJS(event_processor_utils_exports);
+var import_event_actions = require("../events/event_actions.js");
+var import_a2a_event = require("./a2a_event.js");
+var import_metadata_converter_utils = require("./metadata_converter_utils.js");
+var import_part_converter_utils = require("./part_converter_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function getFinalTaskStatusUpdate(adkEvents, context) {
+  var _a, _b;
+  const finalEventActions = (0, import_event_actions.createEventActions)();
+  for (const adkEvent of adkEvents) {
+    if (adkEvent.errorCode || adkEvent.errorMessage) {
+      return (0, import_a2a_event.createTaskFailedEvent)({
+        taskId: context.requestContext.taskId,
+        contextId: context.requestContext.contextId,
+        error: new Error(adkEvent.errorMessage || adkEvent.errorCode),
+        metadata: {
+          ...(0, import_metadata_converter_utils.getA2AEventMetadata)(adkEvent, context),
+          ...(0, import_metadata_converter_utils.getA2AEventMetadataFromActions)(finalEventActions)
+        }
+      });
+    }
+    finalEventActions.escalate = finalEventActions.escalate || ((_a = adkEvent.actions) == null ? void 0 : _a.escalate);
+    if ((_b = adkEvent.actions) == null ? void 0 : _b.transferToAgent) {
+      finalEventActions.transferToAgent = adkEvent.actions.transferToAgent;
+    }
+  }
+  const inputRequiredEvent = scanForInputRequiredEvents(adkEvents, context);
+  if (inputRequiredEvent) {
+    return {
+      ...inputRequiredEvent,
+      metadata: {
+        ...inputRequiredEvent.metadata,
+        ...(0, import_metadata_converter_utils.getA2AEventMetadataFromActions)(finalEventActions)
+      }
+    };
+  }
+  return (0, import_a2a_event.createTaskCompletedEvent)({
+    taskId: context.requestContext.taskId,
+    contextId: context.requestContext.contextId,
+    metadata: {
+      ...(0, import_metadata_converter_utils.getA2ASessionMetadata)(context),
+      ...(0, import_metadata_converter_utils.getA2AEventMetadataFromActions)(finalEventActions)
+    }
+  });
+}
+function scanForInputRequiredEvents(adkEvents, context) {
+  var _a, _b;
+  const inputRequiredParts = [];
+  const inputRequiredFunctionCallIds = /* @__PURE__ */ new Set();
+  for (const adkEvent of adkEvents) {
+    if (!((_b = (_a = adkEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length)) {
+      continue;
+    }
+    for (const genAIPart of adkEvent.content.parts) {
+      const longRunningFunctionCallId = getLongRunnningFunctionCallId(
+        genAIPart,
+        adkEvent.longRunningToolIds,
+        inputRequiredParts
+      );
+      if (!longRunningFunctionCallId) {
+        continue;
+      }
+      const isAlreadyAdded = inputRequiredFunctionCallIds.has(
+        longRunningFunctionCallId
+      );
+      if (isAlreadyAdded) {
+        continue;
+      }
+      inputRequiredParts.push(genAIPart);
+      inputRequiredFunctionCallIds.add(longRunningFunctionCallId);
+    }
+  }
+  if (inputRequiredParts.length > 0) {
+    return (0, import_a2a_event.createTaskInputRequiredEvent)({
+      taskId: context.requestContext.taskId,
+      contextId: context.requestContext.contextId,
+      parts: (0, import_part_converter_utils.toA2AParts)(inputRequiredParts, [...inputRequiredFunctionCallIds]),
+      metadata: (0, import_metadata_converter_utils.getA2ASessionMetadata)(context)
+    });
+  }
+  return void 0;
+}
+function getLongRunnningFunctionCallId(genAIPart, longRunningToolIds = [], inputRequiredParts = []) {
+  var _a, _b, _c;
+  const functionCallId = (_a = genAIPart.functionCall) == null ? void 0 : _a.id;
+  const functionResponseId = (_b = genAIPart.functionResponse) == null ? void 0 : _b.id;
+  if (!functionCallId && !functionResponseId) {
+    return;
+  }
+  if (functionCallId && longRunningToolIds.includes(functionCallId)) {
+    return functionCallId;
+  }
+  if (functionResponseId && longRunningToolIds.includes(functionResponseId)) {
+    return functionResponseId;
+  }
+  for (const part of inputRequiredParts) {
+    if (((_c = part.functionCall) == null ? void 0 : _c.id) === functionResponseId) {
+      return functionResponseId;
+    }
+  }
+  return;
+}
+function getTaskInputRequiredEvent(task, genAIContent) {
+  var _a;
+  if (!task || !(0, import_a2a_event.isInputRequiredTaskStatusUpdateEvent)(task) || !task.status.message) {
+    return void 0;
+  }
+  const statusMsg = task.status.message;
+  const taskParts = (0, import_part_converter_utils.toGenAIParts)(statusMsg.parts);
+  for (const taskPart of taskParts) {
+    const functionCallId = (_a = taskPart.functionCall) == null ? void 0 : _a.id;
+    if (!functionCallId) {
+      continue;
+    }
+    const hasMatchingResponse = ((genAIContent == null ? void 0 : genAIContent.parts) || []).some(
+      (p) => {
+        var _a2;
+        return ((_a2 = p.functionResponse) == null ? void 0 : _a2.id) === functionCallId;
+      }
+    );
+    if (!hasMatchingResponse) {
+      return (0, import_a2a_event.createInputMissingErrorEvent)({
+        taskId: task.id,
+        contextId: task.contextId,
+        parts: [
+          ...statusMsg.parts.filter((p) => {
+            var _a2;
+            return !((_a2 = p.metadata) == null ? void 0 : _a2.validation_error);
+          }),
+          {
+            kind: "text",
+            text: `No input provided for function call id ${functionCallId}`,
+            metadata: {
+              validation_error: true
+            }
+          }
+        ]
+      });
+    }
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFinalTaskStatusUpdate,
+  getTaskInputRequiredEvent
+});

package/dist/cjs/a2a/executor_context.js

@@ -40,7 +40,7 @@ function createExecutorContext({
   return {
     userId: session.userId,
     sessionId: session.id,
-    agentName: session.appName,
+    appName: session.appName,
     readonlyState: session.state,
     events: session.events,
     userContent,

package/dist/cjs/a2a/metadata_converter_utils.js

@@ -59,6 +59,7 @@ var A2AMetadataKeys = ((A2AMetadataKeys2) => {
   A2AMetadataKeys2["GROUNDING_METADATA"] = `${ADK_METADATA_KEY_PREFIX}grounding_metadata`;
   A2AMetadataKeys2["USAGE_METADATA"] = `${ADK_METADATA_KEY_PREFIX}usage_metadata`;
   A2AMetadataKeys2["CUSTOM_METADATA"] = `${ADK_METADATA_KEY_PREFIX}custom_metadata`;
+  A2AMetadataKeys2["VIDEO_METADATA"] = `${ADK_METADATA_KEY_PREFIX}video_metadata`;
   return A2AMetadataKeys2;
 })(A2AMetadataKeys || {});
 var AdkMetadataKeys = ((AdkMetadataKeys2) => {

package/dist/cjs/a2a/part_converter_utils.js

@@ -73,6 +73,10 @@ function toA2ATextPart(part) {
   return a2aPart;
 }
 function toA2AFilePart(part) {
+  const metadata = {};
+  if (part.videoMetadata) {
+    metadata[import_metadata_converter_utils.A2AMetadataKeys.VIDEO_METADATA] = part.videoMetadata;
+  }
   if (part.fileData) {
     return {
       kind: "file",
@@ -80,7 +84,7 @@ function toA2AFilePart(part) {
         uri: part.fileData.fileUri || "",
         mimeType: part.fileData.mimeType
       },
-      metadata: {}
+      metadata
     };
   }
   if (part.inlineData) {
@@ -90,7 +94,7 @@ function toA2AFilePart(part) {
         bytes: part.inlineData.data || "",
         mimeType: part.inlineData.mimeType
       },
-      metadata: {}
+      metadata
     };
   }
   throw new Error(`Not a file part: ${JSON.stringify(part)}`);
@@ -111,7 +115,11 @@ function toA2ADataPart(part, longRunningToolIDs = []) {
     dataPartType = "code_execution_result" /* CODE_EXEC_RESULT */;
     data = part.codeExecutionResult;
   } else {
-    throw new Error(`Unknown part type: ${JSON.stringify(part)}`);
+    return {
+      kind: "data",
+      data: {},
+      metadata: {}
+    };
   }
   const metadata = {
     [import_metadata_converter_utils.A2AMetadataKeys.DATA_PART_TYPE]: dataPartType
@@ -155,21 +163,24 @@ function toGenAIPartText(a2aPart) {
   };
 }
 function toGenAIPartFile(a2aPart) {
+  var _a;
+  const part = {};
+  if ((_a = a2aPart.metadata) == null ? void 0 : _a[import_metadata_converter_utils.A2AMetadataKeys.VIDEO_METADATA]) {
+    part.videoMetadata = a2aPart.metadata[import_metadata_converter_utils.A2AMetadataKeys.VIDEO_METADATA];
+  }
   if ("bytes" in a2aPart.file) {
-    return {
-      inlineData: {
-        data: a2aPart.file.bytes,
-        mimeType: a2aPart.file.mimeType || ""
-      }
+    part.inlineData = {
+      data: a2aPart.file.bytes,
+      mimeType: a2aPart.file.mimeType || ""
     };
+    return part;
   }
   if ("uri" in a2aPart.file) {
-    return {
-      fileData: {
-        fileUri: a2aPart.file.uri,
-        mimeType: a2aPart.file.mimeType || ""
-      }
+    part.fileData = {
+      fileUri: a2aPart.file.uri,
+      mimeType: a2aPart.file.mimeType || ""
     };
+    return part;
   }
   throw new Error(`Not a file part: ${JSON.stringify(a2aPart)}`);
 }

package/dist/cjs/agents/llm_agent.js

@@ -43,6 +43,7 @@ var import_agent_transfer_llm_request_processor = require("./processors/agent_tr
 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_context_compactor_request_processor = require("./processors/context_compactor_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");
@@ -95,6 +96,22 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
       import_content_request_processor.CONTENT_REQUEST_PROCESSOR,
       import_code_execution_request_processor.CODE_EXECUTION_REQUEST_PROCESSOR
     ];
+    if (!config.requestProcessors && config.contextCompactors && config.contextCompactors.length > 0) {
+      const contentIndex = this.requestProcessors.indexOf(
+        import_content_request_processor.CONTENT_REQUEST_PROCESSOR
+      );
+      if (contentIndex !== -1) {
+        this.requestProcessors.splice(
+          contentIndex,
+          0,
+          new import_context_compactor_request_processor.ContextCompactorRequestProcessor(config.contextCompactors)
+        );
+      } else {
+        this.requestProcessors.push(
+          new import_context_compactor_request_processor.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) {

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

@@ -28,9 +28,11 @@ __export(content_processor_utils_exports, {
   getCurrentTurnContents: () => getCurrentTurnContents
 });
 module.exports = __toCommonJS(content_processor_utils_exports);
+var import_genai = require("@google/genai");
 var import_lodash_es = require("lodash-es");
-var import_event = require("../events/event.js");
-var import_functions = require("./functions.js");
+var import_compacted_event = require("../../events/compacted_event.js");
+var import_event = require("../../events/event.js");
+var import_functions = require("../functions.js");
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -40,6 +42,10 @@ function getContents(events, agentName, currentBranch) {
   var _a, _b, _c;
   const filteredEvents = [];
   for (const event of events) {
+    if ((0, import_compacted_event.isCompactedEvent)(event)) {
+      filteredEvents.push(convertCompactedEvent(event));
+      continue;
+    }
     if (!((_a = event.content) == null ? void 0 : _a.role) || ((_c = (_b = event.content.parts) == null ? void 0 : _b[0]) == null ? void 0 : _c.text) === "") {
       continue;
     }
@@ -312,6 +318,19 @@ function safeStringify(obj) {
     return String(obj);
   }
 }
+function convertCompactedEvent(event) {
+  const content = (0, import_genai.createUserContent)(
+    `[Previous Context Summary]:
+${event.compactedContent}`
+  );
+  return (0, import_event.createEvent)({
+    invocationId: event.invocationId,
+    author: "user",
+    content,
+    branch: event.branch,
+    timestamp: event.timestamp
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getContents,