docs(sessions): correct the rationale for InMemorySessionService event deduplication

The deduplication guard in `InMemorySessionService.append_event` was documented as protecting against an orchestrator broadcasting the same `Event` to several concurrent `Session` references (#5723). ADK has no such broadcast: within one invocation all parallel branches share a single `InvocationContext.session` and serialize their appends, every produced event carries a fresh id, and persistent backends reject stale snapshots with `StaleSessionError` and enforce unique `event.id` keys.

The guard is still worth keeping for a different reason: it makes `append_event` idempotent for an equal re-delivery of an event, which callers that retry the call (e.g. a write buffer behind an RPC) rely on to avoid double-applying state or inflating their buffer. Reword the comment and the test docstrings to describe that contract; no behavior change.

Co-authored-by: Shangjie Chen <deanchen@google.com>
PiperOrigin-RevId: 996637458

Author: DeanChensj

src/google/adk/sessions/in_memory_session_service.py

@@ -341,15 +341,15 @@ async def append_event(self, session: Session, event: Event) -> Event:
     if session_id not in self.sessions.get(app_name, {}).get(user_id, {}):
       raise SessionNotFoundError(f'Session {session_id} not found.')
 
-    # Fetch the canonical storage session early so we can drop a re-delivered
-    # event before modifying any state. The same event can be delivered more
-    # than once when the orchestrator broadcasts a shared-state delta to
-    # several concurrent session references; deduplicating here prevents
-    # double-application of state updates and duplicate entries in event lists.
-    # A re-delivery is an equal event -- the same object, or a copy carrying
-    # the same id and fields -- so dedupe on equality, gated on a matching id
-    # for speed. Distinct events that merely share an id (e.g. tests that
-    # stamp a fixed uuid) are not equal and are kept.
+    # ``append_event`` is idempotent for an equal re-delivery of an event (the
+    # same object, or a copy carrying the same id and fields), so a caller
+    # that retries this call -- e.g. a service that buffers writes behind an
+    # RPC -- neither double-applies the state delta nor duplicates the entry.
+    # ADK itself never re-delivers an event: parallel branches of one
+    # invocation share a single ``InvocationContext.session`` and serialize
+    # their appends, and every produced event carries a fresh id. Dedupe on
+    # equality gated on a matching id; distinct events that merely share an
+    # id (e.g. tests that stamp a fixed uuid) are not equal and are kept.
     storage_session = self.sessions[app_name][user_id][session_id]
     if any(e == event for e in storage_session.events if e.id == event.id):
       return event

tests/unittests/sessions/test_session_service.py

@@ -3889,7 +3889,7 @@ def test_list_sessions_sync_unknown_app_or_user_returns_empty_response():
 
 
 # ---------------------------------------------------------------------------
-# Regression tests for duplicate-event deduplication (issue #5723)
+# append_event idempotency for re-delivered events
 # ---------------------------------------------------------------------------
 
 
@@ -3902,8 +3902,9 @@ def test_list_sessions_sync_unknown_app_or_user_returns_empty_response():
 async def test_append_event_is_idempotent_for_same_event_id(session_service):
   """Re-delivering an event must not duplicate entries or double-apply state.
 
-  A broadcast can re-deliver the same event either as the same object or as
-  an equal copy, so both must be deduplicated.
+  A caller that retries ``append_event`` (e.g. a write buffer behind an RPC)
+  can re-deliver the same event either as the same object or as an equal
+  copy, so both must be deduplicated.
   """
   app_name = 'test_app'
   user_id = 'user_dup'
@@ -3917,8 +3918,8 @@ async def test_append_event_is_idempotent_for_same_event_id(session_service):
       actions=EventActions(state_delta={'session:counter': 1}),
   )
 
-  # Re-deliver as the same object and again as an equal copy (a broadcast
-  # to several concurrent session references can produce either).
+  # Re-deliver as the same object and again as an equal copy (a retried
+  # call can produce either).
   await session_service.append_event(session=session, event=event)
   await session_service.append_event(session=session, event=event)
   await session_service.append_event(