9551eceaed
Remove obsolete control-family flags and icon metadata across all callers, dead alternate themes and host helpers, obsolete test setup, and the unused icon-font dependency. Preserve native Material Back transitions. Make navigation fixtures independent of update plugins and answer auxiliary shell snapshots so the complete application suite can run deterministically.
393 lines
14 KiB
Dart
393 lines
14 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';
|
|
|
|
/// 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,
|
|
});
|
|
|
|
final JsonMap row;
|
|
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 copyText = row['streaming'] == true ? '' : _answerText(_partsOf(row));
|
|
final copy = copyText.isEmpty ? null : ChatCopyButton(text: copyText);
|
|
if (gutter <= 0) return _agentTurn(context, content, answer, copy);
|
|
return ChatCopyGutterRow(
|
|
width: gutter,
|
|
copy: copy,
|
|
child: _agentTurn(context, content, answer, null),
|
|
);
|
|
}
|
|
|
|
/// 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.
|
|
String _answerText(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(),
|
|
].join('\n\n');
|
|
|
|
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;
|