cf9f71f27c
Dismissed shell runs leave the transcript and fold into a "N commands" chip in the footer of the first answer at or after each run (the last answer for newer runs, or a row of its own without any answer). The chip opens the turn sheet (wide) or a full-screen page (narrow) listing the commands; each opens its output read-only with Copy output, Send to agent and Restore. On a wide conversation the answer's Copy button moves out of the footer into a 48 px gutter left of the reading column (chatCopyGutter), shown on hover or focus on desktops and always on touch; narrow widths keep it in the footer.
409 lines
14 KiB
Dart
409 lines
14 KiB
Dart
import 'dart:convert';
|
|
|
|
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
|
|
import '../../../../core/api_gateway.dart';
|
|
import '../../data/chat_attachment_images.dart';
|
|
import '../sessions/chat_adaptive.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 cupertino = _isCupertino(context);
|
|
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, cupertino),
|
|
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(cupertino, content, body)
|
|
: _agentRow(
|
|
context,
|
|
content,
|
|
ChatAgentSurface(cupertino: cupertino, child: body),
|
|
gutter,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
Color _secondaryColor(BuildContext context, bool cupertino) => cupertino
|
|
? CupertinoColors.secondaryLabel.resolveFrom(context)
|
|
: Theme.of(context).colorScheme.onSurfaceVariant;
|
|
|
|
bool _isCupertino(BuildContext context) =>
|
|
chatControlsStyleOf(context) == ChatControlsStyle.cupertino;
|
|
|
|
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(bool cupertino, 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(cupertino: cupertino, child: body);
|
|
}
|
|
return Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.end,
|
|
children: [
|
|
if (thumbnails.isNotEmpty)
|
|
ChatAttachmentGallery(
|
|
parts: thumbnails,
|
|
images: images ?? _inlineImages,
|
|
cupertino: cupertino,
|
|
),
|
|
if (thumbnails.isNotEmpty && content.isNotEmpty)
|
|
const SizedBox(height: 6),
|
|
if (content.isNotEmpty || thumbnails.isEmpty)
|
|
ChatUserBubble(cupertino: cupertino, 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, cupertino: _isCupertino(context));
|
|
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, _isCupertino(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, _isCupertino(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) {
|
|
final cupertino = _isCupertino(context);
|
|
return (cupertino
|
|
? CupertinoTheme.of(context).textTheme.textStyle
|
|
: Theme.of(context).textTheme.bodySmall)
|
|
?.copyWith(color: _secondaryColor(context, cupertino));
|
|
}
|
|
|
|
Widget _attachment(BuildContext context, JsonMap part) {
|
|
final cupertino = _isCupertino(context);
|
|
return Row(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Padding(
|
|
padding: const EdgeInsets.only(right: 8),
|
|
child: Icon(cupertino ? CupertinoIcons.paperclip : 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;
|