第1708篇：事件溯源（Event Sourcing）在AI对话系统中的应用
2026/4/30大约 11 分钟
第1708篇：事件溯源（Event Sourcing）在AI对话系统中的应用
有个问题困扰了我很久：为什么AI对话的历史那么难追溯？
用户说"你之前说过……"，你去查数据库，发现只有最终的对话内容，看不出AI当时的配置、用的什么模型版本、那次对话是不是因为模型升级导致行为变了。出了问题要复现，几乎不可能。
我在一个产品化AI助手项目里遇到了这个问题。用户反馈AI的回答"变了"，但我们根本无法验证，因为数据库只存了对话内容，丢失了大量上下文信息。
这促使我研究事件溯源（Event Sourcing）在AI系统里的应用。这个模式在金融系统里很成熟，用在AI对话系统里有一些独特的价值，也有一些需要适配的地方。今天来聊透这个话题。
一、什么是事件溯源，为什么AI系统需要它
传统存储方式：只存当前状态。对话结束后，数据库里有一个对话记录，一堆消息记录。你能看到"说了什么"，但看不到"发生了什么"。
事件溯源：存储导致状态变化的每一个事件。对话的当前状态，是重放所有事件后的结果。
对AI对话系统来说，值得记录的事件包括：
- 用户发送消息
- AI模型被调用（参数是什么）
- AI返回了响应（哪个模型、哪个版本、用了多少token）
- 用户对AI响应进行了评分
- 系统Prompt被修改
- 模型配置被切换
- 工具被调用及其结果
- 对话被分支/合并（某些高级对话系统有此功能）
存了这些事件之后，你可以：
- 完整回放任何一次对话，包括当时的上下文
- 分析AI行为变化：同样的问题，升级模型前后答案有什么不同
- 调试生产问题：还原用户遇到问题时的完整现场
- 审计合规：知道某个响应是由哪个模型版本在哪个配置下生成的
二、事件体系设计
先设计事件的类型体系。用上前面讲的密封类：
// 所有AI对话事件的基接口
public sealed interface ConversationEvent
permits ConversationEvent.SessionCreated,
ConversationEvent.MessageSent,
ConversationEvent.AIResponseReceived,
ConversationEvent.ToolCallExecuted,
ConversationEvent.SessionConfigChanged,
ConversationEvent.ModelSwitched,
ConversationEvent.MessageDeleted,
ConversationEvent.SessionArchived,
ConversationEvent.FeedbackGiven {
// 所有事件共有的字段
String eventId();
String sessionId();
String userId();
Instant occurredAt();
String eventType();
// === 事件类型 ===
// 会话创建
record SessionCreated(
String eventId,
String sessionId,
String userId,
Instant occurredAt,
String title,
String modelName,
String systemPrompt,
SessionConfig initialConfig
) implements ConversationEvent {
@Override public String eventType() { return "SESSION_CREATED"; }
}
// 用户发送消息
record MessageSent(
String eventId,
String sessionId,
String userId,
Instant occurredAt,
String messageId,
String content,
MessageType messageType, // TEXT, IMAGE, FILE, VOICE
Map<String, Object> attachments
) implements ConversationEvent {
@Override public String eventType() { return "MESSAGE_SENT"; }
public enum MessageType { TEXT, IMAGE, FILE, VOICE }
}
// AI响应接收
record AIResponseReceived(
String eventId,
String sessionId,
String userId,
Instant occurredAt,
String messageId,
String content,
String modelName,
String modelVersion,
int promptTokens,
int completionTokens,
long latencyMs,
String finishReason,
Double temperature,
Integer maxTokens,
boolean fromCache
) implements ConversationEvent {
@Override public String eventType() { return "AI_RESPONSE_RECEIVED"; }
public int totalTokens() { return promptTokens + completionTokens; }
public boolean isNormalStop() { return "stop".equals(finishReason); }
}
// 工具调用执行
record ToolCallExecuted(
String eventId,
String sessionId,
String userId,
Instant occurredAt,
String toolCallId,
String toolName,
Map<String, Object> arguments,
String result,
boolean success,
long executionMs
) implements ConversationEvent {
@Override public String eventType() { return "TOOL_CALL_EXECUTED"; }
}
// 会话配置变更
record SessionConfigChanged(
String eventId,
String sessionId,
String userId,
Instant occurredAt,
SessionConfig previousConfig,
SessionConfig newConfig,
String changeReason
) implements ConversationEvent {
@Override public String eventType() { return "SESSION_CONFIG_CHANGED"; }
}
// 模型切换
record ModelSwitched(
String eventId,
String sessionId,
String userId,
Instant occurredAt,
String previousModel,
String newModel,
String switchReason
) implements ConversationEvent {
@Override public String eventType() { return "MODEL_SWITCHED"; }
}
// 用户反馈
record FeedbackGiven(
String eventId,
String sessionId,
String userId,
Instant occurredAt,
String targetMessageId,
FeedbackType feedbackType,
String comment
) implements ConversationEvent {
@Override public String eventType() { return "FEEDBACK_GIVEN"; }
public enum FeedbackType { THUMBS_UP, THUMBS_DOWN, REPORT }
}
// 消息删除
record MessageDeleted(
String eventId,
String sessionId,
String userId,
Instant occurredAt,
String messageId,
String deletedBy,
String reason
) implements ConversationEvent {
@Override public String eventType() { return "MESSAGE_DELETED"; }
}
// 会话归档
record SessionArchived(
String eventId,
String sessionId,
String userId,
Instant occurredAt,
String reason
) implements ConversationEvent {
@Override public String eventType() { return "SESSION_ARCHIVED"; }
}
}三、事件存储层
事件存储（Event Store）是事件溯源的核心。它只支持追加（append-only），不支持修改或删除：
// 事件存储接口
public interface EventStore {
// 追加单个事件
void append(ConversationEvent event);
// 批量追加（同一个会话的多个事件，保证原子性）
void appendBatch(List<ConversationEvent> events);
// 读取会话的所有事件（按时间顺序）
List<ConversationEvent> readAll(String sessionId);
// 读取指定时间之后的事件
List<ConversationEvent> readAfter(String sessionId, Instant after);
// 读取最后N个事件
List<ConversationEvent> readLast(String sessionId, int n);
// 获取事件总数（用于版本号）
long getEventCount(String sessionId);
}
// 基于MySQL的事件存储实现
@Repository
public class MysqlEventStore implements EventStore {
private final JdbcTemplate jdbc;
private final ObjectMapper objectMapper;
// 事件表结构：
// CREATE TABLE conversation_events (
// id VARCHAR(36) PRIMARY KEY,
// session_id VARCHAR(36) NOT NULL,
// user_id VARCHAR(36) NOT NULL,
// event_type VARCHAR(100) NOT NULL,
// event_data JSON NOT NULL,
// occurred_at DATETIME(3) NOT NULL,
// sequence_num BIGINT NOT NULL AUTO_INCREMENT,
// INDEX idx_session_id_seq (session_id, sequence_num)
// )
@Override
public void append(ConversationEvent event) {
String sql = """
INSERT INTO conversation_events
(id, session_id, user_id, event_type, event_data, occurred_at)
VALUES (?, ?, ?, ?, ?, ?)
""";
jdbc.update(sql,
event.eventId(),
event.sessionId(),
event.userId(),
event.eventType(),
serializeEvent(event),
Timestamp.from(event.occurredAt())
);
}
@Override
public void appendBatch(List<ConversationEvent> events) {
String sql = """
INSERT INTO conversation_events
(id, session_id, user_id, event_type, event_data, occurred_at)
VALUES (?, ?, ?, ?, ?, ?)
""";
jdbc.batchUpdate(sql, events.stream()
.map(e -> new Object[]{
e.eventId(),
e.sessionId(),
e.userId(),
e.eventType(),
serializeEvent(e),
Timestamp.from(e.occurredAt())
})
.toList()
);
}
@Override
public List<ConversationEvent> readAll(String sessionId) {
String sql = """
SELECT event_type, event_data FROM conversation_events
WHERE session_id = ?
ORDER BY sequence_num ASC
""";
return jdbc.query(sql, (rs, rowNum) ->
deserializeEvent(rs.getString("event_type"), rs.getString("event_data")),
sessionId
);
}
@Override
public List<ConversationEvent> readAfter(String sessionId, Instant after) {
String sql = """
SELECT event_type, event_data FROM conversation_events
WHERE session_id = ? AND occurred_at > ?
ORDER BY sequence_num ASC
""";
return jdbc.query(sql, (rs, rowNum) ->
deserializeEvent(rs.getString("event_type"), rs.getString("event_data")),
sessionId, Timestamp.from(after)
);
}
private String serializeEvent(ConversationEvent event) {
try {
return objectMapper.writeValueAsString(event);
} catch (JsonProcessingException e) {
throw new EventSerializationException("事件序列化失败", e);
}
}
private ConversationEvent deserializeEvent(String eventType, String eventData) {
try {
Class<? extends ConversationEvent> targetClass = switch (eventType) {
case "SESSION_CREATED" -> ConversationEvent.SessionCreated.class;
case "MESSAGE_SENT" -> ConversationEvent.MessageSent.class;
case "AI_RESPONSE_RECEIVED" -> ConversationEvent.AIResponseReceived.class;
case "TOOL_CALL_EXECUTED" -> ConversationEvent.ToolCallExecuted.class;
case "SESSION_CONFIG_CHANGED" -> ConversationEvent.SessionConfigChanged.class;
case "MODEL_SWITCHED" -> ConversationEvent.ModelSwitched.class;
case "FEEDBACK_GIVEN" -> ConversationEvent.FeedbackGiven.class;
case "MESSAGE_DELETED" -> ConversationEvent.MessageDeleted.class;
case "SESSION_ARCHIVED" -> ConversationEvent.SessionArchived.class;
default -> throw new UnknownEventTypeException("未知事件类型: " + eventType);
};
return objectMapper.readValue(eventData, targetClass);
} catch (JsonProcessingException e) {
throw new EventDeserializationException("事件反序列化失败: " + eventType, e);
}
}
@Override
public long getEventCount(String sessionId) {
return jdbc.queryForObject(
"SELECT COUNT(*) FROM conversation_events WHERE session_id = ?",
Long.class,
sessionId
);
}
@Override
public List<ConversationEvent> readLast(String sessionId, int n) {
String sql = """
SELECT event_type, event_data FROM conversation_events
WHERE session_id = ?
ORDER BY sequence_num DESC
LIMIT ?
""";
List<ConversationEvent> reversed = jdbc.query(sql, (rs, rowNum) ->
deserializeEvent(rs.getString("event_type"), rs.getString("event_data")),
sessionId, n
);
// 反转顺序（因为查询用的是DESC）
Collections.reverse(reversed);
return reversed;
}
}四、聚合：从事件重建对话状态
事件溯源里，"聚合"（Aggregate）是从事件序列重建出当前状态的对象：
// 对话会话聚合
public class ConversationSessionAggregate {
// 当前状态
private String id;
private String userId;
private String title;
private String modelName;
private String systemPrompt;
private SessionConfig currentConfig;
private String status;
private int totalTurns;
private int totalTokens;
private List<MessageSummary> messages;
private Instant createdAt;
private Instant lastActiveAt;
// 版本号（等于已应用的事件数）
private long version;
// 重放所有事件重建状态
public static ConversationSessionAggregate rebuild(List<ConversationEvent> events) {
ConversationSessionAggregate aggregate = new ConversationSessionAggregate();
aggregate.messages = new ArrayList<>();
for (ConversationEvent event : events) {
aggregate.apply(event);
}
return aggregate;
}
// 应用单个事件（修改状态）
private void apply(ConversationEvent event) {
switch (event) {
case ConversationEvent.SessionCreated e -> {
this.id = e.sessionId();
this.userId = e.userId();
this.title = e.title();
this.modelName = e.modelName();
this.systemPrompt = e.systemPrompt();
this.currentConfig = e.initialConfig();
this.status = "ACTIVE";
this.totalTurns = 0;
this.totalTokens = 0;
this.createdAt = e.occurredAt();
this.lastActiveAt = e.occurredAt();
}
case ConversationEvent.MessageSent e -> {
messages.add(new MessageSummary(
e.messageId(), "user", e.content(), e.occurredAt()
));
this.lastActiveAt = e.occurredAt();
}
case ConversationEvent.AIResponseReceived e -> {
messages.add(new MessageSummary(
e.messageId(), "assistant", e.content(), e.occurredAt()
));
this.totalTurns++;
this.totalTokens += e.totalTokens();
this.modelName = e.modelName(); // 可能在运行中切换了模型
this.lastActiveAt = e.occurredAt();
}
case ConversationEvent.SessionConfigChanged e -> {
this.currentConfig = e.newConfig();
this.lastActiveAt = e.occurredAt();
}
case ConversationEvent.ModelSwitched e -> {
this.modelName = e.newModel();
this.lastActiveAt = e.occurredAt();
}
case ConversationEvent.MessageDeleted e -> {
messages.removeIf(m -> m.messageId().equals(e.messageId()));
}
case ConversationEvent.SessionArchived e -> {
this.status = "ARCHIVED";
}
// FeedbackGiven 和 ToolCallExecuted 不修改会话主状态
default -> {}
}
this.version++;
}
// 获取只读的消息列表
public List<MessageSummary> getMessages() {
return Collections.unmodifiableList(messages);
}
// 获取对话历史（用于发送给LLM的上下文）
public List<String[]> getChatHistory() {
return messages.stream()
.map(m -> new String[]{m.role(), m.content()})
.toList();
}
// 各种只读访问器
public String getId() { return id; }
public String getUserId() { return userId; }
public String getModelName() { return modelName; }
public SessionConfig getCurrentConfig() { return currentConfig; }
public int getTotalTurns() { return totalTurns; }
public int getTotalTokens() { return totalTokens; }
public long getVersion() { return version; }
public boolean isActive() { return "ACTIVE".equals(status); }
public record MessageSummary(
String messageId,
String role,
String content,
Instant timestamp
) {}
}五、Service层：事件驱动的业务逻辑
@Service
public class EventSourcedConversationService {
private final EventStore eventStore;
private final ChatClient chatClient;
private final ApplicationEventPublisher eventPublisher; // Spring事件发布
@Transactional
public ConversationEvent.SessionCreated createSession(
String userId, String title, String systemPrompt, SessionConfig config) {
String sessionId = UUID.randomUUID().toString();
ConversationEvent.SessionCreated event = new ConversationEvent.SessionCreated(
UUID.randomUUID().toString(),
sessionId,
userId,
Instant.now(),
title,
config.modelOverride() != null ? config.modelOverride() : "gpt-4o",
systemPrompt,
config
);
eventStore.append(event);
// 发布Spring事件，供其他组件（如通知、统计）使用
eventPublisher.publishEvent(event);
return event;
}
@Transactional
public ConversationEvent.AIResponseReceived sendMessage(
String sessionId, String userId, String userContent) {
// 1. 从事件重建当前状态
List<ConversationEvent> allEvents = eventStore.readAll(sessionId);
ConversationSessionAggregate session = ConversationSessionAggregate.rebuild(allEvents);
if (!session.isActive()) {
throw new SessionNotActiveException(sessionId);
}
// 2. 记录用户消息事件
String userMessageId = UUID.randomUUID().toString();
ConversationEvent.MessageSent userMessageEvent = new ConversationEvent.MessageSent(
UUID.randomUUID().toString(),
sessionId, userId, Instant.now(),
userMessageId, userContent,
ConversationEvent.MessageSent.MessageType.TEXT,
Map.of()
);
eventStore.append(userMessageEvent);
// 3. 调用AI（使用聚合中重建的历史作为上下文）
long startTime = System.currentTimeMillis();
ChatResponse response = chatClient.prompt()
.system(session.getSystemPromptIfNotNull())
.messages(buildMessages(session.getMessages(), userContent))
.call()
.chatResponse();
long latency = System.currentTimeMillis() - startTime;
// 4. 记录AI响应事件（包含完整的调用信息）
int promptTokens = response.getMetadata().getUsage().getPromptTokens().intValue();
int completionTokens = response.getMetadata().getUsage().getCompletionTokens().intValue();
ConversationEvent.AIResponseReceived responseEvent = new ConversationEvent.AIResponseReceived(
UUID.randomUUID().toString(),
sessionId, userId, Instant.now(),
UUID.randomUUID().toString(),
response.getResult().getOutput().getContent(),
session.getModelName(),
"2024-11-01", // 模型版本，实际从配置获取
promptTokens,
completionTokens,
latency,
response.getResult().getMetadata().getFinishReason(),
session.getCurrentConfig().temperatureOverride(),
session.getCurrentConfig().maxTokensOverride(),
false
);
eventStore.append(responseEvent);
// 5. 发布事件
eventPublisher.publishEvent(responseEvent);
return responseEvent;
}
// 重放对话（用于调试和复现）
public ConversationReplayResult replaySession(String sessionId) {
List<ConversationEvent> events = eventStore.readAll(sessionId);
ConversationSessionAggregate aggregate = ConversationSessionAggregate.rebuild(events);
return new ConversationReplayResult(
sessionId,
events.size(),
aggregate,
buildEventTimeline(events)
);
}
// 查询特定时间点的会话状态（时间穿越）
public ConversationSessionAggregate getStateAt(String sessionId, Instant pointInTime) {
List<ConversationEvent> events = eventStore.readAll(sessionId);
List<ConversationEvent> eventsUntilThen = events.stream()
.filter(e -> !e.occurredAt().isAfter(pointInTime))
.toList();
return ConversationSessionAggregate.rebuild(eventsUntilThen);
}
private List<String[]> buildEventTimeline(List<ConversationEvent> events) {
return events.stream()
.map(e -> new String[]{
e.occurredAt().toString(),
e.eventType(),
describeEvent(e)
})
.toList();
}
private String describeEvent(ConversationEvent event) {
return switch (event) {
case ConversationEvent.SessionCreated e -> "会话创建，模型: " + e.modelName();
case ConversationEvent.MessageSent e -> "用户消息: " + truncate(e.content(), 50);
case ConversationEvent.AIResponseReceived e ->
"AI响应(" + e.modelName() + "): " + truncate(e.content(), 50) +
"，tokens: " + e.totalTokens();
case ConversationEvent.ModelSwitched e ->
"模型切换: " + e.previousModel() + " → " + e.newModel();
case ConversationEvent.FeedbackGiven e ->
"用户反馈: " + e.feedbackType();
default -> event.eventType();
};
}
private String truncate(String s, int max) {
return s.length() > max ? s.substring(0, max) + "..." : s;
}
public record ConversationReplayResult(
String sessionId,
int totalEvents,
ConversationSessionAggregate currentState,
List<String[]> eventTimeline
) {}
}六、快照优化：避免每次都重放全量事件
当一个会话有几百条消息时，每次操作都重放全量事件会变慢。快照（Snapshot）机制可以解决这个问题：
@Service
public class SnapshotService {
private final EventStore eventStore;
private final SnapshotRepository snapshotRepository;
private static final int SNAPSHOT_INTERVAL = 50; // 每50个事件创建一次快照
// 加载聚合（优先用快照）
public ConversationSessionAggregate load(String sessionId) {
// 尝试加载最近的快照
Optional<AggregateSnapshot> snapshot = snapshotRepository.findLatest(sessionId);
if (snapshot.isPresent()) {
AggregateSnapshot snap = snapshot.get();
ConversationSessionAggregate aggregate = snap.aggregate();
// 只重放快照之后的事件
List<ConversationEvent> newEvents = eventStore.readAfter(
sessionId, snap.snapshotAt()
);
// 应用新事件
for (ConversationEvent event : newEvents) {
// 通过反射或者暴露package-private方法应用事件
aggregate.applyEvent(event);
}
return aggregate;
}
// 没有快照，重放全量事件
List<ConversationEvent> allEvents = eventStore.readAll(sessionId);
return ConversationSessionAggregate.rebuild(allEvents);
}
// 检查是否需要创建快照
public void maybeCreateSnapshot(String sessionId, ConversationSessionAggregate aggregate) {
if (aggregate.getVersion() % SNAPSHOT_INTERVAL == 0) {
createSnapshot(sessionId, aggregate);
}
}
private void createSnapshot(String sessionId, ConversationSessionAggregate aggregate) {
AggregateSnapshot snapshot = new AggregateSnapshot(
UUID.randomUUID().toString(),
sessionId,
aggregate.getVersion(),
Instant.now(),
aggregate
);
snapshotRepository.save(snapshot);
log.info("会话{}创建快照，版本{}", sessionId, aggregate.getVersion());
}
public record AggregateSnapshot(
String id,
String sessionId,
long version,
Instant snapshotAt,
ConversationSessionAggregate aggregate
) {}
}七、投影：从事件生成不同的视图
事件溯源的另一个好处：可以从同一组事件生成多种不同的"投影"（Projection），满足不同的查询需求。
// Token消耗投影
@Service
public class TokenUsageProjection {
private final EventStore eventStore;
public TokenUsageSummary buildForSession(String sessionId) {
List<ConversationEvent> events = eventStore.readAll(sessionId);
int totalPromptTokens = 0;
int totalCompletionTokens = 0;
Map<String, Integer> tokensByModel = new HashMap<>();
long totalLatencyMs = 0;
int responseCount = 0;
for (ConversationEvent event : events) {
if (event instanceof ConversationEvent.AIResponseReceived r) {
totalPromptTokens += r.promptTokens();
totalCompletionTokens += r.completionTokens();
tokensByModel.merge(r.modelName(), r.totalTokens(), Integer::sum);
totalLatencyMs += r.latencyMs();
responseCount++;
}
}
return new TokenUsageSummary(
sessionId,
totalPromptTokens,
totalCompletionTokens,
tokensByModel,
responseCount > 0 ? (double) totalLatencyMs / responseCount : 0,
responseCount
);
}
public record TokenUsageSummary(
String sessionId,
int totalPromptTokens,
int totalCompletionTokens,
Map<String, Integer> tokensByModel,
double avgLatencyMs,
int responseCount
) {
public int totalTokens() { return totalPromptTokens + totalCompletionTokens; }
// 按GPT-4o定价估算成本（美元）
public double estimatedCostUSD() {
return totalPromptTokens * 0.000005 + totalCompletionTokens * 0.000015;
}
}
}
// 质量指标投影
@Service
public class QualityMetricsProjection {
private final EventStore eventStore;
public QualityMetrics buildForSession(String sessionId) {
List<ConversationEvent> events = eventStore.readAll(sessionId);
int thumbsUp = 0;
int thumbsDown = 0;
int reports = 0;
List<String> reportedMessageIds = new ArrayList<>();
for (ConversationEvent event : events) {
if (event instanceof ConversationEvent.FeedbackGiven f) {
switch (f.feedbackType()) {
case THUMBS_UP -> thumbsUp++;
case THUMBS_DOWN -> thumbsDown++;
case REPORT -> {
reports++;
reportedMessageIds.add(f.targetMessageId());
}
}
}
}
int total = thumbsUp + thumbsDown;
double satisfactionRate = total > 0 ? (double) thumbsUp / total : -1;
return new QualityMetrics(sessionId, thumbsUp, thumbsDown, reports,
satisfactionRate, reportedMessageIds);
}
public record QualityMetrics(
String sessionId,
int thumbsUp,
int thumbsDown,
int reports,
double satisfactionRate, // -1表示无反馈数据
List<String> reportedMessageIds
) {}
}八、踩坑经验
坑1：事件JSON的版本兼容问题
事件一旦存入数据库就不能修改（append-only）。如果后来需要改事件的结构，比如加字段，必须保证新版本的代码能正确反序列化老格式的事件。建议：
- 新加字段时给默认值，Jackson的
@JsonSetter(nulls = Nulls.AS_EMPTY)很有用 - 如果结构变化太大，引入新的事件类型，逐步淘汰老类型
- 事件数据中保存schema版本号：
"schemaVersion": "1"
坑2：事件重放性能
我上面提到了快照，但实际落地时要评估：快照的序列化/反序列化本身也有成本，对于消息不多的会话（比如不到50条），直接重放可能比加载快照更快。需要针对你的实际数据量做测试。
坑3：并发写入竞争
多个请求同时向同一个会话写入事件，可能出现顺序错乱。需要在事件表上做乐观锁：
ALTER TABLE conversation_events ADD COLUMN expected_version BIGINT;
-- 插入时检查当前最大版本号是否等于预期版本号
INSERT INTO conversation_events (...)
SELECT ... WHERE
(SELECT COUNT(*) FROM conversation_events WHERE session_id = ?) = expected_version小结
事件溯源在AI对话系统里的核心价值：
- 完整审计：每一次AI调用的参数、模型版本、token消耗都有记录
- 时间穿越：可以查询任意历史时间点的会话状态
- 多视图投影：同一份事件数据，生成不同维度的统计分析
- 问题复现：生产环境的问题可以通过重放事件完整复现
- 模型对比：拿历史事件驱动不同模型，对比输出差异
代价是：存储量增大（每次对话都存大量事件），重建状态需要遍历事件（快照缓解）。在AI系统里，这些代价通常值得付出——尤其是在需要合规审计或者频繁调试模型行为的场景。