333 lines
12 KiB
Dart
333 lines
12 KiB
Dart
import 'dart:convert';
|
|
|
|
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
|
|
import '../../../../core/api_gateway.dart';
|
|
import '../sessions/chat_adaptive.dart';
|
|
import '../../domain/chat_tool_calls.dart';
|
|
import 'chat_tool_calls_view.dart';
|
|
import 'native_disclosure.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});
|
|
|
|
final JsonMap row;
|
|
final ChatMessageTextBuilder? textBuilder;
|
|
|
|
@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);
|
|
// No visible role label, as on the web: side and colour say who spoke and
|
|
// the row's semantics label names the role. The bubble shrinks to its
|
|
// content (a disclosure still takes the full measure).
|
|
final body = Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: content,
|
|
);
|
|
// The web draws the operator's turn right-aligned in an accent-tinted bubble
|
|
// and the agent's left-aligned on the neutral surface, both capped to a
|
|
// readable measure.
|
|
final contentBody = cupertino
|
|
? DefaultTextStyle.merge(
|
|
style: CupertinoTheme.of(context).textTheme.textStyle,
|
|
child: body,
|
|
)
|
|
: body;
|
|
// A Material surface (not a bare DecoratedBox) so the disclosure ListTiles
|
|
// inside the bubble keep their ink and background.
|
|
final bubble = cupertino
|
|
? Container(
|
|
padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8),
|
|
decoration: _bubbleDecoration(context, cupertino, user: user),
|
|
child: contentBody,
|
|
)
|
|
: Material(
|
|
color: _bubbleColor(context, cupertino, user: user),
|
|
clipBehavior: Clip.antiAlias,
|
|
shape: _bubbleShape(context, cupertino, user: user),
|
|
child: Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8),
|
|
child: contentBody,
|
|
),
|
|
);
|
|
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.
|
|
constraints: BoxConstraints(
|
|
maxWidth: user
|
|
? (constraints.maxWidth * 0.85).clamp(0, 560).toDouble()
|
|
: 560,
|
|
),
|
|
child: user ? bubble : _agentTurn(context, content, bubble),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
Color _bubbleColor(
|
|
BuildContext context,
|
|
bool cupertino, {
|
|
required bool user,
|
|
}) {
|
|
final accent = cupertino
|
|
? CupertinoTheme.of(context).primaryColor
|
|
: Theme.of(context).colorScheme.primary;
|
|
final surface = cupertino
|
|
? CupertinoColors.secondarySystemGroupedBackground.resolveFrom(context)
|
|
: Theme.of(context).colorScheme.surfaceContainerLow;
|
|
return user ? accent.withValues(alpha: 0.16) : surface;
|
|
}
|
|
|
|
ShapeBorder _bubbleShape(
|
|
BuildContext context,
|
|
bool cupertino, {
|
|
required bool user,
|
|
}) {
|
|
final accent = cupertino
|
|
? CupertinoTheme.of(context).primaryColor
|
|
: Theme.of(context).colorScheme.primary;
|
|
final border = cupertino
|
|
? CupertinoColors.separator.resolveFrom(context)
|
|
: Theme.of(context).colorScheme.outlineVariant;
|
|
return RoundedRectangleBorder(
|
|
side: BorderSide(color: user ? accent.withValues(alpha: 0.4) : border),
|
|
borderRadius: BorderRadius.only(
|
|
topLeft: const Radius.circular(12),
|
|
topRight: const Radius.circular(12),
|
|
bottomLeft: Radius.circular(user ? 12 : 4),
|
|
bottomRight: Radius.circular(user ? 4 : 12),
|
|
),
|
|
);
|
|
}
|
|
|
|
BoxDecoration _bubbleDecoration(
|
|
BuildContext context,
|
|
bool cupertino, {
|
|
required bool user,
|
|
}) {
|
|
final Color accent;
|
|
final Color surface;
|
|
final Color border;
|
|
if (cupertino) {
|
|
accent = CupertinoTheme.of(context).primaryColor;
|
|
surface = CupertinoColors.secondarySystemGroupedBackground.resolveFrom(
|
|
context,
|
|
);
|
|
border = CupertinoColors.separator.resolveFrom(context);
|
|
} else {
|
|
final scheme = Theme.of(context).colorScheme;
|
|
accent = scheme.primary;
|
|
surface = scheme.surfaceContainerLow;
|
|
border = scheme.outlineVariant;
|
|
}
|
|
final radius = BorderRadius.only(
|
|
topLeft: const Radius.circular(12),
|
|
topRight: const Radius.circular(12),
|
|
bottomLeft: Radius.circular(user ? 12 : 4),
|
|
bottomRight: Radius.circular(user ? 4 : 12),
|
|
);
|
|
return BoxDecoration(
|
|
color: user ? accent.withValues(alpha: 0.16) : surface,
|
|
border: Border.all(color: user ? accent.withValues(alpha: 0.4) : border),
|
|
borderRadius: radius,
|
|
);
|
|
}
|
|
|
|
Color _secondaryColor(BuildContext context, bool cupertino) => cupertino
|
|
? CupertinoColors.secondaryLabel.resolveFrom(context)
|
|
: Theme.of(context).colorScheme.onSurfaceVariant;
|
|
|
|
bool _isCupertino(BuildContext context) =>
|
|
chatControlsStyleOf(context) == ChatControlsStyle.cupertino;
|
|
|
|
List<Widget> _userParts(BuildContext context) {
|
|
final message = row['message'] is Map
|
|
? Map<String, dynamic>.from(row['message'] as Map)
|
|
: row;
|
|
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) SelectableText(text),
|
|
for (final part in parts.where(_isFile)) _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 agent turn: the answer in the bubble, then one row with its reasoning
|
|
/// and tool-call chips, each opening its own sheet.
|
|
Widget _agentTurn(BuildContext context, List<Widget> content, Widget bubble) {
|
|
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,
|
|
];
|
|
return Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
if (content.isNotEmpty) bubble,
|
|
// Reasoning and tool calls share one quiet row below the answer.
|
|
if (reasoning.isNotEmpty || tools.isNotEmpty)
|
|
Wrap(
|
|
spacing: 8,
|
|
children: [
|
|
if (reasoning.isNotEmpty) ChatReasoningChip(steps: reasoning),
|
|
if (tools.isNotEmpty) ChatToolCallsChip(calls: tools),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
List<Widget> _agentParts(BuildContext context) {
|
|
final widgets = <Widget>[];
|
|
final parts = _partsOf(row);
|
|
final seen = <String, int>{};
|
|
for (var index = 0; index < parts.length; index++) {
|
|
final part = parts[index];
|
|
final widget = _agentPart(context, part);
|
|
if (widget == null) continue;
|
|
// 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 tool calls are drawn outside the bubble (_agentTurn).
|
|
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(
|
|
_attachmentDisplayName(part['name'], part['uri']),
|
|
),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
/// 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 _isFile(JsonMap part) =>
|
|
part['type'] == 'file' &&
|
|
'${part['name'] ?? ''}${part['uri'] ?? ''}'.trim().isNotEmpty;
|
|
|
|
/// The web's attachment name rule: its own name, else the URI basename, else
|
|
/// `file`, so an attachment never shows an empty label.
|
|
String _attachmentDisplayName(Object? name, Object? uri) {
|
|
final shown = '${name ?? ''}'.trim();
|
|
final basename = '${uri ?? ''}'.split('/').last.trim();
|
|
return shown.isNotEmpty ? shown : (basename.isEmpty ? 'file' : basename);
|
|
}
|