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.
1322 lines
48 KiB
Dart
1322 lines
48 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter/material.dart';
|
|
|
|
import '../../../ui/scale/ui_scale.dart';
|
|
import '../../../ui/motion/surface_visibility.dart';
|
|
import 'chat_stop_icon.dart';
|
|
import 'package:flutter/services.dart';
|
|
|
|
import '../../../core/api_gateway.dart';
|
|
import '../../../core/transport/pipelines_client.dart';
|
|
import '../data/chat_attachment_images.dart';
|
|
import '../data/upload/chat_upload.dart';
|
|
import '../domain/chat_attachment_draft.dart';
|
|
import '../domain/chat_attachment_picker.dart';
|
|
import '../domain/chat_attachment_wire.dart';
|
|
import '../domain/chat_clipboard_paste.dart';
|
|
import '../domain/chat_commands.dart';
|
|
import 'chat_command_actions.dart';
|
|
import 'chat_command_palette.dart';
|
|
import 'chat_composer_controller.dart';
|
|
import 'chat_composer_paste_focus.dart';
|
|
import '../ui/transcript/chat_attachment_frame.dart';
|
|
import '../../../ui/adaptive/glass_bar.dart';
|
|
import '../../../ui/adaptive/glass_pill.dart';
|
|
import '../../../ui/adaptive/pop_entrance.dart';
|
|
import 'chat_reading_width.dart';
|
|
import 'composer_focus_request.dart';
|
|
import 'composer_focus_restore.dart';
|
|
import 'chat_bar_tint.dart';
|
|
import 'composer_focus_ring.dart';
|
|
import '../shell/chat_shell_command.dart';
|
|
import '../shell/chat_shell_mode_indicator.dart';
|
|
|
|
/// The composer's placeholder when the chat names no working directory.
|
|
const String chatComposerPlaceholder = 'Message the agent';
|
|
|
|
/// The composer's placeholder for a chat working in [directory]: its folder
|
|
/// name, as the operator would say it, or the generic placeholder without one.
|
|
String chatComposerPlaceholderFor(String directory) {
|
|
final parts = directory.trim().split(RegExp(r'[/\\]'));
|
|
final name = parts.lastWhere((part) => part.isNotEmpty, orElse: () => '');
|
|
return name.isEmpty ? chatComposerPlaceholder : 'Work on $name';
|
|
}
|
|
|
|
/// Whether Enter sends on [platform] (the running host by default).
|
|
///
|
|
/// On a phone the on-screen keyboard's Return breaks the line and the Send
|
|
/// button sends, as in other chat apps; a desktop keyboard's Enter sends and
|
|
/// Shift+Enter breaks the line. Ctrl/Cmd+Enter sends everywhere.
|
|
bool chatEnterSends([TargetPlatform? platform]) {
|
|
final target = platform ?? defaultTargetPlatform;
|
|
return target != TargetPlatform.android && target != TargetPlatform.iOS;
|
|
}
|
|
|
|
/// The composer's gap above the bottom of the window (or its bottom safe
|
|
/// area) on a phone, where it sits just over the keyboard or home indicator.
|
|
const double kChatComposerBottomMargin = 12;
|
|
|
|
/// The same gap on a desktop host (native or a desktop browser), whose
|
|
/// window's bottom edge is a hard frame under a pointer: the composer keeps
|
|
/// more room from it so it does not read as stuck to the edge.
|
|
const double kChatComposerDesktopBottomMargin = 24;
|
|
|
|
/// The composer's bottom gap on [platform] (the running host by default),
|
|
/// split between phones and desktops as [chatEnterSends] is.
|
|
double chatComposerBottomMargin([TargetPlatform? platform]) =>
|
|
chatEnterSends(platform)
|
|
? kChatComposerDesktopBottomMargin
|
|
: kChatComposerBottomMargin;
|
|
|
|
/// The single primary control's words while a turn is and is not running.
|
|
const String chatSendLabel = 'Send';
|
|
const String chatStopLabel = 'Stop';
|
|
|
|
/// The primary control's words while the draft is a `!` shell command.
|
|
const String chatRunShellLabel = 'Run command';
|
|
|
|
/// The attach control's accessible name, verbatim from the web composer.
|
|
const String chatAttachLabel = 'Attach file';
|
|
|
|
/// The unknown-command report's two actions, verbatim from the web client.
|
|
const String chatCommandSendAsMessageLabel = 'Send as message';
|
|
const String chatCommandCancelLabel = 'Cancel';
|
|
const String chatCommandNoticeLabel = 'Command';
|
|
const String chatCommandFailedLabel = 'Command failed';
|
|
const String chatCommandDismissLabel = 'Dismiss command notice';
|
|
|
|
/// The web's line after `/stop`'s interrupt was accepted.
|
|
const String chatStopCommandNotice = 'Stopping the running turn…';
|
|
|
|
/// Shown while the reply says this prompt waits behind the running turn.
|
|
const String chatQueuedNotice =
|
|
'Queued — it will send when the current turn finishes.';
|
|
|
|
/// The foot of one conversation: a native multiline field and Send control,
|
|
/// with a separate Stop while a turn runs, driven by [ChatComposerController].
|
|
///
|
|
/// The field owns only its [TextEditingController] and focus; the durable draft
|
|
/// text lives in the composer controller, so a live transcript rebuild never
|
|
/// replaces the operator's caret. Enter sends, Shift+Enter inserts a newline,
|
|
/// and Ctrl/Cmd+Enter remains a send shortcut.
|
|
/// A leading `/` opens the recorded command palette
|
|
/// above the field: rows are filtered by name prefix, Up/Down move the
|
|
/// highlight, Enter or a tap completes the highlighted command, Escape closes
|
|
/// the palette. A slash draft is never handed to the prompt path: `/new`,
|
|
/// `/close` and `/rename` run through [commands], `/stop` and `/help` run
|
|
/// locally or through the existing Stop path; text naming no recorded command
|
|
/// becomes the web client's local no-send report with its explicit "Send as
|
|
/// message" offer. Picked files are memory-only chips:
|
|
/// their names are shown with the host's own remove action and the bounded
|
|
/// draft owns every refusal. Send carries the chips as the landed wire parts,
|
|
/// keeps them until the prompt is accepted and leaves them in place on a
|
|
/// refusal. Pasting files takes the same draft path as the picker; pasting text
|
|
/// stays with the host field, so its caret, selection and draft behave exactly
|
|
/// as typing does.
|
|
class ChatComposerBar extends StatefulWidget {
|
|
const ChatComposerBar({
|
|
super.key,
|
|
required this.composer,
|
|
required this.running,
|
|
this.picker,
|
|
this.commands,
|
|
this.paste,
|
|
this.pasteTarget = true,
|
|
this.ownsPasteWhenFocused = false,
|
|
this.backgroundTasks,
|
|
this.runShell,
|
|
this.placeholder = chatComposerPlaceholder,
|
|
this.enterSends,
|
|
this.images,
|
|
this.chatColor,
|
|
});
|
|
|
|
/// The chat's colour name (see `chatSessionColor`), the accent of the
|
|
/// field's focus ring; null takes the host's primary colour.
|
|
final String? chatColor;
|
|
|
|
/// The transcript's image cache, told about uploaded files so the sent turn
|
|
/// shows them without a round trip.
|
|
final ChatAttachmentImages? images;
|
|
|
|
/// Overrides [chatEnterSends] for this composer; null follows the host.
|
|
final bool? enterSends;
|
|
|
|
final ChatComposerController composer;
|
|
|
|
/// The empty field's hint; see [chatComposerPlaceholderFor].
|
|
final String placeholder;
|
|
|
|
/// Runs `/new`, `/close` and `/rename` for the open session. A host without a
|
|
/// session (null) keeps those commands on the unavailable report.
|
|
final ChatCommandActions? commands;
|
|
|
|
/// The thread controller's running bit; shows Stop without hiding Send.
|
|
final bool running;
|
|
|
|
/// The host picker seam; production uses [hostChatAttachmentPicker].
|
|
final ChatAttachmentPicker? picker;
|
|
|
|
/// The host clipboard-file seam; production uses [hostChatClipboardPaste].
|
|
final ChatClipboardPaste? paste;
|
|
|
|
/// True only for the active visible pane.
|
|
final bool pasteTarget;
|
|
|
|
/// While its field has the keyboard this composer takes a paste (files
|
|
/// too) even when it is not [pasteTarget], and the paste target leaves it
|
|
/// alone: a floating chat over the tiled ones.
|
|
final bool ownsPasteWhenFocused;
|
|
final Widget? backgroundTasks;
|
|
|
|
/// Runs a `!` draft's command in the chat's folder (never a prompt);
|
|
/// resolves to the server's refusal, or null once it started. Null (no
|
|
/// session) reports shell mode as unavailable and sends nothing.
|
|
final Future<String?> Function(String command)? runShell;
|
|
|
|
@override
|
|
State<ChatComposerBar> createState() => _ChatComposerBarState();
|
|
}
|
|
|
|
class _ChatComposerBarState extends State<ChatComposerBar> {
|
|
late final TextEditingController _text = TextEditingController(
|
|
text: widget.composer.draft,
|
|
);
|
|
final FocusNode _focus = FocusNode(debugLabel: 'chat-composer');
|
|
|
|
/// The field's own scroll position, so a new last line is brought into
|
|
/// view as soon as it exists (see [_revealCaretLine]).
|
|
final ScrollController _fieldScroll = ScrollController();
|
|
late final ComposerFocusRestorer _focusRestorer;
|
|
late final ComposerFocusRequestListener _focusRequests =
|
|
ComposerFocusRequestListener(focus: _focus, canFocus: _composerIsCurrent);
|
|
final ChatAttachmentDraft _attachments = ChatAttachmentDraft();
|
|
|
|
/// The picked bytes behind each chip, positionally aligned with the draft's
|
|
/// attachments so two picks of the same name stay distinct.
|
|
final List<Uint8List> _bytes = [];
|
|
String? _attachmentError;
|
|
|
|
/// True while the draft's files upload ahead of the prompt.
|
|
bool _uploading = false;
|
|
|
|
/// Upload names by attachment instance, so a retried send reuses the files
|
|
/// already stored instead of uploading them again.
|
|
final Expando<String> _uploaded = Expando();
|
|
|
|
/// The draft text whose palette the operator closed (Escape) or completed
|
|
/// (a row or Enter). The palette stays hidden while the draft still equals
|
|
/// it, so any further typing offers the commands again.
|
|
String? _paletteClosedFor;
|
|
|
|
/// The highlighted command row, wrapped to the filtered list on each build.
|
|
int _selectedCommand = 0;
|
|
|
|
/// The local no-send report shown under the field. Every slash draft takes
|
|
/// this path instead of the prompt, as the web client records: an unknown
|
|
/// command carries [_commandOffer] back for an explicit "Send as message".
|
|
String? _commandNotice;
|
|
String? _commandOffer;
|
|
bool _commandFailed = false;
|
|
|
|
/// True while a `!` command is being started.
|
|
bool _shellStarting = false;
|
|
|
|
ChatAttachmentPicker get _picker => widget.picker ?? hostChatAttachmentPicker;
|
|
ChatClipboardPaste get _paste => widget.paste ?? hostChatClipboardPaste;
|
|
|
|
ChatPasteUnsubscribe? _stopPaste;
|
|
|
|
/// The composer's accepted-send count the chips were last cleared for.
|
|
late int _seenAccepted = widget.composer.composerSendsAccepted;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_focusRestorer = ComposerFocusRestorer(
|
|
focus: _focus,
|
|
canRestore: _composerIsCurrent,
|
|
);
|
|
widget.composer.addListener(_syncDraft);
|
|
ChatComposerPasteFocus.register(_focus);
|
|
ChatComposerPasteFocus.setOwnsFocusedPaste(
|
|
_focus,
|
|
widget.ownsPasteWhenFocused,
|
|
);
|
|
FocusManager.instance.addEarlyKeyEventHandler(_nativePasteKey);
|
|
_listenForPaste();
|
|
unawaited(widget.composer.loadDraft());
|
|
}
|
|
|
|
@override
|
|
void didChangeDependencies() {
|
|
super.didChangeDependencies();
|
|
_focusRequests.attach(context);
|
|
}
|
|
|
|
/// Whether the composer is still where the operator works: mounted, shown,
|
|
/// and not covered by a dialog, sheet or another pushed route.
|
|
bool _composerIsCurrent() =>
|
|
mounted &&
|
|
SurfaceVisibility.currentOf(context) &&
|
|
(ModalRoute.of(context)?.isCurrent ?? true);
|
|
|
|
@override
|
|
void didUpdateWidget(covariant ChatComposerBar oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
if (oldWidget.composer != widget.composer) {
|
|
oldWidget.composer.removeListener(_syncDraft);
|
|
widget.composer.addListener(_syncDraft);
|
|
_seenAccepted = widget.composer.composerSendsAccepted;
|
|
_syncDraft();
|
|
}
|
|
if (oldWidget.ownsPasteWhenFocused != widget.ownsPasteWhenFocused) {
|
|
ChatComposerPasteFocus.setOwnsFocusedPaste(
|
|
_focus,
|
|
widget.ownsPasteWhenFocused,
|
|
);
|
|
}
|
|
if (oldWidget.composer != widget.composer ||
|
|
oldWidget.paste != widget.paste ||
|
|
oldWidget.pasteTarget != widget.pasteTarget) {
|
|
_stopListeningForPaste();
|
|
_listenForPaste();
|
|
}
|
|
}
|
|
|
|
void _listenForPaste() {
|
|
if (!_paste.isSupported) return;
|
|
final owner = widget.composer;
|
|
_stopPaste = _paste.listen(
|
|
// File decoding is asynchronous. Keep an accepted paste on its original
|
|
// chat even if it becomes inactive, but never carry it to a replacement.
|
|
onFiles: (files) {
|
|
if (mounted && identical(widget.composer, owner)) _onPastedFiles(files);
|
|
},
|
|
canAccept: _canAcceptPaste,
|
|
onError: (error) {
|
|
if (mounted && identical(widget.composer, owner)) _onPasteError(error);
|
|
},
|
|
onText: _onPastedText,
|
|
canAcceptText: _canAcceptTextPaste,
|
|
);
|
|
}
|
|
|
|
void _stopListeningForPaste() {
|
|
final stop = _stopPaste;
|
|
_stopPaste = null;
|
|
stop?.call();
|
|
}
|
|
|
|
/// A pasted file is taken by the active, visible composer even when its
|
|
/// field is not focused. The host checks this before suppressing the paste's
|
|
/// default behaviour, so an inactive pane is never allowed to swallow it.
|
|
bool _canAcceptPaste() =>
|
|
mounted &&
|
|
(widget.ownsPasteWhenFocused && _focus.hasFocus ||
|
|
widget.pasteTarget &&
|
|
!ChatComposerPasteFocus.otherOwnerHasFocus(_focus)) &&
|
|
_composerIsCurrent() &&
|
|
!ChatComposerPasteFocus.anotherEditableHasFocus &&
|
|
!widget.composer.sending;
|
|
|
|
bool _canAcceptTextPaste() => _canAcceptPaste() && !_focus.hasFocus;
|
|
|
|
KeyEventResult _nativePasteKey(KeyEvent event) {
|
|
// Web uses the browser's clipboard event, never a second Clipboard read.
|
|
if (kIsWeb || event is! KeyDownEvent || !_canAcceptTextPaste()) {
|
|
return KeyEventResult.ignored;
|
|
}
|
|
final keys = HardwareKeyboard.instance;
|
|
if (event.logicalKey != LogicalKeyboardKey.keyV ||
|
|
keys.isAltPressed ||
|
|
keys.isShiftPressed ||
|
|
!(keys.isControlPressed != keys.isMetaPressed)) {
|
|
return KeyEventResult.ignored;
|
|
}
|
|
unawaited(_readNativePaste());
|
|
return KeyEventResult.handled;
|
|
}
|
|
|
|
Future<void> _readNativePaste() async {
|
|
try {
|
|
final data = await Clipboard.getData(Clipboard.kTextPlain);
|
|
final text = data?.text;
|
|
if (text != null && text.isNotEmpty) _onPastedText(text);
|
|
} catch (_) {
|
|
if (mounted && _canAcceptPaste()) {
|
|
_onPasteError('Could not read clipboard text.');
|
|
}
|
|
}
|
|
}
|
|
|
|
void _onPastedText(String text) {
|
|
// Recheck after an asynchronous native read, but permit the same composer
|
|
// to have received focus meanwhile. Never insert into another editor.
|
|
if (!mounted || !_canAcceptPaste()) return;
|
|
final value = _text.value;
|
|
final selection = value.selection.isValid
|
|
? value.selection
|
|
: TextSelection.collapsed(offset: value.text.length);
|
|
final next = value.text.replaceRange(selection.start, selection.end, text);
|
|
_text.value = TextEditingValue(
|
|
text: next,
|
|
selection: TextSelection.collapsed(offset: selection.start + text.length),
|
|
);
|
|
_onDraftEdited(next);
|
|
_focus.requestFocus();
|
|
}
|
|
|
|
void _onPastedFiles(List<ChatPickedFile> files) {
|
|
if (!mounted) return;
|
|
_addFiles(files);
|
|
}
|
|
|
|
void _onPasteError(Object error) {
|
|
if (!mounted) return;
|
|
setState(() => _attachmentError = '$error');
|
|
}
|
|
|
|
/// External draft changes (saved-draft load, send clear, refusal restore)
|
|
/// replace the field's text but never the focus node, so the caret survives
|
|
/// live transcript rebuilds.
|
|
void _syncDraft() {
|
|
if (!mounted) return;
|
|
final accepted = widget.composer.composerSendsAccepted;
|
|
if (accepted != _seenAccepted) {
|
|
_seenAccepted = accepted;
|
|
setState(() {
|
|
_replaceAttachments(const [], const []);
|
|
_attachmentError = null;
|
|
});
|
|
}
|
|
final draft = widget.composer.draft;
|
|
if (_text.text == draft) return;
|
|
_text.value = TextEditingValue(
|
|
text: draft,
|
|
selection: TextSelection.collapsed(offset: draft.length),
|
|
);
|
|
}
|
|
|
|
/// The recorded commands matching the current draft while the palette is
|
|
/// open. A dismissed or completed draft keeps its palette closed until the
|
|
/// operator types something newer.
|
|
List<ChatCommand> _paletteCommands() {
|
|
final draft = widget.composer.draft;
|
|
if (_paletteClosedFor == draft) return const <ChatCommand>[];
|
|
return chatCommandSuggestions(draft);
|
|
}
|
|
|
|
/// Mirrors the typed text into the composer after clearing the per-keystroke
|
|
/// command state: a fresh edit reopens a dismissed palette, hides an old
|
|
/// report, and resets the highlight when the filtered list no longer holds it
|
|
/// (the web client's `refreshComposerControls`).
|
|
void _onDraftEdited(String value) {
|
|
final suggestions = chatCommandSuggestions(value);
|
|
setState(() {
|
|
_paletteClosedFor = null;
|
|
_dismissCommandReport();
|
|
if (_selectedCommand >= suggestions.length) _selectedCommand = 0;
|
|
});
|
|
unawaited(widget.composer.setDraft(value));
|
|
_revealCaretLine(value);
|
|
}
|
|
|
|
/// At the field's line limit, a newline at the end leaves the caret on a
|
|
/// new empty line the field only scrolls to once it has a character.
|
|
/// Scroll there right away whenever the caret is at the end.
|
|
void _revealCaretLine(String value) {
|
|
final caret = _text.selection;
|
|
if (!caret.isCollapsed || caret.baseOffset != value.length) return;
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
if (!mounted || !_fieldScroll.hasClients) return;
|
|
final position = _fieldScroll.position;
|
|
if (position.pixels < position.maxScrollExtent) {
|
|
_fieldScroll.jumpTo(position.maxScrollExtent);
|
|
}
|
|
});
|
|
}
|
|
|
|
KeyEventResult _onKey(FocusNode node, KeyEvent event) {
|
|
final key = event.logicalKey;
|
|
final commands = _paletteCommands();
|
|
if (key == LogicalKeyboardKey.escape) {
|
|
if (commands.isEmpty && _commandNotice == null) {
|
|
return KeyEventResult.ignored;
|
|
}
|
|
if (event is KeyDownEvent) {
|
|
setState(() {
|
|
if (commands.isNotEmpty) _paletteClosedFor = widget.composer.draft;
|
|
_dismissCommandReport();
|
|
});
|
|
}
|
|
return KeyEventResult.handled;
|
|
}
|
|
if (commands.isNotEmpty &&
|
|
(key == LogicalKeyboardKey.arrowDown ||
|
|
key == LogicalKeyboardKey.arrowUp)) {
|
|
if (event is! KeyDownEvent) return KeyEventResult.handled;
|
|
final step = key == LogicalKeyboardKey.arrowDown ? 1 : -1;
|
|
final selected = _selectedCommand % commands.length;
|
|
setState(() => _selectedCommand = (selected + step) % commands.length);
|
|
return KeyEventResult.handled;
|
|
}
|
|
if (key != LogicalKeyboardKey.enter &&
|
|
key != LogicalKeyboardKey.numpadEnter) {
|
|
return KeyEventResult.ignored;
|
|
}
|
|
final keyboard = HardwareKeyboard.instance;
|
|
final sendShortcut = keyboard.isControlPressed || keyboard.isMetaPressed;
|
|
// Enter may be confirming an IME candidate rather than submitting a draft.
|
|
if (_text.value.composing.isValid && !_text.value.composing.isCollapsed) {
|
|
return KeyEventResult.ignored;
|
|
}
|
|
// A phone keyboard's Return is the field's own newline; only the
|
|
// modifier shortcut sends from the keyboard there.
|
|
if (!sendShortcut && !_enterSends) return KeyEventResult.ignored;
|
|
if (!sendShortcut && keyboard.isShiftPressed) {
|
|
if (event is KeyDownEvent) {
|
|
final selection = _text.selection;
|
|
final start = selection.isValid ? selection.start : _text.text.length;
|
|
final end = selection.isValid ? selection.end : start;
|
|
_text.value = TextEditingValue(
|
|
text: _text.text.replaceRange(start, end, '\n'),
|
|
selection: TextSelection.collapsed(offset: start + 1),
|
|
);
|
|
_onDraftEdited(_text.text);
|
|
}
|
|
return KeyEventResult.handled;
|
|
}
|
|
if (!sendShortcut && keyboard.isAltPressed) {
|
|
return KeyEventResult.ignored;
|
|
}
|
|
// A held key must not post a second prompt.
|
|
if (event is! KeyDownEvent) return KeyEventResult.handled;
|
|
_submitDraft();
|
|
return KeyEventResult.handled;
|
|
}
|
|
|
|
bool get _enterSends => widget.enterSends ?? chatEnterSends();
|
|
|
|
/// Hardware Enter, the keyboard's Send action and modifier shortcuts share
|
|
/// the same command/prompt path. An active IME candidate is never submitted.
|
|
void _submitDraft() {
|
|
if (_text.value.composing.isValid && !_text.value.composing.isCollapsed) {
|
|
return;
|
|
}
|
|
final keyboard = HardwareKeyboard.instance;
|
|
if (!keyboard.isControlPressed &&
|
|
!keyboard.isMetaPressed &&
|
|
(keyboard.isShiftPressed || keyboard.isAltPressed)) {
|
|
return;
|
|
}
|
|
final commands = _paletteCommands();
|
|
if (commands.isNotEmpty) {
|
|
_completeCommand(commands[_selectedCommand % commands.length]);
|
|
return;
|
|
}
|
|
if (chatDraftIsShell(widget.composer.draft)) {
|
|
unawaited(_runShellDraft());
|
|
return;
|
|
}
|
|
if (chatCommandWord(widget.composer.draft) != null) {
|
|
_runSlashDraft();
|
|
return;
|
|
}
|
|
unawaited(_send());
|
|
}
|
|
|
|
/// A `!` draft runs as a shell command and is never sent to the agent. The
|
|
/// draft is cleared once the server started it; a refusal keeps it.
|
|
Future<void> _runShellDraft() async {
|
|
final draft = widget.composer.draft;
|
|
final command = chatShellCommandOf(draft) ?? '';
|
|
final run = widget.runShell;
|
|
if (run == null) {
|
|
_showCommandNotice(
|
|
'Shell commands are not available here, so nothing was sent.',
|
|
failed: true,
|
|
);
|
|
return;
|
|
}
|
|
if (command.isEmpty) {
|
|
_showCommandNotice('Type a command after !.', failed: true);
|
|
return;
|
|
}
|
|
if (_shellStarting) return;
|
|
setState(() {
|
|
_shellStarting = true;
|
|
_dismissCommandReport();
|
|
});
|
|
final refusal = await run(command);
|
|
if (!mounted) return;
|
|
setState(() => _shellStarting = false);
|
|
if (refusal != null) {
|
|
_showCommandNotice(refusal, failed: true);
|
|
return;
|
|
}
|
|
if (widget.composer.draft == draft) _consumeCommandDraft();
|
|
}
|
|
|
|
/// Routes a slash draft locally or through the existing Stop controller path.
|
|
void _runSlashDraft() {
|
|
final draft = widget.composer.draft;
|
|
final word = chatCommandWord(draft);
|
|
if (word == null) return;
|
|
final command = chatCommandNamed(draft);
|
|
final actions = widget.commands;
|
|
if (command != null) {
|
|
final argument = chatCommandArgument(draft);
|
|
if (!command.takesArgument && argument.isNotEmpty) {
|
|
_consumeCommandDraft();
|
|
_showCommandNotice(
|
|
'${command.usage} does not take an argument.',
|
|
failed: true,
|
|
);
|
|
} else if (actions != null && ChatCommandActions.runs(command)) {
|
|
_consumeCommandDraft();
|
|
setState(_dismissCommandReport);
|
|
unawaited(actions.run(command, argument));
|
|
} else if (command.name == chatCommandStop) {
|
|
_consumeCommandDraft();
|
|
if (widget.running) {
|
|
unawaited(_stopFromCommand());
|
|
} else {
|
|
_showCommandNotice('No turn is running in this chat.', failed: true);
|
|
}
|
|
} else if (command.name == chatCommandHelp) {
|
|
_consumeCommandDraft();
|
|
_showCommandNotice(chatCommandHelpText());
|
|
} else {
|
|
_consumeCommandDraft();
|
|
_showCommandNotice(chatCommandUnavailableReport('/${command.name}'));
|
|
}
|
|
return;
|
|
}
|
|
final offer = draft.trim();
|
|
setState(() {
|
|
_commandFailed = true;
|
|
_commandOffer = offer;
|
|
_commandNotice = chatUnknownCommandReport(word);
|
|
});
|
|
_text.clear();
|
|
unawaited(widget.composer.setDraft(''));
|
|
_focus.requestFocus();
|
|
}
|
|
|
|
/// `/stop`'s accepted interrupt reports the web's line; a refusal is the
|
|
/// composer's own error.
|
|
Future<void> _stopFromCommand() async {
|
|
await widget.composer.stop();
|
|
if (!mounted || widget.composer.error != null) return;
|
|
_showCommandNotice(chatStopCommandNotice);
|
|
}
|
|
|
|
void _consumeCommandDraft() {
|
|
_text.clear();
|
|
unawaited(widget.composer.setDraft(''));
|
|
_focus.requestFocus();
|
|
}
|
|
|
|
void _showCommandNotice(String text, {bool failed = false}) {
|
|
setState(() {
|
|
_commandFailed = failed;
|
|
_commandOffer = null;
|
|
_commandNotice = text;
|
|
});
|
|
}
|
|
|
|
/// Closes whatever local command report is showing. Callers wrap this in
|
|
/// [setState]; it owns no rebuild of its own.
|
|
void _dismissCommandReport() {
|
|
_commandNotice = null;
|
|
_commandOffer = null;
|
|
_commandFailed = false;
|
|
}
|
|
|
|
/// The offer's one explicit route to the agent: take the reported draft back
|
|
/// and send it as an ordinary message. The notice is dropped first, so a
|
|
/// stale second tap sends nothing.
|
|
Future<void> _sendOffered() async {
|
|
final offer = _commandOffer;
|
|
if (offer == null) return;
|
|
setState(_dismissCommandReport);
|
|
if (offer != widget.composer.draft) {
|
|
_text.value = TextEditingValue(
|
|
text: offer,
|
|
selection: TextSelection.collapsed(offset: offer.length),
|
|
);
|
|
await widget.composer.setDraft(offer);
|
|
if (!mounted) return;
|
|
}
|
|
await _send();
|
|
}
|
|
|
|
/// Puts the chosen recorded command in the composer and closes the palette.
|
|
/// Nothing is sent to the agent: selecting a command is completion, not an
|
|
/// execution path (this slice adds the palette, not the command actions).
|
|
void _completeCommand(ChatCommand command) {
|
|
final text = '/${command.name}';
|
|
setState(() {
|
|
_paletteClosedFor = text;
|
|
_selectedCommand = 0;
|
|
_dismissCommandReport();
|
|
});
|
|
_text.value = TextEditingValue(
|
|
text: text,
|
|
selection: TextSelection.collapsed(offset: text.length),
|
|
);
|
|
unawaited(widget.composer.setDraft(text));
|
|
_focus.requestFocus();
|
|
}
|
|
|
|
/// Builds the chips' exact wire parts and hands them to the composer with the
|
|
/// draft's text and operation id. The chips stay while the prompt is in
|
|
/// flight so a refusal leaves the draft and its files together; only an
|
|
/// accepted prompt clears them.
|
|
Future<void> _send() async {
|
|
final composer = widget.composer;
|
|
if (_uploading || composer.sending || composer.draft.trim().isEmpty) {
|
|
return;
|
|
}
|
|
List<JsonMap> parts;
|
|
final endpoint = configuredGatewayEndpoint(composer.gateway);
|
|
try {
|
|
if (endpoint.isEmpty || _attachments.isEmpty) {
|
|
parts = chatAttachmentParts(_attachments, read: _readAttachment);
|
|
} else {
|
|
// Each file goes to the server as its own request first; the prompt
|
|
// then names the stored files.
|
|
setState(() {
|
|
_uploading = true;
|
|
_attachmentError = null;
|
|
});
|
|
parts = await chatAttachmentUploadParts(
|
|
_attachments,
|
|
read: _readAttachment,
|
|
upload: (attachment, bytes) async {
|
|
final stored = _uploaded[attachment] ??= await uploadChatAttachment(
|
|
endpoint,
|
|
attachment,
|
|
bytes,
|
|
);
|
|
// The sent turn draws these bytes instead of fetching them back.
|
|
if (attachment.mime.toLowerCase().startsWith('image/')) {
|
|
widget.images?.rememberUpload(stored, bytes);
|
|
}
|
|
return stored;
|
|
},
|
|
);
|
|
}
|
|
} on ChatAttachmentWireException catch (error) {
|
|
if (mounted) {
|
|
setState(() {
|
|
_uploading = false;
|
|
_attachmentError = error.message;
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
if (!mounted) return;
|
|
if (_uploading) setState(() => _uploading = false);
|
|
// Keep the caret in the field while the prompt is in flight, as before.
|
|
_focus.requestFocus();
|
|
// Acceptance (here or through the bubble's Retry) clears the chips via
|
|
// the composer's accepted-send count.
|
|
await composer.send(attachments: parts);
|
|
}
|
|
|
|
/// Adds the operator's explicit selection through the host seam. A dismissed
|
|
/// picker changes nothing; a bounded draft refusal is shown in its own words
|
|
/// while every attachment already in the draft stays.
|
|
Future<void> _pickAttachments() async {
|
|
if (widget.composer.sending || !_picker.isSupported) return;
|
|
List<ChatPickedFile>? files;
|
|
try {
|
|
files = await _picker.pick();
|
|
} catch (error) {
|
|
if (!mounted) return;
|
|
setState(() => _attachmentError = '$error');
|
|
return;
|
|
}
|
|
if (!mounted || files == null) return;
|
|
_addFiles(files);
|
|
}
|
|
|
|
/// Adds each file through the landed attachment draft. A refusal keeps every
|
|
/// attachment already in the draft and shows the draft's own words; the
|
|
/// refused file's bytes are never retained. Picking and pasting share this
|
|
/// path so both apply the same name and size decisions.
|
|
void _addFiles(List<ChatPickedFile> files) {
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_attachmentError = null;
|
|
for (final file in files) {
|
|
final refusal = _attachments.add(file.attachment);
|
|
if (refusal != null) {
|
|
_attachmentError = refusal.message;
|
|
} else {
|
|
_bytes.add(file.bytes);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/// The picked bytes for the draft's own attachment instance. Identity is the
|
|
/// only reliable match when two picks share a name, type and size.
|
|
Uint8List? _readAttachment(ChatAttachment attachment) {
|
|
final attachments = _attachments.attachments;
|
|
for (var index = 0; index < attachments.length; index += 1) {
|
|
if (identical(attachments[index], attachment)) return _bytes[index];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
void _removeAttachmentAt(int index) {
|
|
setState(() {
|
|
final remaining = List<ChatAttachment>.from(_attachments.attachments)
|
|
..removeAt(index);
|
|
final remainingBytes = List<Uint8List>.from(_bytes)..removeAt(index);
|
|
_replaceAttachments(remaining, remainingBytes);
|
|
_attachmentError = null;
|
|
});
|
|
}
|
|
|
|
/// Rebuilds the draft and its aligned bytes in [attachments] order. The draft
|
|
/// owns the count and size bounds, and every kept attachment already passed
|
|
/// them, so re-adding never refuses.
|
|
void _replaceAttachments(
|
|
List<ChatAttachment> attachments,
|
|
List<Uint8List> bytes,
|
|
) {
|
|
for (final attachment in _attachments.attachments) {
|
|
_attachments.remove(attachment);
|
|
}
|
|
_bytes
|
|
..clear()
|
|
..addAll(bytes);
|
|
for (final attachment in attachments) {
|
|
_attachments.add(attachment);
|
|
}
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_stopListeningForPaste();
|
|
FocusManager.instance.removeEarlyKeyEventHandler(_nativePasteKey);
|
|
ChatComposerPasteFocus.unregister(_focus);
|
|
widget.composer.removeListener(_syncDraft);
|
|
_focusRestorer.dispose();
|
|
_focusRequests.dispose();
|
|
_text.dispose();
|
|
_focus.dispose();
|
|
_fieldScroll.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return ListenableBuilder(
|
|
listenable: widget.composer,
|
|
builder: (context, _) {
|
|
final composer = widget.composer;
|
|
final error = composer.error ?? composer.draftError;
|
|
final commands = _paletteCommands();
|
|
final selected = commands.isEmpty
|
|
? 0
|
|
: _selectedCommand % commands.length;
|
|
// Everything the next message carries (attachments, its notices) sits
|
|
// inside the glass with the field, as one floating composer; only the
|
|
// command palette, a separate menu, floats above it.
|
|
final extras = <Widget>[
|
|
if (chatDraftIsShell(composer.draft)) ChatShellModeIndicator(),
|
|
if (!_attachments.isEmpty) _attachmentStrip(context),
|
|
if (_uploading)
|
|
_notice(
|
|
context,
|
|
key: const Key('chat-composer-uploading'),
|
|
text: _attachments.attachments.length == 1
|
|
? 'Uploading 1 file…'
|
|
: 'Uploading ${_attachments.attachments.length} files…',
|
|
),
|
|
if (_attachmentError != null)
|
|
_notice(
|
|
context,
|
|
key: const Key('chat-composer-attachment-error'),
|
|
text: _attachmentError!,
|
|
failed: true,
|
|
),
|
|
if (_commandNotice != null) _commandReport(context),
|
|
if (composer.queued)
|
|
_notice(
|
|
context,
|
|
key: const Key('chat-composer-queued'),
|
|
text: chatQueuedNotice,
|
|
),
|
|
if (error != null)
|
|
_notice(
|
|
context,
|
|
key: const Key('chat-composer-error'),
|
|
text: error,
|
|
failed: true,
|
|
),
|
|
];
|
|
return SafeArea(
|
|
top: false,
|
|
// The composer floats over the transcript in the conversation's
|
|
// centred reading column; the space beside it passes taps through.
|
|
child: Align(
|
|
heightFactor: 1,
|
|
child: ConstrainedBox(
|
|
constraints: const BoxConstraints(maxWidth: kChatReadingWidth),
|
|
child: Padding(
|
|
key: const Key('chat-composer'),
|
|
padding: EdgeInsetsDirectional.fromSTEB(
|
|
16,
|
|
8,
|
|
16,
|
|
chatComposerBottomMargin(),
|
|
),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
if (commands.isNotEmpty)
|
|
Padding(
|
|
padding: const EdgeInsetsDirectional.only(bottom: 8),
|
|
child: ChatCommandPalette(
|
|
commands: commands,
|
|
selectedIndex: selected,
|
|
onSelected: _completeCommand,
|
|
),
|
|
),
|
|
// The pill pops in with the app's shared entrance, as
|
|
// the bar's pieces do, once per chat: this state is keyed
|
|
// by the chat, and a rebuild (typing, the keyboard, a
|
|
// sheet closing) never replays it. It only paints, so the
|
|
// field takes focus and keys at once while it plays.
|
|
PopEntrance(
|
|
key: const ValueKey('chat-composer-entrance'),
|
|
child: _pill(
|
|
context,
|
|
Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
if (extras.isNotEmpty)
|
|
Padding(
|
|
padding: const EdgeInsetsDirectional.fromSTEB(
|
|
12,
|
|
8,
|
|
12,
|
|
0,
|
|
),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment:
|
|
CrossAxisAlignment.stretch,
|
|
children: extras,
|
|
),
|
|
),
|
|
LayoutBuilder(
|
|
builder: (context, constraints) => Row(
|
|
crossAxisAlignment: CrossAxisAlignment.end,
|
|
children: [
|
|
_attach(context),
|
|
Expanded(
|
|
child: Focus(
|
|
canRequestFocus: false,
|
|
includeSemantics: false,
|
|
onKeyEvent: _onKey,
|
|
child: _field(),
|
|
),
|
|
),
|
|
// Shown only while tasks run (or their list
|
|
// cannot be read); a quiet control, not a
|
|
// caption.
|
|
if (widget.backgroundTasks != null)
|
|
ConstrainedBox(
|
|
constraints: BoxConstraints(
|
|
maxWidth: constraints.maxWidth * .30,
|
|
),
|
|
child: widget.backgroundTasks!,
|
|
),
|
|
if (widget.running) ...[
|
|
_primary(context, stop: true),
|
|
const SizedBox(width: 4),
|
|
],
|
|
_primary(context),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
static const OutlinedBorder _pillShape = RoundedRectangleBorder(
|
|
borderRadius: BorderRadius.all(Radius.circular(28)),
|
|
);
|
|
|
|
/// The field and its controls in one frosted-glass surface floating over
|
|
/// the transcript, so the composer reads as a single input rather than a
|
|
/// row of separate controls, and the conversation shows through it. While
|
|
/// the field has focus a ring in the chat's colour runs along its edge.
|
|
Widget _pill(BuildContext context, Widget child) => ComposerFocusRing(
|
|
focus: _focus,
|
|
accent: chatFocusRingColor(context, widget.chatColor),
|
|
shape: _pillShape,
|
|
child: GlassPill(
|
|
key: const Key('chat-composer-pill'),
|
|
shape: _pillShape,
|
|
// The end controls keep the same gap from the pill's sides as from
|
|
// its bottom (and its top while the field is one line).
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(GlassBarMetrics.fieldEdgeGap),
|
|
child: child,
|
|
),
|
|
),
|
|
);
|
|
|
|
/// The attach control: a host button that opens the picker, disabled when the
|
|
/// host has no picker or one prompt is already awaiting its reply.
|
|
Widget _attach(BuildContext context) {
|
|
final enabled = _picker.isSupported && !widget.composer.sending;
|
|
final onPressed = enabled ? () => unawaited(_pickAttachments()) : null;
|
|
return IconButton(
|
|
key: const Key('chat-composer-attach'),
|
|
tooltip: chatAttachLabel,
|
|
onPressed: onPressed,
|
|
icon: const Icon(Icons.add),
|
|
);
|
|
}
|
|
|
|
/// The files attached to the next message. Each chip carries only the
|
|
/// operator's recorded name and a native remove action.
|
|
Widget _attachmentStrip(BuildContext context) {
|
|
final attachments = _attachments.attachments;
|
|
return Padding(
|
|
key: const Key('chat-composer-attachments'),
|
|
padding: const EdgeInsetsDirectional.only(bottom: 8),
|
|
child: Wrap(
|
|
spacing: 8,
|
|
runSpacing: 4,
|
|
children: [
|
|
for (var index = 0; index < attachments.length; index += 1)
|
|
if (_imageBytes(index) case final bytes?)
|
|
_imageThumbnail(context, attachments[index], bytes, index)
|
|
else
|
|
_materialChip(attachments[index], index),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
/// The pasted or picked bytes of an image attachment, or null for any other
|
|
/// file.
|
|
Uint8List? _imageBytes(int index) {
|
|
final attachment = _attachments.attachments[index];
|
|
if (!attachment.mime.toLowerCase().startsWith('image/')) return null;
|
|
if (index >= _bytes.length || _bytes[index].isEmpty) return null;
|
|
return _bytes[index];
|
|
}
|
|
|
|
/// An image attachment as a small thumbnail with its remove control in the
|
|
/// corner; its name is the accessible label.
|
|
Widget _imageThumbnail(
|
|
BuildContext context,
|
|
ChatAttachment attachment,
|
|
Uint8List bytes,
|
|
int index,
|
|
) {
|
|
return Semantics(
|
|
key: ValueKey<String>('chat-composer-attachment-$index'),
|
|
container: true,
|
|
explicitChildNodes: true,
|
|
label: attachment.name,
|
|
image: true,
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
SizedBox.square(
|
|
dimension: 72,
|
|
child: Stack(
|
|
clipBehavior: Clip.none,
|
|
children: [
|
|
Positioned.fill(
|
|
child: ChatAttachmentFrame(
|
|
radius: BorderRadius.circular(10),
|
|
child: Image.memory(
|
|
bytes,
|
|
key: ValueKey<String>('chat-composer-thumbnail-$index'),
|
|
fit: BoxFit.cover,
|
|
errorBuilder: (_, _, _) =>
|
|
const Center(child: Icon(Icons.image_outlined)),
|
|
),
|
|
),
|
|
),
|
|
Positioned(
|
|
top: -6,
|
|
right: -6,
|
|
child: Semantics(
|
|
button: true,
|
|
label: 'Remove ${attachment.name}',
|
|
onTap: () => _removeAttachmentAt(index),
|
|
child: ExcludeSemantics(
|
|
child: GestureDetector(
|
|
key: ValueKey<String>(
|
|
'chat-composer-attachment-remove-$index',
|
|
),
|
|
onTap: () => _removeAttachmentAt(index),
|
|
child: Container(
|
|
decoration: const BoxDecoration(
|
|
color: Color(0xCC000000),
|
|
shape: BoxShape.circle,
|
|
),
|
|
padding: const EdgeInsets.all(2),
|
|
child: const Icon(
|
|
Icons.close,
|
|
size: 14,
|
|
color: Color(0xFFFFFFFF),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
// The name under the picture, one line.
|
|
SizedBox(
|
|
width: 72,
|
|
child: Text(
|
|
attachment.name,
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
textAlign: TextAlign.center,
|
|
style: const TextStyle(fontSize: 11),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _materialChip(ChatAttachment attachment, int index) => Chip(
|
|
key: ValueKey<String>('chat-composer-attachment-$index'),
|
|
label: Text(attachment.name),
|
|
onDeleted: () => _removeAttachmentAt(index),
|
|
deleteButtonTooltipMessage: 'Remove ${attachment.name}',
|
|
);
|
|
|
|
/// The most lines the field grows to before it scrolls: up to
|
|
/// [_composerMaxLines], but never more than about 40% of the visible
|
|
/// height (the keyboard excluded), so the conversation stays in view.
|
|
static const int _composerMaxLines = 12;
|
|
|
|
int _maxLines(BuildContext context) {
|
|
final media = MediaQuery.of(context);
|
|
// The scaffold hides the keyboard from its body; the window still has it.
|
|
final keyboard =
|
|
MediaQueryData.fromView(View.of(context)).viewInsets.bottom /
|
|
UiScaleHost.of(context);
|
|
final visible = media.size.height - keyboard;
|
|
final lineHeight = MediaQuery.textScalerOf(context).scale(22);
|
|
final fit = (visible * 0.4 / lineHeight).floor();
|
|
return fit.clamp(3, _composerMaxLines);
|
|
}
|
|
|
|
Widget _field() {
|
|
final maxLines = _maxLines(context);
|
|
return TextField(
|
|
key: const Key('chat-composer-field'),
|
|
controller: _text,
|
|
focusNode: _focus,
|
|
scrollController: _fieldScroll,
|
|
minLines: 1,
|
|
maxLines: maxLines,
|
|
keyboardType: TextInputType.multiline,
|
|
textInputAction: _enterSends
|
|
? TextInputAction.send
|
|
: TextInputAction.newline,
|
|
onEditingComplete: () {},
|
|
onSubmitted: (_) => _submitDraft(),
|
|
onChanged: _onDraftEdited,
|
|
decoration: InputDecoration(
|
|
hintText: widget.placeholder,
|
|
// Let a long folder name wrap when the attach and primary controls
|
|
// leave little horizontal room.
|
|
hintMaxLines: 2,
|
|
// The pill draws the field's surface; the field adds no border.
|
|
border: InputBorder.none,
|
|
isDense: true,
|
|
contentPadding: const EdgeInsets.symmetric(vertical: 12),
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _primary(BuildContext context, {bool stop = false}) {
|
|
final composer = widget.composer;
|
|
final enabled = stop
|
|
? !composer.stopping
|
|
: !_uploading &&
|
|
!_shellStarting &&
|
|
!composer.sending &&
|
|
composer.draft.trim().isNotEmpty;
|
|
void press() {
|
|
if (stop) {
|
|
unawaited(composer.stop());
|
|
return;
|
|
}
|
|
final commands = _paletteCommands();
|
|
if (commands.isNotEmpty) {
|
|
_completeCommand(commands[_selectedCommand % commands.length]);
|
|
} else if (chatDraftIsShell(composer.draft)) {
|
|
unawaited(_runShellDraft());
|
|
} else if (chatCommandWord(composer.draft) != null) {
|
|
_runSlashDraft();
|
|
} else {
|
|
unawaited(_send());
|
|
}
|
|
}
|
|
|
|
// Sending while the turn runs uses the server's existing queued-prompt path.
|
|
// Stopping is always a separate, explicitly named action.
|
|
final label = stop
|
|
? chatStopLabel
|
|
: chatDraftIsShell(composer.draft)
|
|
? chatRunShellLabel
|
|
: chatSendLabel;
|
|
final key = Key(stop ? 'chat-composer-stop' : 'chat-composer-primary');
|
|
// A coloured chat's send button takes the chat's colour (its seeded
|
|
// primary, like the focus ring); stop stays the host's error red.
|
|
final tinted = chatSchemeOf(context, widget.chatColor);
|
|
final scheme = Theme.of(context).colorScheme;
|
|
return IconButton.filled(
|
|
key: key,
|
|
tooltip: label,
|
|
style: stop
|
|
? IconButton.styleFrom(
|
|
backgroundColor: scheme.error,
|
|
foregroundColor: scheme.onError,
|
|
)
|
|
: tinted == null
|
|
? null
|
|
: IconButton.styleFrom(
|
|
backgroundColor: tinted.primary,
|
|
foregroundColor: tinted.onPrimary,
|
|
),
|
|
onPressed: enabled ? press : null,
|
|
icon: stop
|
|
? const ChatStopIcon(child: Icon(Icons.stop))
|
|
: const Icon(Icons.arrow_upward),
|
|
);
|
|
}
|
|
|
|
/// The local command report: a failed line in the composer's own notice
|
|
/// shape, plus the offer's two host controls when an unknown command can be
|
|
/// sent as a message. Neither action is a prompt until the operator chooses
|
|
/// "Send as message".
|
|
Widget _commandReport(BuildContext context) {
|
|
final offer = _commandOffer;
|
|
return Column(
|
|
key: const Key('chat-composer-command-notice'),
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: Text(
|
|
_commandFailed
|
|
? chatCommandFailedLabel
|
|
: chatCommandNoticeLabel,
|
|
style: TextStyle(
|
|
color: _commandFailed
|
|
? Theme.of(context).colorScheme.error
|
|
: null,
|
|
),
|
|
),
|
|
),
|
|
IconButton(
|
|
key: const Key('chat-command-dismiss'),
|
|
tooltip: chatCommandDismissLabel,
|
|
onPressed: () => setState(_dismissCommandReport),
|
|
icon: const Icon(Icons.close),
|
|
),
|
|
],
|
|
),
|
|
_notice(
|
|
context,
|
|
key: const Key('chat-composer-command-text'),
|
|
text: _commandNotice!,
|
|
failed: _commandFailed,
|
|
),
|
|
if (offer != null)
|
|
Padding(
|
|
padding: const EdgeInsetsDirectional.only(bottom: 8),
|
|
child: Wrap(
|
|
alignment: WrapAlignment.end,
|
|
spacing: 8,
|
|
runSpacing: 4,
|
|
children: [
|
|
_commandAction(
|
|
key: const Key('chat-command-send-as-message'),
|
|
label: chatCommandSendAsMessageLabel,
|
|
onPressed: () => unawaited(_sendOffered()),
|
|
),
|
|
_commandAction(
|
|
key: const Key('chat-command-cancel'),
|
|
label: chatCommandCancelLabel,
|
|
onPressed: () => setState(_dismissCommandReport),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
Widget _commandAction({
|
|
required Key key,
|
|
required String label,
|
|
required VoidCallback onPressed,
|
|
}) {
|
|
return TextButton(key: key, onPressed: onPressed, child: Text(label));
|
|
}
|
|
|
|
/// A polite, secondary line for queued/refused state. The error uses the
|
|
/// host's own semantic error tint, never a bespoke palette.
|
|
Widget _notice(
|
|
BuildContext context, {
|
|
required Key key,
|
|
required String text,
|
|
bool failed = false,
|
|
}) {
|
|
final theme = Theme.of(context);
|
|
final color = failed
|
|
? theme.colorScheme.error
|
|
: theme.colorScheme.onSurfaceVariant;
|
|
final style = theme.textTheme.bodyMedium?.copyWith(color: color);
|
|
return Semantics(
|
|
liveRegion: true,
|
|
child: Padding(
|
|
key: key,
|
|
padding: const EdgeInsets.only(bottom: 8),
|
|
child: Text(text, style: style),
|
|
),
|
|
);
|
|
}
|
|
}
|