import 'dart:collection'; import '../../../core/api_gateway.dart'; import 'chat_task_notices.dart'; import 'chat_transcript.dart'; /// 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. /// /// A message the server marks with a `kind` is content the harness delivered, /// not a turn: an `agent_report` becomes its own `agent_report` row and a /// `notice` its own `system_notice` row, on the agent's side, never folded into /// an answer and never drawn as the operator's bubble (see [chatInjectedKind]). /// Two or more consecutive background-task notices fold into one /// `task_notices` row (see [groupTaskNotices]). /// /// [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. /// /// Rows are values: nothing downstream changes a row in place, which is what /// lets [ChatTranscriptRows] hand out the same rows again. List transcriptRows( List messages, { List trailing = const [], bool running = false, bool awaitingResponse = false, String? liveMessageId, }) => _finish( [for (final segment in _segments(messages)) ..._segmentRows(segment)], messages, trailing: trailing, running: running, awaitingResponse: awaitingResponse, liveMessageId: liveMessageId, ); /// [transcriptRows] for a transcript that changes a little at a time. /// /// The rows of a run of consecutive answer messages, or of one other message, /// depend on those messages alone. Each run's rows are kept while the run holds /// the identical message objects, so a streamed delta (which replaces only the /// live message) rebuilds only the live turn, and a prepended history page /// only the runs it touches. The result equals [transcriptRows] for the same /// arguments; messages must not be changed in place once passed. class ChatTranscriptRows { /// The previous call's runs, by their first message. Map _held = HashMap.identity(); List rows( List messages, { List trailing = const [], bool running = false, bool awaitingResponse = false, String? liveMessageId, }) { final next = HashMap.identity(); final rows = []; for (final messages in _segments(messages)) { final held = _held[messages.first]; final segment = held != null && _sameMessages(held.messages, messages) ? held : _Segment(messages, _segmentRows(messages)); next[messages.first] = segment; rows.addAll(segment.rows); } _held = next; return _finish( rows, messages, trailing: trailing, running: running, awaitingResponse: awaitingResponse, liveMessageId: liveMessageId, ); } static bool _sameMessages(List a, List b) { if (a.length != b.length) return false; for (var index = 0; index < a.length; index++) { if (!identical(a[index], b[index])) return false; } return true; } } class _Segment { _Segment(this.messages, this.rows); final List messages; final List rows; } /// Whether [message] folds into an answer turn with its assistant neighbours. bool _answerPart(JsonMap message) => chatInjectedKind(message) == null && message['role'] == 'assistant'; /// [messages] split into runs whose rows depend on the run alone: each maximal /// run of answer messages, and every other message on its own. List> _segments(List messages) { final segments = >[]; List? answer; for (final message in messages) { if (_answerPart(message)) { if (answer == null) segments.add(answer = []); answer.add(message); } else { answer = null; segments.add([message]); } } return segments; } /// The rows of one run from [_segments]. List _segmentRows(List segment) { final first = segment.first; if (!_answerPart(first)) { final injected = chatInjectedKind(first); if (injected != null) { return [ { 'kind': injected == chatKindAgentReport ? 'agent_report' : 'system_notice', 'key': first['id'], 'message': first, }, ]; } return [ {'kind': 'user', 'key': first['id'], 'message': first}, ]; } final rows = []; String? key; String model = ''; final ids = []; final parts = []; final activity = []; String? activityKey; int? createdAt; for (final message in segment) { final id = '${message['id'] ?? ''}'.trim(); key ??= id; createdAt ??= chatMessageCreatedAt(message); 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.from(part); if (chatActivityType(record)) { activityKey ??= id.isEmpty ? null : id; activity.add(record); } else { parts.add(record); } } } final compactions = activity .where((p) => chatActivityKind(p) == 'compaction') .toList(); final passive = activity .where((p) => chatActivityKind(p) != 'compaction') .toList(); if (compactions.isNotEmpty) { final latest = compactions.last; rows.add({ 'kind': 'activity', 'key': activityKey == null ? '' : 'chat-activity-$activityKey', 'records': compactions, 'label': chatActivityLabel(latest), 'state': chatActivityState(latest).toLowerCase(), }); } if (parts.isNotEmpty || passive.isNotEmpty) { rows.add({ 'kind': 'assistant', 'key': key, 'messageIds': ids, 'parts': parts, if (passive.isNotEmpty) 'activityRecords': passive, // The model that answered, as the server recorded it on the reply. if (model.isNotEmpty) 'model': model, 'created_at': ?createdAt, }); } return rows; } /// The streaming mark, the response shell, task-notice grouping and the /// trailing cards over the transcript's own [rows]. [rows] is not changed: a /// marked row is a copy. List _finish( List rows, List messages, { required List trailing, required bool running, required bool awaitingResponse, required String? liveMessageId, }) { // 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. String? streamingId = liveMessageId; if (streamingId == null) { for (final message in messages.reversed) { if (chatInjectedKind(message) != null) continue; if (message['role'] == 'assistant') { streamingId = '${message['id'] ?? ''}'; } break; } } var marked = rows; var hasStreamingRow = false; if (running && streamingId != null) { for (var index = rows.length - 1; index >= 0; index--) { final row = rows[index]; if (row['kind'] == 'assistant' && (row['messageIds'] as List).contains(streamingId)) { marked = List.of(rows); marked[index] = {...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)) { marked = [ ...marked, { 'kind': 'assistant', 'key': 'chat-pending-response', 'messageIds': [], 'parts': [], 'streaming': true, }, ]; } // Consecutive background-task notices are one collapsed group. return [...groupTaskNotices(marked), ...trailing]; }