Files
pipelines/app/lib/features/chat/ui/transcript/chat_message_view.dart
T
alan 6367cce68a Read chat replies aloud with word highlighting
An assistant reply gets Read aloud beside Copy; while it reads it becomes
Pause/Resume and Stop, one reply at a time app-wide. The spoken word is
highlighted in the rendered reply (across multi-part replies) and the
transcript scrolls only when that word leaves the viewport. Reading stops
when its chat closes or is swapped, another reply starts, or the app goes
to the background. Markdown is spoken as sentences; code blocks are
announced as "Code block.".

Speech goes through a SpeechEngine seam with a flutter_tts implementation
(Android, macOS, web; hidden on Linux) and a fake for tests. Settings has
a Read aloud section: a voice picker grouped by language (device language
first, a sample per voice), a rate slider and reset, saved per device.

flutter_tts has no Swift package, so macOS/iOS gain the CocoaPods
integration (Podfiles with the Runner deployment targets); Android
declares the TTS_SERVICE query. The capture fixture gains ?speech=fake.
2026-11-13 01:29:04 +00:00

428 lines
15 KiB
Dart

import 'dart:convert';
import 'package:flutter/material.dart';
import '../../../../core/api_gateway.dart';
import '../../data/chat_attachment_images.dart';
import 'chat_attachment_gallery.dart';
import '../../domain/chat_tool_calls.dart';
import '../../domain/chat_transcript.dart';
import 'chat_copy_button.dart';
import 'chat_copy_gutter.dart';
import 'chat_link_text.dart';
import 'chat_message_bubble.dart';
import 'chat_turn_activity_view.dart';
import 'native_disclosure.dart';
import 'chat_message_timestamp.dart';
import 'chat_read_aloud_button.dart';
import '../../speech/speech_controller.dart';
/// Builds an assistant text part; the default keeps the server's text exactly.
typedef ChatMessageTextBuilder = Widget Function(BuildContext, String);
/// One `transcriptRows` row: a user message or one folded agent turn. Parts keep
/// order for agent turns; native disclosures retain unknown parts as raw JSON.
class ChatMessageView extends StatelessWidget {
const ChatMessageView({
super.key,
required this.row,
this.textBuilder,
this.footer = const [],
this.images,
this.speechScope = 'chat',
});
final JsonMap row;
/// Names the conversation in the reader's message ids, so leaving it can
/// stop only its own reply (see [speechMessageId]).
final String speechScope;
final ChatMessageTextBuilder? textBuilder;
/// Loads attached images for the operator's turn; without one, only images
/// the history carries inline can draw.
final ChatAttachmentImages? images;
static final ChatAttachmentImages _inlineImages = ChatAttachmentImages(null);
/// Beneath the turn: an agent turn's settled permissions, or the delivery
/// line under the operator's own message.
final List<Widget> footer;
@override
Widget build(BuildContext context) {
final user = row['kind'] == 'user';
final role = user ? 'User' : 'Assistant';
final content = user ? _userParts(context) : _agentParts(context);
// A wide window draws an answer's Copy in the gutter left of the reading
// column; without room it stays at the start of the answer's footer.
final gutter = user ? 0.0 : ChatCopyGutter.of(context);
// No visible role label: side and surface say who spoke and the row's
// semantics label names the role. The operator's turn is a neutral bubble
// that shrinks to its content; the agent's answer sits on the page with no
// bubble, so long replies read as a document rather than a balloon.
final body = DefaultTextStyle.merge(
style: chatMessageTextStyle(context),
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.start,
children: content,
),
);
return Semantics(
container: true,
explicitChildNodes: true,
label: '$role message',
child: Padding(
padding: const EdgeInsets.symmetric(vertical: 6),
child: LayoutBuilder(
builder: (context, constraints) => Align(
alignment: user
? AlignmentDirectional.centerEnd
: AlignmentDirectional.centerStart,
child: ConstrainedBox(
// The operator's turn leaves a margin on a phone, so the two
// sides read as a conversation; the answer keeps a readable
// measure on a wide pane.
constraints: BoxConstraints(
maxWidth: user
? (constraints.maxWidth * 0.85).clamp(0, 560).toDouble()
: 720 + gutter,
),
child: user
? _userTurn(content, body)
: _agentRow(
context,
content,
ChatAgentSurface(child: body),
gutter,
),
),
),
),
),
);
}
Color _secondaryColor(BuildContext context) =>
Theme.of(context).colorScheme.onSurfaceVariant;
JsonMap get _userMessage => row['message'] is Map
? Map<String, dynamic>.from(row['message'] as Map)
: row;
/// Attached images sit above the operator's bubble, as their own thumbnails;
/// an images-only turn draws no empty bubble. The footer (the delivery line)
/// sits under the bubble's trailing corner.
Widget _userTurn(List<Widget> content, Widget body) {
final thumbnails = [
for (final part in _partsOf(_userMessage))
if (_isFile(part) && chatPartIsThumbnail(part)) part,
];
final timestamp = ChatMessageTimestamp(
createdAt: chatMessageCreatedAt(_userMessage),
);
final hasTimestamp = chatMessageCreatedAt(_userMessage) != null;
if (thumbnails.isEmpty && footer.isEmpty && !hasTimestamp) {
return ChatUserBubble(child: body);
}
return Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.end,
children: [
if (thumbnails.isNotEmpty)
ChatAttachmentGallery(
parts: thumbnails,
images: images ?? _inlineImages,
),
if (thumbnails.isNotEmpty && content.isNotEmpty)
const SizedBox(height: 6),
if (content.isNotEmpty || thumbnails.isEmpty)
ChatUserBubble(child: body),
if (footer.isNotEmpty) ...[
const SizedBox(height: 2),
Wrap(
key: const Key('chat-message-footer'),
spacing: 8,
alignment: WrapAlignment.end,
crossAxisAlignment: WrapCrossAlignment.center,
children: footer,
),
],
if (hasTimestamp) ...[const SizedBox(height: 2), timestamp],
],
);
}
List<Widget> _userParts(BuildContext context) {
final message = _userMessage;
final parts = _partsOf(message);
final text = parts
.where((part) => part['type'] == null || part['type'] == 'text')
.map((part) => '${part['text'] ?? ''}')
.join('\n');
final widgets = <Widget>[
if (text.trim().isNotEmpty) ChatLinkText(text),
for (final part in parts.where(_isFile))
if (!chatPartIsThumbnail(part)) _attachment(context, part),
for (final part in parts)
if (part['type'] != 'text' &&
!_isFile(part) &&
!(part['type'] == null && part['text'] is String))
_unrecognised(part),
];
final client = '${message['client'] ?? ''}'.trim();
if (client.isNotEmpty) {
widgets.insert(0, Text(client, style: _clientStyle(context)));
}
return widgets;
}
/// The answer, with its Copy button in the [gutter] to its left when there
/// is one, or else first in its footer.
Widget _agentRow(
BuildContext context,
List<Widget> content,
Widget answer,
double gutter,
) {
final answerParts = row['streaming'] == true
? const <String>[]
: _answerParts(_partsOf(row));
final copyText = answerParts.join('\n\n');
final id = speechMessageId(speechScope, '${row['key'] ?? row['id'] ?? ''}');
Widget? actions(Axis direction) => copyText.isEmpty
? null
: Flex(
direction: direction,
mainAxisSize: MainAxisSize.min,
verticalDirection: VerticalDirection.up,
children: [
ChatCopyButton(text: copyText),
ChatReadAloudButton(
messageId: id,
parts: answerParts,
direction: direction,
),
],
);
if (gutter <= 0) {
return _agentTurn(context, content, answer, actions(Axis.horizontal));
}
// The gutter is one button wide: Read aloud stacks above Copy, and stays
// shown on a desktop while this reply reads.
final turn = _agentTurn(context, content, answer, null);
return ListenableBuilder(
listenable: speechController,
child: turn,
builder: (context, child) => ChatCopyGutterRow(
width: gutter,
copy: actions(Axis.vertical),
pinned: speechController.messageId == id,
child: child!,
),
);
}
/// Stable activity precedes the answer; permission summaries and recorded
/// model remain beneath it. Pending interaction cards are rendered separately.
Widget _agentTurn(
BuildContext context,
List<Widget> content,
Widget answer,
Widget? copy,
) {
final parts = _partsOf(row);
final reasoning = [
for (final part in parts)
if (part['type'] == 'reasoning' &&
'${part['text'] ?? ''}'.trim().isNotEmpty)
'${part['text']}',
];
final tools = [
for (final part in parts)
if (isChatToolPart(part)) part,
];
final model = '${row['model'] ?? ''}'.trim();
final footer = <Widget>[
?copy,
...this.footer,
if (model.isNotEmpty)
Text(
model,
key: const Key('chat-reply-model'),
style: TextStyle(fontSize: 12, color: _secondaryColor(context)),
),
if (chatMessageCreatedAt(row) case final time?)
ChatMessageTimestamp(createdAt: time),
];
return Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.start,
children: [
if (row['streaming'] == true ||
reasoning.isNotEmpty ||
tools.isNotEmpty ||
(row['activityRecords'] as List? ?? const []).isNotEmpty)
ChatTurnActivityView(
key: const Key('chat-stable-turn-activity'),
parts: [
...parts,
...List<JsonMap>.from(
row['activityRecords'] as List? ?? const [],
),
],
streaming: row['streaming'] == true,
),
// A little air between the one-line turn status and the answer.
if (content.isNotEmpty) const SizedBox(height: 6),
if (content.isNotEmpty || footer.isNotEmpty)
Padding(
padding: const EdgeInsets.symmetric(
horizontal: chatAgentContentInset,
),
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.start,
children: [
if (content.isNotEmpty) answer,
if (footer.isNotEmpty)
Wrap(
key: const Key('chat-message-footer'),
spacing: 8,
crossAxisAlignment: WrapCrossAlignment.center,
children: footer,
),
],
),
),
],
);
}
/// The answer as the operator reads it: the turn's text parts in order,
/// without reasoning, tools or attachments.
List<String> _answerParts(List<JsonMap> parts) => [
for (final part in parts)
if ((part['type'] == null || part['type'] == 'text') &&
part['text'] is String &&
(part['text'] as String).trim().isNotEmpty)
(part['text'] as String).trim(),
];
List<Widget> _agentParts(BuildContext context) {
final widgets = <Widget>[];
final parts = _partsOf(row);
final seen = <String, int>{};
// Long replies arrive as several text parts (and folded messages); an
// empty line between consecutive ones keeps them reading as paragraphs.
final gap = chatParagraphGap(
context,
chatMessageTextStyle(context)?.fontSize,
);
var previousText = false;
for (var index = 0; index < parts.length; index++) {
final part = parts[index];
var widget = _agentPart(context, part);
if (widget == null) continue;
final text = _isTextPart(part);
if (text && previousText) {
widget = Padding(
padding: EdgeInsets.only(top: gap),
child: widget,
);
}
previousText = text;
// Part identity, not position, so an older assistant message that folds
// into the same turn can prepend its parts without moving an open
// disclosure. The enclosing row's identity is carried by ChatRowKeys; a
// part with no server id still falls back to its position.
widgets.add(
KeyedSubtree(key: _partKey(part, index, seen), child: widget),
);
}
return widgets;
}
/// The server's part id when there is one, else this part's position. A
/// repeated identity gets an ordinal so two sibling keys never collide.
Key _partKey(JsonMap part, int index, Map<String, int> seen) {
final type = '${part['type'] ?? ''}';
final id = '${part['id'] ?? ''}'.trim();
final base = id.isEmpty ? 'index-$index' : '$type:$id';
final ordinal = (seen[base] ?? 0) + 1;
seen[base] = ordinal;
return ValueKey<String>('chat-part-$base-$ordinal');
}
/// One agent part, or null when a known part has nothing to draw. The web's
/// `partRendering` hides blank text/reasoning too, so a blank known part must
/// not fall through to the unknown-part disclosure.
Widget? _agentPart(BuildContext context, JsonMap part) {
final type = '${part['type'] ?? ''}';
final text = part['text'] is String ? part['text'] as String : '';
final hasText = text.trim().isNotEmpty;
if (type.isEmpty || type == 'text') {
if (!hasText) return type.isEmpty ? _unrecognised(part) : null;
return textBuilder?.call(context, text) ?? SelectableText(text);
}
// Reasoning and tools are retained in the turn's activity disclosure.
if (type == 'reasoning' || type == 'tool') return null;
if (type == 'file') {
if (_isFile(part)) return _attachment(context, part);
return hasText ? SelectableText(text) : null;
}
if (hasText) return SelectableText(text);
return _unrecognised(part);
}
Widget _unrecognised(JsonMap part) {
final type = '${part['type'] ?? ''}';
return NativeDisclosure(
label: 'Unrecognised part${type.isEmpty ? '' : ': $type'}',
childBuilder: (context) => _raw(part),
);
}
TextStyle? _clientStyle(BuildContext context) {
return Theme.of(
context,
).textTheme.bodySmall?.copyWith(color: _secondaryColor(context));
}
Widget _attachment(BuildContext context, JsonMap part) {
return Row(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
const Padding(
padding: EdgeInsets.only(right: 8),
child: Icon(Icons.attach_file),
),
Expanded(child: SelectableText(chatAttachmentPartName(part))),
],
);
}
/// Pretty-printed on demand: a closed disclosure never pays for it.
Widget _raw(JsonMap part) =>
SelectableText(const JsonEncoder.withIndent(' ').convert(part));
}
List<JsonMap> _partsOf(Map<dynamic, dynamic> source) {
final parts = source['parts'];
if (parts is! List) return const [];
return parts
.whereType<Map>()
.map((part) => Map<String, dynamic>.from(part))
.toList();
}
bool _isTextPart(JsonMap part) =>
(part['type'] == null || part['type'] == 'text') &&
part['text'] is String &&
(part['text'] as String).trim().isNotEmpty;
bool _isFile(JsonMap part) =>
part['type'] == 'file' &&
'${part['name'] ?? ''}${part['uri'] ?? ''}'.trim().isNotEmpty;