fix(adk): skip saving checkpoint when TurnLoop is idle (#916)

* fix(adk): skip saving checkpoint when TurnLoop is idle

When Stop() is called on an idle TurnLoop (no active agent run, no
unhandled items, no canceled items), the resulting checkpoint contains
no meaningful state. Skip saving such checkpoints to avoid unnecessary
store writes.

- Add isIdle check in cleanup() before checkpoint save decision
- Add TestTurnLoop_StopWhileIdle_SkipsCheckpoint test

Change-Id: I6aeaff5ed5833a971cb95298193fdb96d904baf8

* fix(internal): merge id2State in PopulateInterruptState instead of replacing

PopulateInterruptState merged id2Addr entries one by one but replaced
id2State wholesale. In a parallel workflow resume, two goroutines share
the same globalResumeInfo. If one goroutine's compose graph called
PopulateInterruptState (replacing id2State with compose-only entries)
before the other goroutine looked up its outer-level entry, the lookup
returned a zero-value InterruptState with State=nil, triggering the
'has no state' panic in ChatModelAgent.Resume.

Change id2State handling to merge entry by entry, consistent with
id2Addr.

Change-Id: Ia21f65289bff7beb2bc383fb033926ad9c92d7e7

* fix(adk): keep watching for cancel escalation after stopSig.done

When watchStopSignal entered the stopSig.done branch, it processed the
initial cancel and then blocked on <-done (turn completion), never
looping back to check notify. This meant a subsequent Stop() call with
a higher cancel mode (e.g. CancelImmediate) was never forwarded to the
agent, causing TestTurnLoop_Stop_EscalatesCancelMode to time out.

Replace the blocking <-done with an inner loop that selects on both
done and notify, so escalation signals are always delivered. Also apply
the generation-based dedup check consistent with the notify branch.

Change-Id: Ia6a04d00a2b44625ffbcb625ff0e559c12ed145f

Author: shentongmartin

adk/turn_loop.go

@@ -1228,14 +1228,31 @@ func (l *TurnLoop[T]) watchStopSignal(done <-chan struct{}, agentCancelFunc Agen
 				}
 			}
 		case <-l.stopSig.done:
-			_, opts := l.stopSig.check()
-			_, contributed := agentCancelFunc(opts...)
-			if contributed && !stoppedClosed {
-				close(stoppedDone)
-				stoppedClosed = true
+			gen, opts := l.stopSig.check()
+			if gen != lastGen {
+				lastGen = gen
+				_, contributed := agentCancelFunc(opts...)
+				if contributed && !stoppedClosed {
+					close(stoppedDone)
+					stoppedClosed = true
+				}
+			}
+			for {
+				select {
+				case <-done:
+					return
+				case <-l.stopSig.notify:
+					gen, opts := l.stopSig.check()
+					if gen != lastGen {
+						lastGen = gen
+						_, contributed := agentCancelFunc(opts...)
+						if contributed && !stoppedClosed {
+							close(stoppedDone)
+							stoppedClosed = true
+						}
+					}
+				}
 			}
-			<-done
-			return
 		}
 	}
 }
@@ -1380,7 +1397,8 @@ func (l *TurnLoop[T]) cleanup(ctx context.Context) {
 
 	unhandled := l.buffer.TakeAll()
 	checkpointID := l.config.CheckpointID
-	shouldSaveCheckpoint := l.config.Store != nil && checkpointID != "" && l.stopSig.isStopped()
+	isIdle := len(l.checkPointRunnerBytes) == 0 && len(unhandled) == 0 && len(l.canceledItems) == 0
+	shouldSaveCheckpoint := l.config.Store != nil && checkpointID != "" && l.stopSig.isStopped() && !isIdle
 	if shouldSaveCheckpoint {
 		cp := &turnLoopCheckpoint[T]{
 			RunnerCheckpoint: l.checkPointRunnerBytes,

adk/turn_loop_test.go

@@ -1484,6 +1484,34 @@ func TestTurnLoop_StopWithoutCheckpointIDDoesNotPersist(t *testing.T) {
 	assert.Empty(t, store.m, "no checkpoint should be saved when CheckpointID is not configured")
 }
 
+func TestTurnLoop_StopWhileIdle_SkipsCheckpoint(t *testing.T) {
+	ctx := context.Background()
+	store := &deletableCheckpointStore{
+		turnLoopCheckpointStore: turnLoopCheckpointStore{m: make(map[string][]byte)},
+	}
+	cpID := "idle-session"
+
+	loop := newAndRunTurnLoop(ctx, TurnLoopConfig[string]{
+		Store:        store,
+		CheckpointID: cpID,
+		GenInput: func(ctx context.Context, _ *TurnLoop[string], items []string) (*GenInputResult[string], error) {
+			return &GenInputResult[string]{Input: &AgentInput{}, Consumed: items}, nil
+		},
+		PrepareAgent: func(ctx context.Context, _ *TurnLoop[string], consumed []string) (Agent, error) {
+			return &turnLoopMockAgent{name: "test"}, nil
+		},
+	})
+
+	loop.Stop()
+	exit := loop.Wait()
+	assert.NoError(t, exit.ExitReason)
+
+	store.mu.Lock()
+	defer store.mu.Unlock()
+	_, exists := store.m[cpID]
+	assert.False(t, exists, "no checkpoint should be saved when TurnLoop is idle")
+}
+
 func TestTurnLoop_StopBetweenTurnsAndResume(t *testing.T) {
 	ctx := context.Background()
 	store := &turnLoopCheckpointStore{m: make(map[string][]byte)}

internal/core/address.go

@@ -281,7 +281,12 @@ func PopulateInterruptState(ctx context.Context, id2Addr map[string]Address,
 		for id, addr := range id2Addr {
 			rInfo.id2Addr[id] = addr
 		}
-		rInfo.id2State = id2State
+		if rInfo.id2State == nil {
+			rInfo.id2State = make(map[string]InterruptState)
+		}
+		for id, state := range id2State {
+			rInfo.id2State[id] = state
+		}
 	} else {
 		rInfo = &globalResumeInfo{
 			id2Addr:           id2Addr,