fix: memory leak in InMemorySessionService.deleteSession() - clean up empty parent maps

When deleteSession() removes the last session for a userId, the now-empty
userId map remained in the parent appName map. Similarly, if all users under
an appName were deleted, the empty appName map remained in the top-level
sessions map. This caused linear memory growth with the number of unique
users/apps, eventually leading to OutOfMemoryError.

Replace the manual get+remove pattern with computeIfPresent() calls that
atomically remove parent map entries when they become empty. When the
remapping function returns null, ConcurrentHashMap automatically removes
the key - this is thread-safe without additional locking.

Before:
  sessions = { appName: { userId: {} } }  <-- empty maps leak

After:
  sessions = {}  <-- fully cleaned up

Add two new tests:
- deleteSession_cleansUpEmptyParentMaps: verifies via reflection that the
  internal sessions map is completely empty after deleting the only session
- deleteSession_doesNotRemoveUserMapWhenOtherSessionsExist: verifies that
  a userId entry is NOT pruned when the user still has remaining sessions

Fixes #687

Author: YuqiGuo105

core/src/main/java/com/google/adk/sessions/InMemorySessionService.java

@@ -192,13 +192,16 @@ public Completable deleteSession(String appName, String userId, String sessionId
     Objects.requireNonNull(userId, "userId cannot be null");
     Objects.requireNonNull(sessionId, "sessionId cannot be null");
 
-    ConcurrentMap<String, ConcurrentMap<String, Session>> appSessionsMap = sessions.get(appName);
-    if (appSessionsMap != null) {
-      ConcurrentMap<String, Session> userSessionsMap = appSessionsMap.get(userId);
-      if (userSessionsMap != null) {
-        userSessionsMap.remove(sessionId);
-      }
-    }
+    sessions.computeIfPresent(appName, (app, appSessionsMap) -> {
+        appSessionsMap.computeIfPresent(userId, (user, userSessionsMap) -> {
+            userSessionsMap.remove(sessionId);
+            // If userSessionsMap is now empty, return null to automatically remove the userId key
+            return userSessionsMap.isEmpty() ? null : userSessionsMap;
+        });
+        // If appSessionsMap is now empty, return null to automatically remove the appName key
+        return appSessionsMap.isEmpty() ? null : appSessionsMap;
+    });
+
     return Completable.complete();
   }
 

core/src/test/java/com/google/adk/sessions/InMemorySessionServiceTest.java

@@ -20,6 +20,7 @@
 import com.google.adk.events.Event;
 import com.google.adk.events.EventActions;
 import io.reactivex.rxjava3.core.Single;
+import java.lang.reflect.Field;
 import java.util.HashMap;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
@@ -247,4 +248,59 @@ public void sequentialAgents_shareTempState() {
     assertThat(retrievedSession.state()).doesNotContainKey("temp:agent1_output");
     assertThat(retrievedSession.state()).containsEntry("temp:agent2_output", "processed_data");
   }
+
+  // Fixes https://github.com/google/adk-java/issues/687
+  @Test
+  public void deleteSession_cleansUpEmptyParentMaps() throws Exception {
+    InMemorySessionService sessionService = new InMemorySessionService();
+    Session session = sessionService.createSession("app-name", "user-id").blockingGet();
+
+    sessionService.deleteSession(session.appName(), session.userId(), session.id()).blockingAwait();
+
+    assertThat(getSessionsMap(sessionService)).isEmpty();
+  }
+
+  @Test
+  public void deleteSession_doesNotRemoveUserMapWhenOtherSessionsExist() throws Exception {
+    InMemorySessionService sessionService = new InMemorySessionService();
+    Session session1 = sessionService.createSession("app-name", "user-id").blockingGet();
+    Session session2 = sessionService.createSession("app-name", "user-id").blockingGet();
+
+    sessionService.deleteSession(session1.appName(), session1.userId(), session1.id()).blockingAwait();
+
+    // session2 still retrievable
+    assertThat(
+            sessionService
+                .getSession(session2.appName(), session2.userId(), session2.id(), Optional.empty())
+                .blockingGet())
+        .isNotNull();
+
+    // userId entry survives because session2 remains
+    assertThat(getSessionsMap(sessionService).get("app-name").get("user-id")).hasSize(1);
+  }
+
+  // Reproduces issue #687: user1/user2/user3 each delete their only session → no ghost maps left.
+  @Test
+  public void deleteSession_multipleUsers_cleansUpAllEmptyMaps() throws Exception {
+    InMemorySessionService sessionService = new InMemorySessionService();
+    Session s1 = sessionService.createSession("myApp", "user1").blockingGet();
+    Session s2 = sessionService.createSession("myApp", "user2").blockingGet();
+    Session s3 = sessionService.createSession("myApp", "user3").blockingGet();
+
+    sessionService.deleteSession(s1.appName(), s1.userId(), s1.id()).blockingAwait();
+    sessionService.deleteSession(s2.appName(), s2.userId(), s2.id()).blockingAwait();
+    sessionService.deleteSession(s3.appName(), s3.userId(), s3.id()).blockingAwait();
+
+    assertThat(getSessionsMap(sessionService)).isEmpty();
+  }
+
+  // Helper: accesses the private sessions field via reflection.
+  @SuppressWarnings("unchecked")
+  private static ConcurrentMap<String, ConcurrentMap<String, ConcurrentMap<String, ?>>>
+      getSessionsMap(InMemorySessionService service) throws Exception {
+    Field field = InMemorySessionService.class.getDeclaredField("sessions");
+    field.setAccessible(true);
+    return (ConcurrentMap<String, ConcurrentMap<String, ConcurrentMap<String, ?>>>)
+        field.get(service);
+  }
 }