feat: wire sliding-window context compaction into the runner

PiperOrigin-RevId: 932346604

Author: wikaaaaa

core/src/commonMain/kotlin/com/google/adk/kt/apps/App.kt

@@ -17,6 +17,7 @@
 package com.google.adk.kt.apps
 
 import com.google.adk.kt.agents.BaseAgent
+import com.google.adk.kt.summarizer.EventsCompactionConfig
 
 /**
  * Represents an LLM-backed agentic application.
@@ -31,8 +32,14 @@ import com.google.adk.kt.agents.BaseAgent
  *
  * @property appName The application name.
  * @property rootAgent The root agent of the application's agent tree.
+ * @property eventsCompactionConfig Optional configuration controlling context-compaction strategies
+ *   for sessions of this application. When `null`, no compaction runs.
  */
-data class App(val appName: String, val rootAgent: BaseAgent) {
+data class App(
+  val appName: String,
+  val rootAgent: BaseAgent,
+  val eventsCompactionConfig: EventsCompactionConfig? = null,
+) {
   init {
     require(IDENTIFIER_REGEX.matches(appName)) {
       "Invalid app name '$appName': must be a valid identifier consisting of letters, digits, " +

core/src/commonMain/kotlin/com/google/adk/kt/runners/AbstractRunner.kt

@@ -20,6 +20,7 @@ package com.google.adk.kt.runners
 
 import com.google.adk.kt.agents.BaseAgent
 import com.google.adk.kt.agents.InvocationContext
+import com.google.adk.kt.agents.LlmAgent
 import com.google.adk.kt.agents.ResumabilityConfig
 import com.google.adk.kt.agents.RunConfig
 import com.google.adk.kt.agents.findAgent
@@ -41,6 +42,9 @@ import com.google.adk.kt.sessions.Session
 import com.google.adk.kt.sessions.SessionKey
 import com.google.adk.kt.sessions.SessionService
 import com.google.adk.kt.sessions.State
+import com.google.adk.kt.summarizer.EventsCompactionConfig
+import com.google.adk.kt.summarizer.LlmEventSummarizer
+import com.google.adk.kt.summarizer.SlidingWindowEventCompactor
 import com.google.adk.kt.telemetry.trace
 import com.google.adk.kt.types.Blob
 import com.google.adk.kt.types.Content
@@ -53,39 +57,64 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.toList
 import kotlinx.coroutines.runBlocking
 
-/**
- * An abstract base class for [Runner] implementations that provides common orchestration logic.
- *
- * Subclasses may be constructed either from explicit fields or from an [App] (via the [App]-based
- * constructor), which supplies the [App.appName] and [App.rootAgent].
- */
-abstract class AbstractRunner(
-  override val appName: String,
-  override val agent: BaseAgent,
-  override val sessionService: SessionService,
-  override val artifactService: ArtifactService?,
-  override val memoryService: MemoryService?,
-  override val pluginManager: PluginManager,
-  override val resumabilityConfig: ResumabilityConfig = ResumabilityConfig(),
-) : Runner {
-
-  /** Creates a runner from an [App], taking its [App.appName] and [App.rootAgent]. */
+/** An abstract base class for [Runner] implementations that provides common orchestration logic. */
+abstract class AbstractRunner : Runner {
+
+  val app: App?
+  final override val appName: String
+  final override val agent: BaseAgent
+  final override val sessionService: SessionService
+  final override val artifactService: ArtifactService?
+  final override val memoryService: MemoryService?
+  final override val pluginManager: PluginManager
+  final override val resumabilityConfig: ResumabilityConfig
+
+  /** Creates a runner from explicit fields, not using an [App]. */
+  constructor(
+    appName: String,
+    agent: BaseAgent,
+    sessionService: SessionService,
+    artifactService: ArtifactService?,
+    memoryService: MemoryService?,
+    pluginManager: PluginManager,
+    resumabilityConfig: ResumabilityConfig = ResumabilityConfig(),
+  ) {
+    this.appName = appName
+    this.agent = agent
+    this.sessionService = sessionService
+    this.artifactService = artifactService
+    this.memoryService = memoryService
+    this.pluginManager = pluginManager
+    this.resumabilityConfig = resumabilityConfig
+    this.app = null
+  }
+
+  /**
+   * Creates a runner from an [App]. The compaction config is resolved at construction (failing fast
+   * if a default summarizer is required but the root agent is not an [LlmAgent]) and stored back on
+   * the [app], so [App.eventsCompactionConfig] returns the effective config.
+   */
   constructor(
     app: App,
     sessionService: SessionService,
     artifactService: ArtifactService?,
     memoryService: MemoryService?,
     pluginManager: PluginManager,
     resumabilityConfig: ResumabilityConfig = ResumabilityConfig(),
-  ) : this(
-    app.appName,
-    app.rootAgent,
-    sessionService,
-    artifactService,
-    memoryService,
-    pluginManager,
-    resumabilityConfig,
-  )
+  ) {
+    this.appName = app.appName
+    this.agent = app.rootAgent
+    this.sessionService = sessionService
+    this.artifactService = artifactService
+    this.memoryService = memoryService
+    this.pluginManager = pluginManager
+    this.resumabilityConfig = resumabilityConfig
+    this.app =
+      app.copy(
+        eventsCompactionConfig =
+          resolveEventsCompactionConfig(app.rootAgent, app.eventsCompactionConfig)
+      )
+  }
 
   /**
    * Main entry method to run the agent in this runner.
@@ -125,6 +154,10 @@ abstract class AbstractRunner(
 
         // 4. Run agent with plugins
         emitAll(runAgentWithPlugins(context))
+
+        // 5. Post-invocation context compaction. Runs once the agent has finished emitting and all
+        // its events have been appended to `session`.
+        runPostInvocationCompaction(session)
       }
       .trace("invocation")
 
@@ -680,7 +713,38 @@ abstract class AbstractRunner(
     return "e-" + Uuid.random()
   }
 
+  /**
+   * Runs post-invocation sliding-window context compaction over [session] when configured. A no-op
+   * when no compaction config was supplied or sliding-window compaction is not configured. The
+   * compactor appends a single summary [Event] to [session] (via [sessionService]) when the
+   * configured invocation interval is reached.
+   */
+  private suspend fun runPostInvocationCompaction(session: Session) {
+    val config = app?.eventsCompactionConfig ?: return
+    if (!config.hasSlidingWindowConfig()) return
+    SlidingWindowEventCompactor(config).compact(session, sessionService)
+  }
+
   private companion object {
     private val logger = LoggerFactory.getLogger(AbstractRunner::class)
+
+    /**
+     * Returns [config] with a default [LlmEventSummarizer] injected when compaction is configured
+     * but no summarizer was supplied. The default summarizer uses [rootAgent]'s model, so
+     * [rootAgent] must be an [LlmAgent] in that case; otherwise an [IllegalArgumentException] is
+     * thrown. Returns [config] unchanged when it is `null` or already carries a summarizer. Any
+     * configured compaction strategy needs a summarizer, so this does not depend on which strategy
+     * is set.
+     */
+    private fun resolveEventsCompactionConfig(
+      rootAgent: BaseAgent,
+      config: EventsCompactionConfig?,
+    ): EventsCompactionConfig? {
+      if (config == null || config.summarizer != null) return config
+      val model =
+        (rootAgent as? LlmAgent)?.model
+          ?: throw IllegalArgumentException("No BaseLlm model available for event compaction")
+      return config.copy(summarizer = LlmEventSummarizer(model))
+    }
   }
 }

core/src/commonTest/kotlin/com/google/adk/kt/apps/AppTest.kt

@@ -16,10 +16,12 @@
 
 package com.google.adk.kt.apps
 
+import com.google.adk.kt.summarizer.EventsCompactionConfig
 import com.google.adk.kt.testing.DummyAgent
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
+import kotlin.test.assertNull
 import kotlin.test.assertSame
 
 class AppTest {
@@ -34,6 +36,22 @@ class AppTest {
     assertSame(agent, app.rootAgent)
   }
 
+  @Test
+  fun construct_noEventsCompactionConfig_defaultsToNull() {
+    val app = App(appName = "my_app", rootAgent = DummyAgent())
+
+    assertNull(app.eventsCompactionConfig)
+  }
+
+  @Test
+  fun construct_withEventsCompactionConfig_exposesIt() {
+    val config = EventsCompactionConfig(compactionInterval = 2, overlapSize = 1)
+
+    val app = App(appName = "my_app", rootAgent = DummyAgent(), eventsCompactionConfig = config)
+
+    assertSame(config, app.eventsCompactionConfig)
+  }
+
   @Test
   fun construct_emptyName_throwsIllegalArgumentException() {
     assertFailsWith<IllegalArgumentException> { App(appName = "", rootAgent = DummyAgent()) }