feat: make EventsCompactionConfig sliding-window fields optional

EventsCompactionConfig required compaction_interval and overlap_size, so a
token-threshold-only compaction config could not be constructed even though the
runtime already tolerates a missing sliding-window trigger. Make both
sliding-window fields Optional and validate them as a both-or-neither pair,
mirroring the token-threshold pair, and require at least one trigger overall.

This also tightens validation with positivity bounds enforced whenever a value
is provided (compaction_interval > 0, overlap_size >= 0). Minor behavior
change: compaction_interval <= 0 and negative overlap_size, previously
accepted, now raise ValidationError.

Close #6398

Co-authored-by: George Weale <gweale@google.com>
PiperOrigin-RevId: 950899288

Author: GWeale

src/google/adk/apps/_configs.py

@@ -58,11 +58,11 @@ class EventsCompactionConfig(BaseModel):
   summarizer: Optional[BaseEventsSummarizer] = None
   """The event summarizer to use for compaction."""
 
-  compaction_interval: int
+  compaction_interval: Optional[int] = Field(default=None, gt=0)
   """The number of *new* user-initiated invocations that, once
   fully represented in the session's events, will trigger a compaction."""
 
-  overlap_size: int
+  overlap_size: Optional[int] = Field(default=None, ge=0)
   """The number of preceding invocations to include from the
   end of the last compacted range. This creates an overlap between consecutive
   compacted summaries, maintaining context."""
@@ -85,11 +85,22 @@ class EventsCompactionConfig(BaseModel):
   """
 
   @model_validator(mode="after")
-  def _validate_token_params(self) -> EventsCompactionConfig:
+  def _validate_trigger_params(self) -> EventsCompactionConfig:
     token_threshold_set = self.token_threshold is not None
     retention_size_set = self.event_retention_size is not None
     if token_threshold_set != retention_size_set:
       raise ValueError(
           "token_threshold and event_retention_size must be set together."
       )
+    compaction_interval_set = self.compaction_interval is not None
+    overlap_size_set = self.overlap_size is not None
+    if compaction_interval_set != overlap_size_set:
+      raise ValueError(
+          "compaction_interval and overlap_size must be set together."
+      )
+    if not (token_threshold_set or compaction_interval_set):
+      raise ValueError(
+          "At least one compaction trigger must be configured: the"
+          " token-threshold pair or the sliding-window pair."
+      )
     return self

tests/unittests/apps/test_compaction.py

@@ -473,20 +473,38 @@ def test_events_compaction_config_rejects_partial_token_fields(
   def test_events_compaction_config_rejects_partial_sliding_fields(
       self,
   ):
-    with pytest.raises(ValidationError):
+    with pytest.raises(ValidationError, match='must be set together'):
       EventsCompactionConfig(
           compaction_interval=2,
       )
 
-    with pytest.raises(ValidationError):
+    with pytest.raises(ValidationError, match='must be set together'):
       EventsCompactionConfig(
           overlap_size=0,
       )
 
   def test_events_compaction_config_rejects_missing_modes(self):
-    with pytest.raises(ValidationError):
+    with pytest.raises(
+        ValidationError, match='At least one compaction trigger'
+    ):
       EventsCompactionConfig()
 
+  def test_events_compaction_config_accepts_token_only_without_sliding_window(
+      self,
+  ):
+    config = EventsCompactionConfig(
+        token_threshold=160_000,
+        event_retention_size=50,
+    )
+    self.assertIsNone(config.compaction_interval)
+    self.assertIsNone(config.overlap_size)
+    self.assertEqual(config.token_threshold, 160_000)
+    self.assertEqual(config.event_retention_size, 50)
+
+  def test_events_compaction_config_rejects_zero_compaction_interval(self):
+    with pytest.raises(ValidationError):
+      EventsCompactionConfig(compaction_interval=0, overlap_size=1)
+
   def test_latest_prompt_token_count_fallback_applies_compaction(self):
     events = [
         self._create_event(1.0, 'inv1', 'a' * 40),