fix: Account for nulls in EventActions and State

This change convert nulls to `State.REMOVED` to be closer to the way other methods in those classes work.

PiperOrigin-RevId: 911414129

Author: google-genai-bot

core/src/main/java/com/google/adk/events/EventActions.java

@@ -289,10 +289,15 @@ public Builder skipSummarization(@Nullable Boolean skipSummarization) {
     @CanIgnoreReturnValue
     @JsonProperty("stateDelta")
     public Builder stateDelta(@Nullable Map<String, Object> value) {
-      if (value == null) {
-        this.stateDelta = new ConcurrentHashMap<>();
-      } else {
-        this.stateDelta = new ConcurrentHashMap<>(value);
+      this.stateDelta = new ConcurrentHashMap<>();
+      if (value != null) {
+        value
+            .entrySet()
+            .forEach(
+                entry -> {
+                  stateDelta.put(
+                      entry.getKey(), Optional.ofNullable(entry.getValue()).orElse(State.REMOVED));
+                });
       }
       return this;
     }

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

@@ -46,16 +46,22 @@ public State(Map<String, Object> state) {
 
   public State(Map<String, Object> state, @Nullable Map<String, Object> delta) {
     Objects.requireNonNull(state, "state is null");
-    this.state =
-        state instanceof ConcurrentMap
-            ? (ConcurrentMap<String, Object>) state
-            : new ConcurrentHashMap<>(state);
-    this.delta =
-        delta == null
-            ? new ConcurrentHashMap<>()
-            : delta instanceof ConcurrentMap
-                ? (ConcurrentMap<String, Object>) delta
-                : new ConcurrentHashMap<>(delta);
+    this.state = toConcurrentMap(state);
+    this.delta = toConcurrentMap(delta);
+  }
+
+  private static ConcurrentMap<String, Object> toConcurrentMap(Map<String, Object> map) {
+    if (map == null) {
+      return new ConcurrentHashMap<>();
+    }
+    if (map instanceof ConcurrentMap) {
+      return (ConcurrentMap<String, Object>) map;
+    }
+    ConcurrentMap<String, Object> concurrentMap = new ConcurrentHashMap<>();
+    for (Map.Entry<String, Object> entry : map.entrySet()) {
+      concurrentMap.put(entry.getKey(), entry.getValue() == null ? REMOVED : entry.getValue());
+    }
+    return concurrentMap;
   }
 
   @Override

core/src/test/java/com/google/adk/events/EventActionsTest.java

@@ -24,6 +24,7 @@
 import com.google.common.collect.ImmutableSet;
 import com.google.genai.types.Content;
 import com.google.genai.types.Part;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
@@ -129,6 +130,33 @@ public void removeStateByKey_marksKeyAsRemoved() {
     assertThat(eventActions.stateDelta()).containsExactly("key1", State.REMOVED);
   }
 
+  @Test
+  public void builderStateDelta_withNullMap_initializesEmptyMap() {
+    EventActions eventActions = EventActions.builder().stateDelta(null).build();
+
+    assertThat(eventActions.stateDelta()).isEmpty();
+  }
+
+  @Test
+  public void builderStateDelta_withNullValue_marksKeyAsRemoved() {
+    Map<String, Object> inputDelta = new HashMap<>();
+    inputDelta.put("key1", "value1");
+    inputDelta.put("key2", null);
+
+    EventActions eventActions = EventActions.builder().stateDelta(inputDelta).build();
+
+    assertThat(eventActions.stateDelta()).containsExactly("key1", "value1", "key2", State.REMOVED);
+  }
+
+  @Test
+  public void jsonDeserialization_withNullValueInStateDelta_deserializesAsRemoved()
+      throws Exception {
+    String json = "{\"stateDelta\":{\"key1\":\"value1\",\"key2\":null}}";
+    EventActions deserialized = EventActions.fromJsonString(json, EventActions.class);
+
+    assertThat(deserialized.stateDelta()).containsExactly("key1", "value1", "key2", State.REMOVED);
+  }
+
   @Test
   public void jsonSerialization_works() throws Exception {
     EventActions eventActions =

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

@@ -23,8 +23,10 @@ public void constructor_nullDelta_createsEmptyConcurrentHashMap() {
   }
 
   @Test
-  public void constructor_nullState_throwsException() {
-    Assert.assertThrows(NullPointerException.class, () -> new State(null, new HashMap<>()));
+  public void constructor_nullState_createsEmptyConcurrentHashMap() {
+    State state = new State(null, new HashMap<>());
+    assertThat(state.isEmpty()).isTrue();
+    assertThat(state.hasDelta()).isFalse();
   }
 
   @Test
@@ -47,4 +49,14 @@ public void constructor_singleArgument() {
     state.put("key", "value");
     assertThat(state.hasDelta()).isTrue();
   }
+
+  @Test
+  public void constructor_stateMapWithNullValues_replacesWithRemoved() {
+    Map<String, Object> stateMap = new HashMap<>();
+    stateMap.put("key1", "value1");
+    stateMap.put("key2", null);
+    State state = new State(stateMap);
+    assertThat(state).containsEntry("key1", "value1");
+    assertThat(state).containsEntry("key2", State.REMOVED);
+  }
 }