* 采用生产者-消费者解耦设计：将 SSE 事件的生产（Flux 订阅）与消费（SseEmitter 连接）解耦。 * 一个后台 Flux 生产者持续产出事件，广播给所有 SseEmitter 订阅者并缓存到 buffer。 * 新连接（重连）到来时，先回放 buffer，再接入实时流。 * *
The {@link #runs} map is process-local memory. A reconnect * request can only re-attach to a {@code RunState} that lives on the same * JVM that originally created it. In a multi-node deployment behind a load * balancer, the LB MUST be configured for sticky session by {@code conversationId} * (Nginx {@code hash $arg_conversationId consistent;}, K8s Ingress * cookie-based affinity, AWS ALB target-group stickiness, etc.). * *
This is an explicit CE constraint — see * {@code rfcs/community/90-appendix/02-tech-debt-inventory.md §4.1} and * {@code rfc-054 §0}. Cross-node SSE relay (Redis Stream / NATS / Kafka) is * tracked under the EE roadmap. * *
Operator-facing diagnostics: callers should use
* {@link #streamExistsOnThisNode(String)} when distinguishing "stream finished
* normally" from "stream is on a different node" — both return {@code false}
* from {@link #attach(String, SseEmitter)} but mean very different things to
* the user.
*
* @author MateClaw Team
*/
@Slf4j
@Component
public class ChatStreamTracker {
/** buffer 最大事件数，超出后丢弃最早的 thinking_delta 事件以释放空间 */
private static final int MAX_BUFFER_SIZE = 16000;
private final ObjectMapper objectMapper;
/**
* Maximum size, in bytes, of a single SSE event JSON payload before
* {@link #broadcastChunked} splits the body into ordered
* {@code tool_result_chunk} events.
*/
static final int CHUNK_SIZE = 8192;
// ===== Configurable knobs (mateclaw.stream.*) =====
/**
* Gate for chunked tool-result transport. When {@code false},
* {@link #broadcastChunked} falls back to a single broadcast call so
* environments that prefer the legacy single-event behavior can opt out.
*/
@Value("${mateclaw.stream.chunked-tool-results:true}")
private boolean chunkedToolResultsEnabled = true;
/**
* Gate for {@code iteration_start} / {@code iteration_end} events emitted
* from graph nodes. Off-by-default deployments can suppress them without
* touching node code.
*/
@Value("${mateclaw.stream.iteration-events:true}")
private boolean iterationEventsEnabled = true;
/**
* Heartbeat cadence (seconds) before the first model token arrives. Short
* because pre-token gaps strand the UI on a blank "正在生成中" placeholder
* with no visible activity.
*/
@Value("${mateclaw.stream.heartbeat.pre-token-sec:2}")
private int heartbeatPreTokenSec = 2;
/**
* Heartbeat cadence (seconds) once the model is actively streaming tokens —
* deltas themselves keep the connection warm, so heartbeats relax.
*/
@Value("${mateclaw.stream.heartbeat.streaming-sec:10}")
private int heartbeatStreamingSec = 10;
/**
* Heartbeat cadence (seconds) while a tool call is in flight. Tools can
* take longer than streaming chunks but should still tick faster than the
* default proxy idle timeout.
*/
@Value("${mateclaw.stream.heartbeat.tool-sec:5}")
private int heartbeatToolSec = 5;
public ChatStreamTracker(ObjectMapper objectMapper) {
this.objectMapper = objectMapper;
}
/** Test-only setters; production paths use Spring property binding. */
void setChunkedToolResultsEnabled(boolean enabled) {
this.chunkedToolResultsEnabled = enabled;
}
void setIterationEventsEnabled(boolean enabled) {
this.iterationEventsEnabled = enabled;
}
public boolean isIterationEventsEnabled() {
return iterationEventsEnabled;
}
/**
* One buffered SSE event. The {@code id} is a per-conversation monotonic
* sequence — the SSE protocol's standard {@code id:} line carries this
* value so the client can echo it back via {@code lastEventId} when
* reconnecting, allowing us to skip already-delivered events on replay.
*/
record SseEvent(long id, String name, String json) {}
/**
* 中断类型：区分用户主动停止和用户在运行中追加新消息
*/
public enum InterruptType {
/** 用户点击 Stop，终止当前 turn，不自动续跑 */
USER_STOP,
/** 用户在执行中追加新消息，中断当前 turn 后自动续跑排队消息 */
USER_INTERRUPT_WITH_FOLLOWUP
}
static final class RunState {
final String conversationId;
final List
* The callback must be idempotent (will not be called twice for the same run, but
* may race with normal doOnComplete/doOnError; both paths must tolerate the other
* having saved already).
*/
volatile Runnable emergencySaveCallback;
/** 心跳定时器 */
volatile ScheduledFuture heartbeatFuture;
/**
* Flips the first time any content/thinking delta is observed for this
* run. Heartbeat scheduling watches this flag to switch from the short
* pre-token cadence to the streaming cadence — pre-token gaps need
* frequent keep-alives because the UI has no other signal of activity.
*/
volatile boolean firstTokenReceived = false;
/** 已广播的 pending approval ID 集合（用于幂等去重） */
final java.util.Set
* Read by the SSE doOn* handlers in ChatController to skip a duplicate
* saveMessage when the recycle path already wrote the "[已被用户中止]"
* placeholder. Without this, the agent's late-yielding doOnComplete
* inserts a second assistant row carrying whatever the agent produced
* after the user pressed stop — exactly the behavior the user does
* not want when force-recycling.
*/
private final ConcurrentHashMap
* Buffered events are emitted as a single {@code delegation_batch}
* envelope on the parent conversation listener:
*
* Two event categories survive {@code state.done=true}:
*
* 用于在 Node 内部直接向前端推送 SSE 事件，绕过 NodeOutput 管道。
* 典型场景：审批请求在 awaitDecision() 阻塞前必须先送达前端。
*
* @param conversationId 会话 ID
* @param eventName SSE 事件名称（如 tool_approval_requested）
* @param data 事件载荷，将被 Jackson 序列化为 JSON
*/
public void broadcastObject(String conversationId, String eventName, Object data) {
String json;
try {
json = objectMapper.writeValueAsString(data);
} catch (Exception e) {
log.warn("Failed to serialize broadcast data for event {}: {}", eventName, e.getMessage());
json = "{\"error\":\"serialization_failed\"}";
}
broadcast(conversationId, eventName, json);
}
/**
* Broadcast {@code payload} as a single SSE event when its serialized form
* fits within {@link #CHUNK_SIZE}; otherwise extract the long {@code result}
* field and emit it as ordered {@code tool_result_chunk} events.
*
* Each chunk carries:
* {@link #attach(String, SseEmitter)} returns {@code false} both when
* the stream finished normally and when no state exists on this
* node. Callers that need to distinguish those two cases (e.g. to send a
* different SSE event to the client) should consult this method first.
*
* @return {@code true} when a RunState exists locally for this
* conversationId; {@code false} when it never existed here OR was
* already cleaned up after completion
*/
public boolean streamExistsOnThisNode(String conversationId) {
return runs.containsKey(conversationId);
}
/**
* 将 emitter 附着到现有的运行中或刚刚完成的流。
* 先回放 buffer 中的全部事件，再加入订阅者列表接收后续实时事件（仅当流仍在运行时）。
*
* 兼容"流已完成"语义：如果 RunState 还在 map 里但 done=true，仍然回放 buffer
* （包含 done 事件本身），让重连客户端拿到完成信号后正常退出"生成中"状态。
* RunState 完成后会保留 DONE_RETENTION_MS（5 分钟），由 cleanupStaleRuns 异步清理；
* 这段窗口期内任何刷新页面都能拿到 done 回放。
*
* @return true 如果成功附着或重放（订阅者已加入或事件已重放完毕），false 如果没有任何状态可恢复
*/
public boolean attach(String conversationId, SseEmitter emitter) {
return attach(conversationId, emitter, 0L);
}
/**
* Reconnect-aware attach: replays only events whose id >
* {@code lastEventId}. Pass 0 to replay everything (fresh attach
* behavior — same as the no-arg overload).
*
* The id is the per-conversation monotonic sequence stamped on
* each {@link SseEvent} when it was first emitted. Frontend tracks
* the last id it processed and echoes it back via the request
* body's {@code lastEventId} field, eliminating the duplicate-
* delivery class of bugs (the symptom: thinking segments rendered
* with the wrong iterationIndex because frontend processed the
* same {@code iteration_start} twice).
*/
public boolean attach(String conversationId, SseEmitter emitter, long lastEventId) {
RunState state = runs.get(conversationId);
if (state == null) {
return false;
}
synchronized (state.lock) {
// Replay buffer with id-based dedup. Each buffered event keeps its
// original (1:1) id, so the skip condition is the simple
// `id <= lastEventId`. trimBuffer no longer merges delta events,
// so a single id always corresponds to a single contiguous run of
// text — there's no straddling-range edge case.
int replayed = 0;
int skipped = 0;
for (SseEvent event : state.buffer) {
if (event.id() <= lastEventId) {
skipped++;
continue;
}
try {
emitter.send(SseEmitter.event().id(String.valueOf(event.id())).name(event.name()).data(event.json()));
replayed++;
} catch (IOException | IllegalStateException e) {
log.warn("Failed to replay buffer to reconnecting client for {}: {}",
conversationId, e.getMessage());
return false;
}
}
if (lastEventId > 0 && skipped > 0) {
log.info("[SSE] Reconnect dedup for {}: skipped {} already-seen events, replayed {} new",
conversationId, skipped, replayed);
}
// Stream complete: buffer replayed (including the `done` event itself).
// We DO NOT auto-complete the emitter here — keep it subscribed so any
// late-arriving async_task_* events (image/video/music generation that
// outlasts the agent's reasoning turn) reach the client live. Idle
// emitters are pruned naturally when:
// - the next broadcast hits a broken pipe and removes the dead subscriber
// - cleanupStaleRuns() removes the RunState after DONE_RETENTION_MS (5 min)
// - the frontend explicitly disconnects (component unmount / navigation)
// Without this, async_task_completed fired after `done` would be silently
// dropped, leaving the chat UI stuck on the "正在生成中" placeholder.
state.subscribers.add(emitter);
if (state.done) {
log.info("[SSE] Replayed {} buffered events; emitter stays subscribed for late async events: {}",
state.buffer.size(), conversationId);
// Restart heartbeat so the proxy/Tomcat 60s idle timeout doesn't
// close the reconnected emitter before the async_task_* event fires.
// The scheduler self-stops once subscribers go empty (see startHeartbeat).
startHeartbeat(conversationId);
return true;
}
}
log.info("[SSE] Client reconnected for conversation={}, replaying {} buffered events",
conversationId, state.buffer.size());
return true;
}
/**
* 递增活跃 Flux 计数（每个 Flux 订阅开始时调用）。
* 原始流和审批 Replay 流共享同一个 RunState，通过计数协调生命周期。
*/
public void incrementFlux(String conversationId) {
RunState state = runs.get(conversationId);
if (state != null) {
synchronized (state.lock) {
state.activeFluxCount++;
log.debug("Flux count incremented: {} (count={})", conversationId, state.activeFluxCount);
}
}
}
/**
* 完成结果：包含是否全部完成、排队消息快照
*/
public record CompletionResult(boolean allDone, QueuedInput queuedInput) {}
/**
* 标记一个 Flux 完成。仅在所有 Flux 都完成时才真正移除 RunState。
*
* 这解决了"原始流完成关闭 SSE，但 Replay 流仍在运行"的竞态问题。
*
* 无副作用：不消费排队消息。适用于不关心 queue 的路径（approval deny、setup error 等）。
* 需要链式续跑的路径应使用 {@link #completeAndConsumeIfLast(String)}。
*
* @return true 如果这是最后一个 Flux（RunState 已被移除），false 如果仍有活跃 Flux
*/
public boolean complete(String conversationId) {
RunState state = runs.get(conversationId);
if (state == null) {
return true;
}
synchronized (state.lock) {
state.activeFluxCount = Math.max(0, state.activeFluxCount - 1);
if (state.activeFluxCount > 0) {
log.debug("Stream partially completed (no queue drain): {} (remaining flux={})",
conversationId, state.activeFluxCount);
return false;
}
}
// 所有 Flux 都已完成，停止心跳，标记 done 但**不立即移除 RunState**——
// 留给 cleanupStaleRuns 在 DONE_RETENTION_MS 后异步清理。这段窗口期内
// 客户端刷新页面 attach() 能从 buffer 回放 done 事件，UI 不会卡在
// "生成中"。之前立即 runs.remove() 是 SSE 中途断开导致 done 永远丢的根源。
stopHeartbeat(conversationId);
state.done = true;
log.debug("Stream fully completed (no queue drain): {} (kept in map for {}ms reconnect window)",
conversationId, DONE_RETENTION_MS);
return true;
}
/**
* 原子地递减 activeFluxCount，仅在最后一个 Flux 完成时消费排队消息并移除 RunState。
*
* 将「递减计数 → 消费 queue → 删除 RunState」三步收口到同一个临界区，
* 避免非最后一个 flux 提前 consume 导致 queue 丢失，也避免 complete 后查不到 queue。
*
* @return CompletionResult(allDone, queuedInput)
*/
public CompletionResult completeAndConsumeIfLast(String conversationId) {
RunState state = runs.get(conversationId);
if (state == null) {
return new CompletionResult(true, null);
}
QueuedInput consumed = null;
synchronized (state.lock) {
state.activeFluxCount = Math.max(0, state.activeFluxCount - 1);
if (state.activeFluxCount > 0) {
log.debug("Stream partially completed: {} (remaining flux={}, queuePreserved={})",
conversationId, state.activeFluxCount, !state.messageQueue.isEmpty());
return new CompletionResult(false, null);
}
// 最后一个 Flux：在同一个锁内消费排队消息（取队首）
consumed = state.messageQueue.poll();
}
// 锁外：停止心跳，标记 done。**不立即移除 RunState**——保留 DONE_RETENTION_MS
// 让客户端可在窗口期内刷新页面通过 attach() 回放 done 事件。
stopHeartbeat(conversationId);
state.done = true;
log.debug("Stream fully completed: {} (hasQueuedSnapshot={}, kept in map for {}ms reconnect window)",
conversationId, consumed != null, DONE_RETENTION_MS);
return new CompletionResult(true, consumed);
}
/**
* 检查指定会话是否有正在运行的流
*/
public boolean isRunning(String conversationId) {
RunState state = runs.get(conversationId);
return state != null && !state.done;
}
/**
* 从订阅者列表中移除指定 emitter（连接断开/超时时调用）
*/
public void detach(String conversationId, SseEmitter emitter) {
RunState state = runs.get(conversationId);
if (state == null) {
return;
}
synchronized (state.lock) {
state.subscribers.remove(emitter);
}
log.debug("Emitter detached from stream: {} (remaining={})",
conversationId, state.subscribers.size());
}
// ===== Heartbeat =====
/**
* Pick the heartbeat cadence (seconds) that matches the run's current
* phase. Pre-token gaps need fast keep-alives so the UI shows activity;
* tool execution stretches slightly; mid-stream is rate-limited because
* deltas already keep the connection warm.
*/
private int currentHeartbeatIntervalSec(RunState state) {
if (state.runningToolName != null && !state.runningToolName.isEmpty()) {
return heartbeatToolSec;
}
return state.firstTokenReceived ? heartbeatStreamingSec : heartbeatPreTokenSec;
}
/**
* 启动心跳定时器。在流注册后调用，定期向前端发送 heartbeat 事件。
* 防止 useStream 的 60 秒无数据 timeout 误杀等待审批/长工具的流。
*/
public void startHeartbeat(String conversationId) {
RunState state = runs.get(conversationId);
if (state == null) return;
// 避免重复启动
if (state.heartbeatFuture != null && !state.heartbeatFuture.isDone()) return;
int intervalSec = currentHeartbeatIntervalSec(state);
state.heartbeatFuture = heartbeatScheduler.scheduleAtFixedRate(() -> {
try {
RunState s = runs.get(conversationId);
if (s == null) {
stopHeartbeat(conversationId);
return;
}
// Continue heartbeating post-done as long as someone is still listening
// (reconnected emitter waiting for late async_task_* events). Stop only
// when the run is done AND the subscribers list is empty — otherwise the
// 60s idle proxy timeout drops the reconnected emitter and async events
// never reach the client live.
if (s.done && s.subscribers.isEmpty()) {
stopHeartbeat(conversationId);
return;
}
String json;
try {
json = objectMapper.writeValueAsString(Map.of(
"conversationId", conversationId,
"currentPhase", safe(s.currentPhase),
"waitingReason", safe(s.waitingReason),
"runningToolName", safe(s.runningToolName),
"queueLength", s.messageQueue.size(),
"timestamp", System.currentTimeMillis()
));
} catch (Exception e) {
json = "{\"conversationId\":\"" + conversationId + "\"}";
}
broadcast(conversationId, "heartbeat", json);
} catch (Exception e) {
log.debug("Heartbeat error for {}: {}", conversationId, e.getMessage());
}
}, intervalSec, intervalSec, TimeUnit.SECONDS);
}
/**
* Mark that the first content/thinking token has been received for this
* run and reschedule the heartbeat at the streaming cadence.
*
* Called from the LLM streaming layer so the heartbeat relaxes once the
* connection is naturally being kept warm by data deltas. Idempotent — a
* second call is a no-op.
*/
public void markFirstTokenReceived(String conversationId) {
RunState state = runs.get(conversationId);
if (state == null) return;
if (state.firstTokenReceived) return;
state.firstTokenReceived = true;
rescheduleHeartbeat(conversationId);
}
/**
* Cancels the active heartbeat (if any) and starts a new one at the
* cadence currently appropriate for the run state. Public so callers that
* mutate {@code runningToolName} can request a tool-cadence heartbeat.
*/
public void rescheduleHeartbeat(String conversationId) {
RunState state = runs.get(conversationId);
if (state == null || state.done) return;
if (state.heartbeatFuture != null) {
state.heartbeatFuture.cancel(false);
state.heartbeatFuture = null;
}
startHeartbeat(conversationId);
}
/**
* 停止心跳定时器
*/
public void stopHeartbeat(String conversationId) {
RunState state = runs.get(conversationId);
if (state != null && state.heartbeatFuture != null) {
state.heartbeatFuture.cancel(false);
state.heartbeatFuture = null;
}
}
// ===== Phase tracking =====
/**
* 更新当前执行阶段（用于 heartbeat 和前端状态展示）
*/
public void updatePhase(String conversationId, String phase) {
RunState state = runs.get(conversationId);
if (state != null) {
state.currentPhase = phase;
}
}
/**
* 更新当前正在执行的工具名称
*/
public void updateRunningTool(String conversationId, String toolName) {
RunState state = runs.get(conversationId);
if (state != null) {
String previous = state.runningToolName;
state.runningToolName = toolName;
// Heartbeat cadence depends on whether a tool is in flight; switch
// cadences when the tool slot transitions in either direction.
boolean wasRunning = previous != null && !previous.isEmpty();
boolean nowRunning = toolName != null && !toolName.isEmpty();
if (wasRunning != nowRunning) {
rescheduleHeartbeat(conversationId);
}
}
}
/**
* Read-only accessor for the currently running tool name on a conversation.
* Returns {@code null} when no run state exists or no tool is in flight.
* Used by external observers (heartbeat watchdog, status APIs) that need
* to probe progress without mutating the run.
*/
public String getRunningToolName(String conversationId) {
RunState state = runs.get(conversationId);
return state != null ? state.runningToolName : null;
}
/**
* Read-only accessor for the current execution phase. Returns {@code null}
* when no run state exists. Mirrors {@link #getRunningToolName(String)} so
* external observers can read both fields without touching internals.
*/
public String getCurrentPhase(String conversationId) {
RunState state = runs.get(conversationId);
return state != null ? state.currentPhase : null;
}
/**
* 设置等待原因
*/
public void setWaitingReason(String conversationId, String reason) {
RunState state = runs.get(conversationId);
if (state != null) {
state.waitingReason = reason;
}
}
// ===== Interrupt with follow-up =====
/**
* 请求中断当前流并排队一条用户消息。
* 与 requestStop 的区别：中断后自动续跑排队消息，而非停在原地。
*
* @return true 如果成功请求了中断
*/
public boolean requestInterrupt(String conversationId, String queuedMessage, Long agentId, boolean persisted) {
return requestInterrupt(conversationId, queuedMessage, agentId, persisted, null);
}
public boolean requestInterrupt(String conversationId, String queuedMessage, Long agentId,
boolean persisted, List We deliberately do NOT merge delta events even though it would
* reduce entry count more aggressively. Merging concatenates a range
* of original event ids into a single record; on reconnect a client
* whose {@code lastEventId} falls inside the merged range would
* either re-receive the head text (replay = duplicate) or lose the
* tail text (skip = data loss). Both are correctness bugs, and the
* dropping strategy below avoids them entirely — events kept in the
* buffer always correspond 1:1 to the ids the client originally saw.
*
* Strategy (must be called under {@code state.lock}):
*
* Spring closes singleton beans in reverse construction order; ConversationService /
* Hikari outlive ChatStreamTracker, so saveMessage from {@link #onShutdown()} still
* has a working DB connection. Without this, a {@code mvn spring-boot:run} restart or
* SIGTERM during a turn races against the Reactor cancellation: the doOnError /
* doOnComplete saveMessage may not run before HikariPool shuts down, leaving the
* conversation with only the user message and no assistant reply (the
* "对话框里除了问题外什么也没留下" symptom seen in production logs at 07:23:02).
*
* Behavior:
*
* {
* "kind": "delegation_batch",
* "scope": "subagent",
* "events": [{ "event": "tool_call_started", "data": "<json>" }, ...]
* }
*
*
* @param sourceConversationId conversation to listen on
* @param parentConversationId parent conversation context (currently
* forwarded only as listener metadata; the
* tracker itself does not target it)
* @param batchSize flush threshold by event count
* @param flushMs flush threshold by elapsed millis since
* first buffered event
* @return Runnable that deregisters the relay (and flushes any pending
* events first)
*/
public Runnable addBatchedEventRelay(String sourceConversationId,
String parentConversationId,
int batchSize,
long flushMs,
java.util.function.BiConsumer
*
* For all other events, the prior {@code state==null || state.done}
* early-return remains.
*/
public void broadcast(String conversationId, String eventName, String jsonData) {
RunState state = runs.get(conversationId);
boolean isDone = "done".equals(eventName);
boolean isAsyncTask = eventName != null && eventName.startsWith("async_task_");
boolean isHeartbeat = "heartbeat".equals(eventName);
// Stamp last activity for stuck detection. Heartbeats are excluded
// because they fire on a timer regardless of model progress; counting
// them would mask a wedged turn behind a healthy timestamp.
if (state != null && !isHeartbeat) {
state.lastEventAt = System.currentTimeMillis();
}
if (isDone || isAsyncTask) {
if (state == null) return;
synchronized (state.lock) {
long id = ++state.nextEventId;
SseEvent ev = new SseEvent(id, eventName, jsonData);
state.buffer.add(ev);
if (state.buffer.size() > MAX_BUFFER_SIZE) {
trimBuffer(state.buffer);
}
Iterator
* {
* "kind": "tool_result",
* "scope": "parent", // sub-agent producers will set "subagent"
* "ref": "<refKey>",
* "seq": <0..N>,
* "final": <true|false>,
* "delta": "<text>"
* }
*
* The last chunk has {@code "final": true}; consumers reassemble by
* concatenating {@code delta} in seq order keyed on {@code ref}. When the
* payload's {@code result} field cannot be located (or chunked transport
* is disabled), the entire envelope is sent unchanged.
*
* @param conversationId target conversation
* @param eventName SSE event name for the small-payload path
* @param payload envelope; the {@code result} field (or, failing
* that, the {@code arguments} field) is split
* @param refKey identifier consumers use to group chunks; usually
* {@code toolCallId} or the step index as a string
*/
public void broadcastChunked(String conversationId, String eventName,
Object payload, String refKey) {
String json;
try {
json = objectMapper.writeValueAsString(payload);
} catch (Exception e) {
log.warn("Failed to serialize chunked broadcast for event {}: {}",
eventName, e.getMessage());
return;
}
if (!chunkedToolResultsEnabled || json.length() <= CHUNK_SIZE) {
broadcast(conversationId, eventName, json);
return;
}
// Find a long string field worth splitting; tool results live under
// "result", approval payloads under "arguments". Falling back to the
// whole envelope keeps the transport correct even for unknown shapes
// (the consumer can still concatenate by ref+seq and decode itself).
Map
*
*/
private static void trimBuffer(List
*
* The callback must tolerate normal doOnError/doOnComplete having raced and saved
* already; the latest commit wins for that conversation.
*/
@PreDestroy
public void onShutdown() {
int active = (int) runs.values().stream().filter(s -> !s.done).count();
if (active == 0) {
log.info("[ChatStreamTracker] Shutdown: no active runs to flush");
return;
}
log.warn("[ChatStreamTracker] Shutdown: flushing {} active run(s) before JVM exit",
active);
for (Map.Entry