import 'dart:async'; import 'dart:math' as math; import 'package:flutter/cupertino.dart'; import 'package:flutter/material.dart'; import 'package:flutter/services.dart'; import '../../../core/api_gateway.dart'; import '../../../core/transport/pipelines_client.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 '../ui/sessions/chat_adaptive.dart'; import 'chat_command_actions.dart'; import 'chat_command_palette.dart'; import 'chat_composer_controller.dart'; /// The composer's multiline placeholder, verbatim from the web client. const String chatComposerPlaceholder = 'Message the agent… or / for commands'; /// The single primary control's words while a turn is and is not running. const String chatSendLabel = 'Send'; const String chatStopLabel = 'Stop'; /// 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 one primary /// Send/Stop control, driven by the landed [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 inserts a newline and Ctrl/Cmd+Enter /// sends the plain message. 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, }); final ChatComposerController composer; /// 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; it alone decides Send versus Stop. final bool running; /// The host picker seam; production uses [hostChatAttachmentPicker]. final ChatAttachmentPicker? picker; /// The host clipboard-file seam; production uses [hostChatClipboardPaste]. final ChatClipboardPaste? paste; @override State createState() => _ChatComposerBarState(); } class _ChatComposerBarState extends State { late final TextEditingController _text = TextEditingController( text: widget.composer.draft, ); final FocusNode _focus = FocusNode(debugLabel: 'chat-composer'); 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 _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 _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; ChatAttachmentPicker get _picker => widget.picker ?? hostChatAttachmentPicker; ChatClipboardPaste get _paste => widget.paste ?? hostChatClipboardPaste; ChatPasteUnsubscribe? _stopPaste; @override void initState() { super.initState(); widget.composer.addListener(_syncDraft); _listenForPaste(); unawaited(widget.composer.loadDraft()); } @override void didUpdateWidget(covariant ChatComposerBar oldWidget) { super.didUpdateWidget(oldWidget); if (oldWidget.composer != widget.composer) { oldWidget.composer.removeListener(_syncDraft); widget.composer.addListener(_syncDraft); _syncDraft(); } if (oldWidget.paste != widget.paste) { _stopListeningForPaste(); _listenForPaste(); } } void _listenForPaste() { if (!_paste.isSupported) return; _stopPaste = _paste.listen( onFiles: _onPastedFiles, canAccept: _canAcceptPaste, onError: _onPasteError, ); } void _stopListeningForPaste() { final stop = _stopPaste; _stopPaste = null; stop?.call(); } /// A pasted file is taken only while this composer owns the field and no /// prompt is in flight, which is the same window as the attach control. The /// host checks this before it suppresses the paste's default behaviour, so a /// paste elsewhere is never swallowed. bool _canAcceptPaste() => mounted && _focus.hasFocus && !widget.composer.sending; void _onPastedFiles(List 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 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 _paletteCommands() { final draft = widget.composer.draft; if (_paletteClosedFor == draft) return const []; 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)); } KeyEventResult _onKey(FocusNode node, KeyEvent event) { final key = event.logicalKey; final commands = _paletteCommands(); final word = chatCommandWord(widget.composer.draft); final slashDraft = word != null; 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; // A plain Enter accepts the highlighted command instead of sending it. With // no palette showing, a slash draft is still a command, never a prompt. if (!sendShortcut && !keyboard.isShiftPressed) { if (commands.isNotEmpty) { if (event is! KeyDownEvent) return KeyEventResult.handled; _completeCommand(commands[_selectedCommand % commands.length]); return KeyEventResult.handled; } if (slashDraft) { if (event is! KeyDownEvent) return KeyEventResult.handled; _runSlashDraft(); return KeyEventResult.handled; } } if (!sendShortcut) return KeyEventResult.ignored; // A held key must not post a second prompt. if (event is! KeyDownEvent) return KeyEventResult.handled; // Ctrl/Cmd+Enter is the same submit: a visible palette completes, and a // slash draft reports locally. Only plain text reaches the prompt path. if (commands.isNotEmpty) { _completeCommand(commands[_selectedCommand % commands.length]); return KeyEventResult.handled; } if (slashDraft) { _runSlashDraft(); return KeyEventResult.handled; } unawaited(_send()); return KeyEventResult.handled; } /// 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 _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 _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 _send() async { final composer = widget.composer; if (_uploading || composer.sending || composer.draft.trim().isEmpty) { return; } List 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 => _uploaded[attachment] ??= await uploadChatAttachment(endpoint, attachment, bytes), ); } } 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(); final accepted = await composer.send(attachments: parts); if (!mounted) return; if (accepted) { setState(() { _replaceAttachments(const [], const []); _attachmentError = null; }); } } /// 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 _pickAttachments() async { if (widget.composer.sending || !_picker.isSupported) return; List? 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 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.from(_attachments.attachments) ..removeAt(index); final remainingBytes = List.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 attachments, List 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(); widget.composer.removeListener(_syncDraft); _text.dispose(); _focus.dispose(); super.dispose(); } @override Widget build(BuildContext context) { final cupertino = chatControlsStyleOf(context) == ChatControlsStyle.cupertino; 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; return SafeArea( top: false, child: Padding( key: const Key('chat-composer'), padding: const EdgeInsetsDirectional.fromSTEB(16, 8, 16, 8), 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, ), ), if (!_attachments.isEmpty) _attachmentStrip(context, cupertino), if (_uploading) _notice( context, cupertino, key: const Key('chat-composer-uploading'), text: _attachments.attachments.length == 1 ? 'Uploading 1 file…' : 'Uploading ${_attachments.attachments.length} files…', ), if (_attachmentError != null) _notice( context, cupertino, key: const Key('chat-composer-attachment-error'), text: _attachmentError!, failed: true, ), if (_commandNotice != null) _commandReport(context, cupertino), if (composer.queued) _notice( context, cupertino, key: const Key('chat-composer-queued'), text: chatQueuedNotice, ), if (error != null) _notice( context, cupertino, key: const Key('chat-composer-error'), text: error, failed: true, ), Row( crossAxisAlignment: CrossAxisAlignment.end, children: [ _attach(context, cupertino), const SizedBox(width: 8), Expanded( child: Focus( canRequestFocus: false, includeSemantics: false, onKeyEvent: _onKey, child: _field(cupertino), ), ), const SizedBox(width: 8), _primary(context, cupertino), ], ), ], ), ), ); }, ); } /// 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, bool cupertino) { final enabled = _picker.isSupported && !widget.composer.sending; final onPressed = enabled ? () => unawaited(_pickAttachments()) : null; if (cupertino) { return Semantics( label: chatAttachLabel, button: true, enabled: enabled, child: ExcludeSemantics( child: CupertinoButton( key: const Key('chat-composer-attach'), padding: EdgeInsets.zero, onPressed: onPressed, child: const Icon(CupertinoIcons.paperclip), ), ), ); } return IconButton( key: const Key('chat-composer-attach'), tooltip: chatAttachLabel, onPressed: onPressed, icon: const Icon(Icons.attach_file), ); } /// 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, bool cupertino) { 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 if (cupertino) _cupertinoChip(context, attachments[index], 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, ) { final cupertino = chatControlsStyleOf(context) == ChatControlsStyle.cupertino; return Semantics( key: ValueKey('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: ClipRRect( borderRadius: BorderRadius.circular(10), child: Image.memory( bytes, key: ValueKey('chat-composer-thumbnail-$index'), fit: BoxFit.cover, errorBuilder: (_, _, _) => Center( child: Icon( cupertino ? CupertinoIcons.photo : 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( '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: Icon( cupertino ? CupertinoIcons.xmark : Icons.close, size: 14, color: const 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('chat-composer-attachment-$index'), label: Text(attachment.name), onDeleted: () => _removeAttachmentAt(index), deleteButtonTooltipMessage: 'Remove ${attachment.name}', ); /// Cupertino has no chip control, so the host's capsule fill and its own /// button carry the same name and remove action. Widget _cupertinoChip( BuildContext context, ChatAttachment attachment, int index, ) { return Semantics( container: true, explicitChildNodes: true, child: DefaultTextStyle.merge( style: CupertinoTheme.of(context).textTheme.textStyle, child: DecoratedBox( key: ValueKey('chat-composer-attachment-$index'), decoration: ShapeDecoration( shape: const StadiumBorder(), color: CupertinoColors.secondarySystemFill.resolveFrom(context), ), child: Padding( padding: const EdgeInsetsDirectional.fromSTEB(12, 4, 4, 4), child: Row( mainAxisSize: MainAxisSize.min, children: [ Flexible( child: Text(attachment.name, overflow: TextOverflow.ellipsis), ), const SizedBox(width: 4), Semantics( container: true, button: true, label: 'Remove ${attachment.name}', onTap: () => _removeAttachmentAt(index), child: ExcludeSemantics( child: CupertinoButton( key: ValueKey( 'chat-composer-attachment-remove-$index', ), padding: EdgeInsets.zero, onPressed: () => _removeAttachmentAt(index), child: Icon( CupertinoIcons.xmark_circle_fill, color: CupertinoColors.secondaryLabel.resolveFrom( context, ), ), ), ), ), ], ), ), ), ), ); } /// The lines the composer placeholder needs at [width] (the field's /// default 7px side padding excluded), capped at 3. int _placeholderLines(BuildContext context, double width) { if (!width.isFinite) return 1; final painter = TextPainter( text: TextSpan( text: chatComposerPlaceholder, style: CupertinoTheme.of(context).textTheme.textStyle, ), textDirection: Directionality.of(context), textScaler: MediaQuery.textScalerOf(context), maxLines: 3, )..layout(maxWidth: math.max(0, width - 14)); final lines = painter.computeLineMetrics().length; painter.dispose(); return lines.clamp(1, 3); } Widget _field(bool cupertino) { if (cupertino) { // CupertinoTextField lays its placeholder out with up to maxLines lines // but sizes an empty field by minLines, so a wrapped placeholder was // clipped on a narrow pane. While empty the field is exactly as tall as // its placeholder (at most 3 lines, then ellipsised); typing restores // the normal 1-6 lines. return LayoutBuilder( builder: (context, constraints) { final empty = _text.text.isEmpty; final lines = empty ? _placeholderLines(context, constraints.maxWidth) : 1; return CupertinoTextField( key: const Key('chat-composer-field'), controller: _text, focusNode: _focus, placeholder: chatComposerPlaceholder, placeholderStyle: const TextStyle( color: CupertinoColors.placeholderText, overflow: TextOverflow.ellipsis, ), minLines: lines, maxLines: empty ? lines : 6, keyboardType: TextInputType.multiline, textInputAction: TextInputAction.newline, onChanged: _onDraftEdited, ); }, ); } return TextField( key: const Key('chat-composer-field'), controller: _text, focusNode: _focus, minLines: 1, maxLines: 6, keyboardType: TextInputType.multiline, textInputAction: TextInputAction.newline, onChanged: _onDraftEdited, decoration: const InputDecoration( hintText: chatComposerPlaceholder, // Let the complete, web-matched hint wrap when the attachment and // primary controls leave little horizontal room. hintMaxLines: 2, border: OutlineInputBorder(), ), ); } Widget _primary(BuildContext context, bool cupertino) { final composer = widget.composer; final stop = widget.running; final enabled = stop ? !composer.stopping : !_uploading && !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 (chatCommandWord(composer.draft) != null) { _runSlashDraft(); } else { unawaited(_send()); } } // One icon control, named Send or Stop for assistive technology: a send // arrow, or a stop square in the error colour while a turn runs. final label = stop ? chatStopLabel : chatSendLabel; if (cupertino) { return Semantics( button: true, label: label, excludeSemantics: true, child: CupertinoButton.filled( key: const Key('chat-composer-primary'), sizeStyle: CupertinoButtonSize.small, color: stop ? CupertinoColors.systemRed.resolveFrom(context) : null, onPressed: enabled ? press : null, child: Icon( stop ? CupertinoIcons.stop_fill : CupertinoIcons.arrow_up, size: 18, ), ), ); } final scheme = Theme.of(context).colorScheme; return IconButton.filled( key: const Key('chat-composer-primary'), tooltip: label, style: stop ? IconButton.styleFrom( backgroundColor: scheme.error, foregroundColor: scheme.onError, ) : null, onPressed: enabled ? press : null, icon: Icon(stop ? Icons.stop : Icons.send), ); } /// 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, bool cupertino) { 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 ? (cupertino ? CupertinoColors.systemRed.resolveFrom(context) : Theme.of(context).colorScheme.error) : null, ), ), ), if (cupertino) Semantics( button: true, label: chatCommandDismissLabel, child: CupertinoButton( key: const Key('chat-command-dismiss'), padding: EdgeInsets.zero, onPressed: () => setState(_dismissCommandReport), child: const Text('Dismiss'), ), ) else IconButton( key: const Key('chat-command-dismiss'), tooltip: chatCommandDismissLabel, onPressed: () => setState(_dismissCommandReport), icon: const Icon(Icons.close), ), ], ), _notice( context, cupertino, 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( cupertino, key: const Key('chat-command-send-as-message'), label: chatCommandSendAsMessageLabel, onPressed: () => unawaited(_sendOffered()), ), _commandAction( cupertino, key: const Key('chat-command-cancel'), label: chatCommandCancelLabel, onPressed: () => setState(_dismissCommandReport), ), ], ), ), ], ); } Widget _commandAction( bool cupertino, { required Key key, required String label, required VoidCallback onPressed, }) { if (cupertino) { return CupertinoButton( key: key, padding: EdgeInsets.zero, onPressed: onPressed, child: Text(label), ); } 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, bool cupertino, { required Key key, required String text, bool failed = false, }) { final theme = Theme.of(context); final color = failed ? (cupertino ? CupertinoColors.systemRed.resolveFrom(context) : theme.colorScheme.error) : (cupertino ? CupertinoColors.secondaryLabel.resolveFrom(context) : theme.colorScheme.onSurfaceVariant); final style = (cupertino ? CupertinoTheme.of(context).textTheme.textStyle : 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), ), ); } }