Files
pipelines/app/lib/features/chat/domain/chat_transcript.dart
T

414 lines
14 KiB
Dart

import '../../../core/api_gateway.dart';
/// Merge chronological history pages by message id. Incoming authoritative
/// copies replace held copies without changing their order; cursor is opaque.
JsonMap mergeChatHistory(JsonMap previous, JsonMap page, {bool older = false}) {
final held = (previous['messages'] as List? ?? const [])
.whereType<Map>()
.map((m) => Map<String, dynamic>.from(m))
.toList();
final incoming = (page['messages'] as List? ?? const [])
.whereType<Map>()
.map((m) => Map<String, dynamic>.from(m))
.toList();
final latest = <Object, JsonMap>{};
for (final message in incoming) {
if (message['id'] != null) latest[message['id']] = message;
}
final combined = older ? [...incoming, ...held] : [...held, ...incoming];
final seen = <Object>{};
final messages = <JsonMap>[];
for (final message in combined) {
final id = message['id'];
if (id != null && !seen.add(id)) continue;
messages.add(id == null ? message : latest[id] ?? message);
}
return {
'messages': messages,
'nextCursor': '${page['nextCursor'] ?? ''}',
'hasMore': page['hasMore'] == true,
'loaded': true,
'loading': false,
};
}
/// Replaces a transcript that opened from this visit's cached copy with the
/// newest authoritative page.
///
/// [held] is what the view shows: the cached messages plus anything a live
/// frame or a local send added or changed since the conversation reopened.
/// [untouchedCached] names the cached messages nothing has changed since; they
/// are not evidence of the current state, so the page alone decides whether
/// they still exist. The page's messages lead in its order with its copies
/// winning, then live arrivals the page does not hold yet follow in their own
/// order, so a frame received during the read is never dropped.
JsonMap refreshCachedChatHistory(
List<JsonMap> held,
JsonMap page,
Set<Object> untouchedCached,
) {
final live = [
for (final message in held)
if (message['id'] == null || !untouchedCached.contains(message['id']))
message,
];
return mergeChatHistory({'messages': live}, page, older: true);
}
/// Consecutive assistant messages form one answer turn. All part fields (also
/// future/unknown protocol types) are preserved in original order.
///
/// `key` is the turn's first assistant message id, which is only a display
/// anchor: paging an older assistant message into the turn changes it, so widget
/// identity uses `messageIds`. That list carries every message the folded turn
/// currently holds so the view can keep the same row element while the turn
/// grows at either end.
///
/// A recorded activity sequence is not an answer bubble. Parts whose `type` is
/// `activity` or `compaction` are lifted out of the turn and collapse into one
/// `activity` row before it, carrying the recorded records, the web wording for
/// the latest record and that record's lifecycle state. Several updates of one
/// compaction are therefore one line, never one line per update.
///
/// [trailing] rows are conversation cards (permission requests and questions),
/// not messages. They keep the server's order after the transcript, the way the
/// web renders approvals and forms at the end of the conversation.
List<JsonMap> transcriptRows(
List<JsonMap> messages, {
List<JsonMap> trailing = const [],
bool running = false,
bool awaitingResponse = false,
String? liveMessageId,
}) {
final rows = <JsonMap>[];
String? key;
String model = '';
final ids = <String>[];
final parts = <JsonMap>[];
final activity = <JsonMap>[];
String? activityKey;
void flush() {
if (activity.isNotEmpty) {
final latest = activity.last;
rows.add({
'kind': 'activity',
'key': activityKey == null ? '' : 'chat-activity-$activityKey',
'records': List<JsonMap>.of(activity),
'label': chatActivityLabel(latest),
'state': chatActivityState(latest).toLowerCase(),
});
}
if (key != null && parts.isNotEmpty) {
rows.add({
'kind': 'assistant',
'key': key,
'messageIds': List<String>.of(ids),
'parts': List<JsonMap>.of(parts),
// The model that answered, as the server recorded it on the reply.
if (model.isNotEmpty) 'model': model,
});
}
key = null;
model = '';
ids.clear();
parts.clear();
activity.clear();
activityKey = null;
}
for (final message in messages) {
if (message['role'] == 'assistant') {
final id = '${message['id'] ?? ''}'.trim();
key ??= id;
final recorded = '${message['model'] ?? ''}'.trim();
if (recorded.isNotEmpty) model = recorded;
if (id.isNotEmpty) ids.add(id);
for (final part in (message['parts'] as List? ?? const [])) {
if (part is! Map) continue;
final record = Map<String, dynamic>.from(part);
if (chatActivityType(record)) {
activityKey ??= id.isEmpty ? null : id;
activity.add(record);
} else {
parts.add(record);
}
}
} else {
flush();
rows.add({'kind': 'user', 'key': message['id'], 'message': message});
}
}
flush();
// Prefer the assistant identity that actually streamed: a queued follow-up
// can be later in the transcript while this same reply is still arriving.
// Before a first delta, do not reopen an older reply behind a new user turn.
final streamingId =
liveMessageId ??
(messages.isNotEmpty && messages.last['role'] == 'assistant'
? '${messages.last['id'] ?? ''}'
: null);
var hasStreamingRow = false;
if (running && streamingId != null) {
for (final row in rows.reversed) {
if (row['kind'] == 'assistant' &&
(row['messageIds'] as List).contains(streamingId)) {
row['streaming'] = true;
hasStreamingRow = true;
break;
}
}
}
// Display-only response shell: never inserted into stored message history.
// A queued follow-up does not create a second shell beside the active reply.
if (!hasStreamingRow && (running || awaitingResponse)) {
rows.add({
'kind': 'assistant',
'key': 'chat-pending-response',
'messageIds': <String>[],
'parts': <JsonMap>[],
'streaming': true,
});
}
rows.addAll(trailing);
return rows;
}
/// Whether [part] is a recorded activity record rather than answer content.
///
/// Both spellings occur: `compaction` is the native lifecycle record and
/// `activity` is a generic sequence entry whose [chatActivityKind] carries the
/// concrete kind.
bool chatActivityType(JsonMap part) {
final type = '${part['type'] ?? ''}'.trim().toLowerCase();
return type == 'activity' || type == 'compaction';
}
/// The record's kind, or the part type when the record does not name one.
String chatActivityKind(JsonMap record) {
final kind = '${record['kind'] ?? ''}'.trim();
if (kind.isNotEmpty) return kind;
return '${record['type'] ?? ''}'.trim();
}
/// The record's lifecycle state, exactly as recorded (may be blank).
String chatActivityState(JsonMap record) {
for (final field in const ['state', 'status', 'lifecycle']) {
final value = '${record[field] ?? ''}'.trim();
if (value.isNotEmpty) return value;
}
return '';
}
/// The web's `Compacting context…` phase words. Both this activity line and the
/// local compaction notice use this one constant, so their wording cannot drift.
const String chatCompactionPhaseLabel = 'Compacting context…';
/// The running-phase words shared verbatim with the web's `turnPhaseLabel`.
/// The web clears a compaction on completion/failure, so there is no web copy
/// for a terminal record: those keep the label the server recorded.
const _chatActivityRunningWords = <String, String>{
'compaction': chatCompactionPhaseLabel,
'thinking': 'Thinking…',
'tool': 'Running a tool…',
'waiting': 'Waiting…',
};
/// The one line for a recorded activity record.
///
/// A running kind with a web phase word uses that exact wording. Otherwise the
/// server's recorded [record] label wins, including for an unknown kind; with
/// no label the recorded kind and state are kept verbatim rather than inventing
/// copy. Nothing is inferred from text the model wrote.
String chatActivityLabel(JsonMap record) {
final kind = chatActivityKind(record);
final state = chatActivityState(record);
if (state.toLowerCase() == 'running') {
final known = _chatActivityRunningWords[kind.toLowerCase()];
if (known != null) return known;
}
final recorded = '${record['label'] ?? ''}'.trim();
if (recorded.isNotEmpty) return recorded;
if (kind.isEmpty) return state.isEmpty ? 'Activity' : state;
return state.isEmpty ? kind : '$kind · $state';
}
/// Replace a local optimistic user row when its server echo identifies the
/// same operation/native message; otherwise append once by authoritative id.
List<JsonMap> reconcileChatUser(List<JsonMap> messages, JsonMap remote) {
final operation = remote['operation_id'];
final nativeId = remote['native_message_id'];
final id = remote['id'];
final index = messages.indexWhere(
(message) =>
(operation != null && message['operation_id'] == operation) ||
(nativeId != null && message['native_message_id'] == nativeId) ||
(id != null && message['id'] == id),
);
if (index < 0) return [...messages, remote];
final result = List<JsonMap>.of(messages);
result[index] = remote;
return result;
}
/// Fold a live chat frame into an immutable thread snapshot. Text and reasoning
/// deltas append by part id, tool snapshots merge without dropping prior fields,
/// and step frames update turn activity. Frames for another session are ignored.
JsonMap applyChatEvent(JsonMap thread, JsonMap frame) {
final session = thread['sessionId'];
if (session != null &&
frame['session_id'] != null &&
session != frame['session_id']) {
return thread;
}
final messages = (thread['messages'] as List? ?? const [])
.whereType<Map>()
.map((m) => Map<String, dynamic>.from(m))
.toList();
final kind = frame['kind'];
if (kind == 'user') {
final part = frame['part'];
final text = part is Map ? part['text'] : null;
final id = frame['message_id'];
if (text is! String ||
text.isEmpty ||
id == null ||
messages.any(
(m) =>
m['id'] == id ||
m['native_message_id'] == id ||
(frame['operation_id'] != null &&
m['operation_id'] == frame['operation_id']),
)) {
return thread;
}
messages.add({
'id': id,
'session_id': frame['session_id'],
'role': 'user',
'client': frame['client'],
'operation_id': frame['operation_id'],
'parts': [
{'type': 'text', 'text': text},
...(frame['attachments'] is List
? frame['attachments'] as List
: const []),
],
});
return {...thread, 'messages': messages};
}
if (kind == 'text' || kind == 'reasoning' || kind == 'tool') {
final incoming = frame['part'];
if (incoming is! Map || incoming['id'] == null) return thread;
final messageId = frame['message_id'];
var index = messages.indexWhere(
(m) => m['id'] == messageId && m['role'] == 'assistant',
);
if (index < 0) {
messages.add({
'id': messageId,
'session_id': frame['session_id'],
'role': 'assistant',
'parts': <JsonMap>[],
});
index = messages.length - 1;
}
final message = messages[index];
final parts = (message['parts'] as List? ?? const [])
.whereType<Map>()
.map((p) => Map<String, dynamic>.from(p))
.toList();
final partIndex = parts.indexWhere(
(p) => p['id'] == incoming['id'] && p['type'] == kind,
);
if (kind == 'text' || kind == 'reasoning') {
final delta = frame['delta'];
if (delta is! String || delta.isEmpty) return thread;
if (partIndex < 0) {
parts.add({'type': kind, 'id': incoming['id'], 'text': delta});
} else {
parts[partIndex] = {
...parts[partIndex],
'text': '${parts[partIndex]['text'] ?? ''}$delta',
};
}
} else if (partIndex < 0) {
parts.add(Map<String, dynamic>.from(incoming));
} else {
final merged = {
...parts[partIndex],
...Map<String, dynamic>.from(incoming),
};
if (parts[partIndex]['state'] is Map && incoming['state'] is Map) {
merged['state'] = {
...Map<String, dynamic>.from(parts[partIndex]['state'] as Map),
...Map<String, dynamic>.from(incoming['state'] as Map),
};
}
parts[partIndex] = merged;
}
messages[index] = {...message, 'parts': parts};
return {...thread, 'messages': messages, 'running': true};
}
if (kind == 'step' && frame['step'] is Map) {
final step = frame['step'] as Map;
if (step['intermediate'] == true) return thread;
return {
...thread,
'running': step['status'] != 'ended',
'nativeTurnId': step['status'] == 'ended'
? ''
: (step['turn_id'] ?? thread['nativeTurnId'] ?? ''),
};
}
return thread;
}
/// Queue serialized sends per session; operation ids survive retries/replays.
class QueuedChatSend {
QueuedChatSend({
required this.operationId,
required this.text,
this.files = const [],
});
final String operationId;
final String text;
final List<String> files;
/// Retry the same immutable intent with the same idempotency key.
QueuedChatSend retry() => QueuedChatSend(
operationId: operationId,
text: text,
files: List.unmodifiable(files),
);
}
class ChatSendQueue {
final Map<String, List<QueuedChatSend>> _sessions = {};
List<QueuedChatSend> forSession(String sessionId) =>
List.unmodifiable(_sessions[sessionId] ?? const []);
bool enqueue(String sessionId, QueuedChatSend send) {
final queue = _sessions.putIfAbsent(sessionId, () => []);
if (queue.any((item) => item.operationId == send.operationId)) return false;
queue.add(send);
return true;
}
QueuedChatSend? takeNext(String sessionId) {
final queue = _sessions[sessionId];
if (queue == null || queue.isEmpty) return null;
final result = queue.removeAt(0);
if (queue.isEmpty) _sessions.remove(sessionId);
return result;
}
}
/// The model of the latest stored reply, or empty when none recorded one.
String latestReplyModel(List<JsonMap> messages) {
for (final message in messages.reversed) {
if (message['role'] != 'assistant') continue;
final model = '${message['model'] ?? ''}'.trim();
if (model.isNotEmpty) return model;
}
return '';
}