import 'dart:async'; import 'package:flutter/cupertino.dart'; import 'package:flutter/material.dart'; import 'package:flutter/rendering.dart'; import '../../../core/api_gateway.dart'; import '../../../shell/shell_bar.dart'; import '../data/chat_repository.dart'; import '../domain/chat_activity_detail.dart'; import '../domain/chat_notice.dart'; import '../domain/chat_attachment_picker.dart'; import '../domain/chat_transcript.dart'; import '../ui/sessions/chat_adaptive.dart'; import '../ui/sessions/session_actions.dart'; import '../ui/transcript/chat_markdown_view.dart'; import '../ui/transcript/chat_message_view.dart'; import 'chat_background_tasks.dart'; import 'chat_command_actions.dart'; import 'chat_composer_bar.dart'; import 'chat_composer_controller.dart'; import 'chat_draft_store.dart'; import 'chat_model_control.dart'; import 'chat_models.dart'; import 'chat_row_keys.dart'; import 'chat_scroll.dart'; import 'chat_thread_controller.dart'; import 'chat_transcript_card.dart'; /// One read-only conversation: the controller's transcript in the order the /// server reports it, rendered by the existing [ChatMessageView]. /// /// Assistant text goes through [ChatMarkdownView]'s builder, so stored and live /// prose share the supported markdown subset. User text keeps the server's exact /// characters, and reasoning/tool disclosures stay plain text. /// /// History and live-subscription failures are separate notices: readable stored /// history must never hide a refused live watch. The shell owns the navigation /// bar, so this view adds only its own Back control and content. class ChatThreadView extends StatefulWidget { const ChatThreadView({ super.key, required this.gateway, required this.sessionId, required this.onBack, this.title = '', this.session, this.onModelChanged, this.syncToken = 0, this.drafts, this.newOperationId, this.attachmentPicker, this.scrollPositions, this.initialNotice, this.onCreatedSession, this.onSessionRenamed, this.onSessionClosed, }); final ApiGateway gateway; final String sessionId; final VoidCallback onBack; /// The local line this conversation opens on: the destination hands over /// the `/new` notice for a session it just created and opened. final String? initialNotice; /// `/new` created this row; the destination lists it, opens it with the /// notice and refreshes the list. Without a destination the notice shows /// here instead, since the session already exists on the server. final ChatCreatedSessionCallback? onCreatedSession; /// `/rename` was accepted with this title, so the header can follow it. final ValueChanged? onSessionRenamed; /// `/close` was accepted: the conversation is finished here as on the web. final VoidCallback? onSessionClosed; /// The list row's title when this visit knows it; a deep link may not. final String title; /// The opened row's recorded facts when this visit knows them. The model /// control reads its current model from this row; the destination supplies /// it from the tapped row or from the list's loaded rows for a routed id. final JsonMap? session; /// The server's echo after an accepted model switch, so the destination can /// keep the row it opened current for the next visit. final ValueChanged? onModelChanged; /// Advances when the shared socket is replaced, keeping this selection. final int syncToken; /// Draft persistence for tests and previews; production uses the app store. final ChatDraftStore? drafts; /// Test/fixture seam for deterministic operation ids. final String Function()? newOperationId; /// Host picker seam for the thread's composer. final ChatAttachmentPicker? attachmentPicker; /// The destination's per-conversation scroll store. The screen supplies one /// that outlives this view, so a conversation opened again returns to where /// the operator left it. Null keeps the view stateless across visits. final ChatScrollStore? scrollPositions; @override State createState() => _ChatThreadViewState(); } class _ChatThreadViewState extends State { late ChatThreadController _controller = _attach(); late ChatComposerController _composer = _attachComposer(); late ChatRowKeys _rowKeys = ChatRowKeys(); /// Local notices the operator hid; cleared when the conversation or socket /// changes so a reconnect never keeps a stale dismissal. ChatNoticeDismissals _dismissals = ChatNoticeDismissals(); /// True while a reconnect repair is in flight: notices recorded before the /// gap are stale, so none is drawn until the repair reports fresh state. bool _reconnecting = false; int _syncGeneration = 0; /// The transcript held when the socket was replaced. A running state recorded /// before the gap cannot be trusted again until a fresh read or frame /// replaces that transcript. List? _preGapMessages; /// The chain that repairs the newest socket gap. A second gap waits for an /// in-flight repair instead of treating the controller's immediate return as /// completion, which would expose stale notices mid-repair. Future? _repair; /// The lines this conversation's slash commands produced, in order. They are /// this conversation's own: a session switch starts over from the /// destination's handoff, and a dismissal removes one. final List _commandNotices = []; int _commandNoticeSeq = 0; final ScrollController _scroll = ScrollController(); /// True while the transcript's end is in view. The operator's own upward /// scroll releases it; only returning to the end (or the jump control) arms /// it again. bool _following = true; /// The measured distance from the transcript's end, or null before layout. /// Not every scrolled pixel rebuilds the view; the jump control only needs to /// know whether the end is beyond the follow threshold. double? _distanceFromBottom; /// The conversation's saved position, read when this view is attached and /// consumed by the first placement after the history arrives. double? _savedOffset; bool _placed = false; bool _pinScheduled = false; /// A saved position is being re-applied while the lazy transcript's measured /// extent is still settling. Until it stops growing, an apparent "bottom" /// would be a stale estimate and would silently turn a restored read into a /// follow. double? _restoreOffset; bool _restoring = false; double _restoreMeasuredExtent = 0; /// True during a pointer/touch/wheel scroll. Programmatic placement and /// follow jumps never set it, so they cannot release the follow intent. bool _userScrolling = false; /// The last measured offset. Kept separately because the scrollable can /// detach before this state is disposed; disposal still has to save where the /// operator was. double _lastOffset = 0; /// The newest message id when the operator left the end. Later messages are /// counted against it for the jump control's arrival count. String? _newestAtRelease; ChatThreadController _attach() => ChatThreadController(widget.gateway, widget.sessionId)..load(); ChatComposerController _attachComposer() => ChatComposerController( widget.gateway, widget.sessionId, drafts: widget.drafts, newOperationId: widget.newOperationId, onOptimistic: _onOptimistic, onRejected: _onRejected, ); void _onOptimistic(ChatComposerSend send) { if (!mounted) return; _controller.insertLocal({ 'id': send.optimisticId, 'session_id': send.sessionId, 'role': 'user', 'operation_id': send.operationId, 'native_message_id': send.nativeMessageId, 'parts': [ {'type': 'text', 'text': send.text}, for (final attachment in send.attachments) { 'type': 'file', 'name': attachment['name'], 'uri': attachment['name'], 'mime': attachment['mime'], }, ], }); } void _onRejected(ChatComposerSend send, String error) { if (!mounted) return; _controller.removeLocal(send.operationId); } /// Reports the harness's recorded usage. The standard sheet is dismissed the /// platform's way (drag/barrier/Back, or a popup tap) and closes explicitly. Future _openInfo() async { final cupertino = chatControlsStyleOf(context) == ChatControlsStyle.cupertino; if (cupertino) { await showCupertinoModalPopup( context: context, builder: (sheetContext) => Align( alignment: Alignment.bottomCenter, child: SafeArea( child: CupertinoPopupSurface( child: _ChatInfoSheet(controller: _controller), ), ), ), ); return; } await showModalBottomSheet( context: context, showDragHandle: true, isScrollControlled: true, useSafeArea: true, builder: (sheetContext) => _ChatInfoSheet(controller: _controller), ); } /// The transcript in recorded order; a sent turn is part of it from the /// moment it is sent (ChatThreadController.insertLocal). List _visibleMessages() => _controller.messages; void _seedCommandNotice() { final notice = widget.initialNotice; if (notice == null || notice.isEmpty) return; _commandNotices.add( chatCommandNotice(notice, sequence: ++_commandNoticeSeq), ); } void _showCommandNotice(String text, {bool failed = false}) { if (!mounted) return; setState(() { _commandNotices.add( chatCommandNotice(text, sequence: ++_commandNoticeSeq, failed: failed), ); }); } /// The runner for this session's `/new`, `/close` and `/rename`, rebuilt per /// build so an adopted row's directory and title are the current ones. ChatCommandActions _commandActions() { final session = widget.session ?? {'id': widget.sessionId, 'title': widget.title}; final onCreated = widget.onCreatedSession; return ChatCommandActions( repository: ChatRepository(widget.gateway), sessionId: widget.sessionId, directory: '${session['directory'] ?? ''}'.trim(), showNotice: _showCommandNotice, confirmClose: () => confirmCloseChat(context, session), openCreatedSession: onCreated ?? (created, notice) => _showCommandNotice(notice), onRenamed: widget.onSessionRenamed, onClosed: widget.onSessionClosed, newOperationId: widget.newOperationId, ); } @override void initState() { super.initState(); _savedOffset = widget.scrollPositions?.read(widget.sessionId); _seedCommandNotice(); } @override void didUpdateWidget(covariant ChatThreadView oldWidget) { super.didUpdateWidget(oldWidget); if (oldWidget.gateway != widget.gateway || oldWidget.sessionId != widget.sessionId) { // The conversation being left keeps the position the operator chose. _persistPosition(oldWidget.sessionId); _controller.dispose(); _composer.dispose(); _controller = _attach(); _composer = _attachComposer(); _rowKeys = ChatRowKeys(); _dismissals = ChatNoticeDismissals(); _reconnecting = false; _preGapMessages = null; _syncGeneration++; _commandNotices.clear(); _seedCommandNotice(); _savedOffset = widget.scrollPositions?.read(widget.sessionId); _placed = false; _following = true; _distanceFromBottom = null; _newestAtRelease = null; _userScrolling = false; _restoring = false; _restoreOffset = null; _restoreMeasuredExtent = 0; _lastOffset = 0; } else if (oldWidget.syncToken != widget.syncToken) { // The socket was replaced: conditions recorded before the gap are stale, // so no earlier dismissal survives and nothing recorded before the gap is // painted while the repair runs. _dismissals.clear(); _preGapMessages = _controller.messages; _reconnecting = true; final generation = ++_syncGeneration; final previous = _repair; final repair = (previous ?? Future.value()) .then((_) async { // A newer gap owns the repair; its own step in this chain runs next. if (!mounted || generation != _syncGeneration) return; await _controller.resync(); }) .whenComplete(() { if (!mounted || generation != _syncGeneration) return; setState(() { _reconnecting = false; // A successful repair replaced the transcript with fresh state. if (!identical(_controller.messages, _preGapMessages)) { _preGapMessages = null; } }); }); _repair = repair; unawaited(repair); } } @override void dispose() { _persistPosition(); _scroll.dispose(); _composer.dispose(); _controller.dispose(); super.dispose(); } /// The ids of the transcript's messages in view order. Cards are conversation /// state, not messages, so a pending approval does not count as an arrival. List _messageIds() => [ for (final message in _visibleMessages()) if ('${message['id'] ?? ''}'.trim().isNotEmpty) '${message['id']}'.trim(), ]; String? _newestMessageId() { final ids = _messageIds(); return ids.isEmpty ? null : ids.last; } /// Writes the operator's position for the conversation being left: a /// deliberate position is remembered, following the end is not. Called on a /// scroll's end, a conversation switch and disposal. void _persistPosition([String? sessionId]) { final store = widget.scrollPositions; final id = sessionId ?? widget.sessionId; if (store == null || !_placed || _restoring) return; if (_following) { store.clear(id); return; } if (_scroll.hasClients) { store.write(id, _scroll.position.pixels); } else { store.write(id, _lastOffset); } } /// Measured distance from the end for the current content. double? _distanceFor(ScrollMetrics metrics, int itemCount) => chatBottomDistance( maxScrollExtent: metrics.maxScrollExtent, pixels: metrics.pixels, itemCount: itemCount, ); /// Adopts a measured position as the follow intent. Crossing out of the /// bottom records the newest message then, so only later arrivals are counted. void _updateFollow(ScrollMetrics metrics) { final ids = _messageIds(); final distance = _distanceFor(metrics, ids.length); final following = chatFollowsAt(distance, itemCount: ids.length); _distanceFromBottom = distance; _lastOffset = metrics.pixels; if (following == _following) return; setState(() { _following = following; _newestAtRelease = following ? null : _newestMessageId(); }); } /// Puts the transcript at its end without animation, the way the web's /// `scrollTop = scrollHeight` does. Used both for following and the control. void _jumpToBottom() { if (!_scroll.hasClients) return; final end = _scroll.position.maxScrollExtent; if (_scroll.position.pixels != end) _scroll.jumpTo(end); _lastOffset = end; _distanceFromBottom = 0; _following = true; _newestAtRelease = null; } /// The first placement after the held history arrives: the saved position when /// the operator left one, otherwise the newest message. void _placeFromStore() { if (!_scroll.hasClients) return; _placed = true; final saved = _savedOffset; _savedOffset = null; if (saved != null) { _restoreOffset = saved; _restoring = true; _following = false; _newestAtRelease = null; // The control must appear as soon as a saved position exists, even while // the lazy extent is still settling; this runs after layout, so a rebuild // is safe. setState(() {}); _applyRestore(); _scheduleFollow(); return; } _jumpToBottom(); _persistPosition(); } /// Puts the viewport at the saved position within the currently measured /// extent. Re-applied while the extent settles, so a growing lazy list cannot /// turn the restored read into an accidental follow. void _applyRestore() { if (!_scroll.hasClients) return; final end = _scroll.position.maxScrollExtent; final target = chatRestoreOffset( savedOffset: _restoreOffset, maxScrollExtent: end, ); if (_scroll.position.pixels != target) _scroll.jumpTo(target); _lastOffset = target; _restoreMeasuredExtent = _scroll.position.maxScrollExtent; _distanceFromBottom = chatBottomDistance( maxScrollExtent: _restoreMeasuredExtent, pixels: _scroll.position.pixels, itemCount: _messageIds().length, ); } /// Places the first loaded transcript and keeps a following view at the end /// after every rebuild. Runs after layout so the newest extent is known; a pin /// is never scheduled while the operator is scrolling. void _scheduleFollow() { if (_pinScheduled) return; _pinScheduled = true; WidgetsBinding.instance.addPostFrameCallback((_) { _pinScheduled = false; if (!mounted || !_scroll.hasClients || !_controller.loaded) return; if (!_placed) { _placeFromStore(); return; } if (_restoring) { final measuredBefore = _restoreMeasuredExtent; _applyRestore(); if (_scroll.position.maxScrollExtent == measuredBefore) { // The measured extent stopped changing: the restored offset is the // operator's real position again, so follow intent can be judged. _restoring = false; _restoreOffset = null; _updateFollow(_scroll.position); // The settled distance decides whether the control is offered; the // frames that settled it ran without a follow-intent change. setState(() {}); _persistPosition(); } else { _scheduleFollow(); } return; } if (_following && !_userScrolling) _jumpToBottom(); }); } /// Follows a list whose measured extent grew without a scroll, as a lazily /// built transcript does while its newest turn wraps onto more lines. The jump /// itself happens after layout, when the new extent is the settled one. bool _onScrollMetrics(ScrollMetricsNotification notification) { if (notification.depth != 0 || notification.metrics.axis != Axis.vertical || !_placed) { return false; } if (_restoring) { // The lazy extent is still growing; re-place the saved offset once the // next layout has measured the new content. _scheduleFollow(); return false; } if (!_following || _userScrolling || !_scroll.hasClients) return false; if (_scroll.position.pixels < _scroll.position.maxScrollExtent) { _scheduleFollow(); } return false; } /// Follows only the transcript's own vertical scroll. A code fence's or /// table's horizontal scroll bubbles through this listener too and must not /// release the conversation's follow intent. bool _onScrollNotification(ScrollNotification notification) { if (notification.depth != 0 || notification.metrics.axis != Axis.vertical) { return false; } if (notification is UserScrollNotification) { _userScrolling = notification.direction != ScrollDirection.idle; if (_userScrolling) _abandonRestore(); } else if (notification is ScrollStartNotification) { if (notification.dragDetails != null) { _userScrolling = true; _abandonRestore(); } } else if (notification is ScrollUpdateNotification) { if (_userScrolling) _updateFollow(notification.metrics); } else if (notification is ScrollEndNotification) { if (_userScrolling) { _updateFollow(notification.metrics); _persistPosition(); // Releasing a scroll within the threshold returns to the end, exactly // like a follow check at the bottom of the web's wheel handler. if (_following) _jumpToBottom(); } _userScrolling = false; } return false; } void _followLatest() { setState(() { _following = true; _newestAtRelease = null; _distanceFromBottom = 0; }); _abandonRestore(); _jumpToBottom(); _persistPosition(); } /// The operator took over while a saved position was still being re-applied; /// their own scroll is authoritative from that point. void _abandonRestore() { _restoring = false; _restoreOffset = null; } @override Widget build(BuildContext context) => AnimatedBuilder( animation: _controller, builder: (context, _) { final cupertino = chatControlsStyleOf(context) == ChatControlsStyle.cupertino; final messages = _visibleMessages(); final cards = chatCardRows( permissions: _controller.permissionFrames, forms: _controller.questionForms, answerFor: _controller.permissionAnswerFor, permissionErrorFor: _controller.permissionErrorFor, formErrorFor: _controller.questionErrorFor, ); final allRows = transcriptRows(messages, trailing: cards); // A transcript held from before a socket gap may still say a compaction is // running even when the repair's read is refused. That running state is // stale, so no compaction notice is derived from it until a fresh read or // frame replaces the transcript. Fresh failure notices still report. // // Notices report recorded conditions only: a refused read/watch and a // running compaction. A dismissal keeps one hidden until its condition // changes. A running compaction's own activity line is that notice, so it // is not drawn twice; hiding it when dismissed is the whole dismissal. final allNotices = _reconnecting ? const [] : chatNotices( historyError: _controller.error, liveError: _controller.subscriptionError, messages: _staleTranscript ? const [] : _controller.messages, ); final notices = _dismissals.visible(allNotices); final compactionNotice = _noticeOf(notices, ChatNoticeKind.compaction); final rows = [ for (final row in allRows) if (!_hiddenRunningCompaction(row)) row, ]; // Older pages prepend messages and a live frame can append one, so a // folded assistant turn's first message id is not a stable identity. // ChatRowKeys carries a turn's key forward while it still holds any of // its previous messages, keeping the element (and its open disclosures) // across paging and streaming. final keys = _rowKeys.forRows(rows); final initialLoad = !_controller.loaded && _controller.loading; final historyNotice = _noticeOf( notices, ChatNoticeKind.connectionRefused, ); final liveNotice = _noticeOf(notices, ChatNoticeKind.liveFailure); final messageIds = _messageIds(); final newMessages = chatNewMessageCount(messageIds, _newestAtRelease); final showJump = chatShowsJumpToLatest( following: _following, distanceFromBottom: _distanceFromBottom, itemCount: messageIds.length, ); // Place the first loaded transcript and keep a following view at the end. // Scheduling after the build means the new extent is already laid out. _scheduleFollow(); // Under the app shell the conversation takes over the app's bar (title, // Back, model, information) instead of drawing a second bar below it. final inShellBar = ShellBar.available(context); final column = Column( children: [ // The conversation's own bar first, outside the transcript's scroller, // as on the web (chat-bar, then background tasks, then transcript). if (!inShellBar) Padding( key: const Key('chat-thread-header'), padding: const EdgeInsetsDirectional.fromSTEB(4, 8, 4, 4), child: LayoutBuilder( builder: (context, constraints) { final title = widget.title.trim(); final session = widget.session; final hasModel = session != null && supportsChatModels('${session['backend'] ?? ''}'); // One compact row, as on the web: back, the conversation's // name, its model and the information action. The title // takes the remaining width and ellipsises; the model keeps // a bounded share so neither control is pushed off a narrow // 2x phone and the header never wraps onto a second line. return Row( children: [ _backButton(cupertino), Expanded( child: Padding( padding: const EdgeInsetsDirectional.only(start: 4), child: title.isEmpty ? const SizedBox.shrink() : Text( title, maxLines: 1, overflow: TextOverflow.ellipsis, style: cupertino ? CupertinoTheme.of( context, ).textTheme.navTitleTextStyle : Theme.of(context).textTheme.titleLarge, ), ), ), if (hasModel) ConstrainedBox( constraints: BoxConstraints( maxWidth: constraints.maxWidth * 0.4, ), child: ChatModelControl( key: ValueKey( 'chat-model-${widget.sessionId}', ), gateway: widget.gateway, sessionId: widget.sessionId, session: session, onChanged: widget.onModelChanged, answeredBy: latestReplyModel(_controller.messages), ), ), ChatBarAction( key: const Key('chat-info'), label: 'Chat information', onPressed: _openInfo, materialIcon: Icons.info_outline, cupertinoIcon: CupertinoIcons.info, ), ], ); }, ), ), // The session's still-running background tasks, above the transcript // and outside its scroller (web C11). It removes itself when the last // task exits and never draws a finished task. ChatBackgroundTasks( key: ValueKey('chat-background-tasks-${widget.sessionId}'), gateway: widget.gateway, sessionId: widget.sessionId, syncToken: widget.syncToken, ), Expanded( child: NotificationListener( onNotification: _onScrollMetrics, child: NotificationListener( onNotification: _onScrollNotification, child: Stack( children: [ ListView( key: ValueKey('chat-thread-${widget.sessionId}'), controller: _scroll, padding: const EdgeInsets.symmetric(vertical: 8), children: [ if (initialLoad) Padding( key: const Key('chat-thread-loading'), padding: const EdgeInsets.all(16), child: Center( child: cupertino ? const CupertinoActivityIndicator() : const CircularProgressIndicator(), ), ), if (_controller.hasMore) Padding( key: const Key('chat-load-older'), padding: const EdgeInsets.symmetric(horizontal: 16), child: Align( alignment: AlignmentDirectional.centerStart, child: cupertino ? CupertinoButton( padding: EdgeInsets.zero, onPressed: _controller.loading ? null : _controller.loadOlder, child: const Text('Load older'), ) : TextButton( onPressed: _controller.loading ? null : _controller.loadOlder, child: const Text('Load older'), ), ), ), if (historyNotice != null) _ChatNoticeLine( key: const Key('chat-history-error'), notice: historyNotice, onDismiss: _dismiss, onRetry: _controller.load, ), if (liveNotice != null) _ChatNoticeLine( key: const Key('chat-live-error'), notice: liveNotice, onDismiss: _dismiss, onRetry: _controller.resync, ), if (_controller.loaded && allRows.isEmpty && allNotices.isEmpty && _commandNotices.isEmpty && _controller.error == null) const Padding( key: Key('chat-thread-empty'), padding: EdgeInsets.all(16), child: Text('No messages in this chat yet.'), ), for (var index = 0; index < rows.length; index++) Padding( key: ValueKey(keys[index]), padding: const EdgeInsets.symmetric(horizontal: 16), child: _transcriptRow( rows[index], onDismissCompaction: compactionNotice != null && chatNoticeActivityCondition( rows[index], ) == compactionNotice.condition ? () => _dismiss(compactionNotice) : null, ), ), // The conversation's own command lines sit after the // turns, as on the web; they are never bubbles. for (final notice in _commandNotices) _ChatNoticeLine( key: ValueKey( 'chat-command-notice-${notice.condition}', ), notice: notice, onDismiss: _dismiss, ), ], ), if (showJump) PositionedDirectional( end: 16, bottom: 16, child: _ChatJumpToLatest( key: const Key('chat-jump-to-latest'), label: chatJumpToLatestLabel(newMessages), cupertino: cupertino, onPressed: _followLatest, ), ), ], ), ), ), ), ChatComposerBar( key: ValueKey('chat-composer-${widget.sessionId}'), composer: _composer, running: _controller.running, commands: _commandActions(), picker: widget.attachmentPicker, ), ], ); if (!inShellBar) return column; final session = widget.session; final hasModel = session != null && supportsChatModels('${session['backend'] ?? ''}'); final title = widget.title.trim(); return ShellBar( title: title.isEmpty ? null : title, onBack: widget.onBack, actions: [ if (hasModel) ConstrainedBox( constraints: const BoxConstraints(maxWidth: 180), child: ChatModelControl( key: ValueKey('chat-model-${widget.sessionId}'), gateway: widget.gateway, sessionId: widget.sessionId, session: session, onChanged: widget.onModelChanged, answeredBy: latestReplyModel(_controller.messages), ), ), ChatBarAction( key: const Key('chat-info'), label: 'Chat information', onPressed: _openInfo, materialIcon: Icons.info_outline, cupertinoIcon: CupertinoIcons.info, ), ], child: column, ); }, ); ChatNotice? _noticeOf(List notices, ChatNoticeKind kind) { for (final notice in notices) { if (notice.kind == kind) return notice; } return null; } /// Whether a running compaction's activity line must stay off screen. /// /// That line is the compaction notice, so it follows the same conditions: it /// is hidden while the repair runs, while the held transcript is still the /// pre-gap one, and when the operator dismissed this exact compaction. A /// different running compaction in the transcript keeps its own line. bool _hiddenRunningCompaction(JsonMap row) { final condition = chatNoticeActivityCondition(row); if (condition == null) return false; return _reconnecting || _staleTranscript || _dismissals.isDismissed(condition); } /// Whether the held transcript is still the one recorded before the gap. bool get _staleTranscript => _preGapMessages != null && identical(_controller.messages, _preGapMessages); void _dismiss(ChatNotice notice) { setState(() { if (notice.kind == ChatNoticeKind.command) { // A command line is this conversation's own record, not a recorded // condition that could recur: dismissing it removes it. _commandNotices.remove(notice); } else { _dismissals.dismiss(notice); } }); } Widget _transcriptRow(JsonMap row, {VoidCallback? onDismissCompaction}) { final kind = '${row['kind'] ?? ''}'; if (kind == 'activity') { return _ChatActivityLine(row: row, onDismiss: onDismissCompaction); } if (kind == 'permission' || kind == 'question') { return ChatTranscriptCard( row: row, onPermissionDecision: _controller.replyPermission, onQuestionAnswer: _controller.answerQuestion, ); } return ChatMessageView(row: row, textBuilder: chatMarkdownText); } /// The header's compact Back control, matching the web's icon-only control. /// Its accessible name states the destination; Material keeps a tooltip and /// Cupertino the same label on the wrapping node. Widget _backButton(bool cupertino) { const label = 'Back to chats'; final icon = Icon(cupertino ? CupertinoIcons.back : Icons.arrow_back); if (!cupertino) { return IconButton( key: const Key('chat-back'), tooltip: label, onPressed: widget.onBack, icon: icon, ); } return Semantics( label: label, button: true, child: CupertinoButton( key: const Key('chat-back'), padding: EdgeInsets.zero, onPressed: widget.onBack, child: icon, ), ); } } /// The native dismiss control shared by a local notice and a running /// compaction's activity line. Material uses a tooltip; Cupertino carries the /// same accessible name on the wrapping node, since its button has none. Widget _noticeDismissControl({ required bool cupertino, required String label, required Key key, required VoidCallback onPressed, }) { final icon = Icon(cupertino ? CupertinoIcons.xmark_circle_fill : Icons.close); if (!cupertino) { return IconButton( key: key, tooltip: label, onPressed: onPressed, icon: icon, ); } return Semantics( container: true, button: true, label: label, onTap: onPressed, child: ExcludeSemantics( child: CupertinoButton( key: key, padding: EdgeInsets.zero, onPressed: onPressed, child: icon, ), ), ); } /// One local notice beside the conversation: a recorded failure or a slash /// command's outcome. /// /// It is never a message bubble and never sent to the agent. The line carries /// the kind's own words plus the recorded reason, keeps its native Retry and /// adds a native dismiss control. Colour only repeats the failed state, so the /// words remain readable without it. A running compaction is a recorded activity /// line and is dismissed there instead. class _ChatNoticeLine extends StatelessWidget { const _ChatNoticeLine({ super.key, required this.notice, required this.onDismiss, this.onRetry, }); final ChatNotice notice; final ValueChanged onDismiss; final VoidCallback? onRetry; @override Widget build(BuildContext context) { final cupertino = chatControlsStyleOf(context) == ChatControlsStyle.cupertino; final theme = Theme.of(context); final failed = notice.failed; 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); final icon = failed ? (cupertino ? CupertinoIcons.exclamationmark_circle : Icons.error_outline) : (cupertino ? CupertinoIcons.info_circle : Icons.info_outline); return Padding( padding: const EdgeInsetsDirectional.fromSTEB(16, 4, 8, 4), child: Column( crossAxisAlignment: CrossAxisAlignment.stretch, children: [ Row( crossAxisAlignment: CrossAxisAlignment.start, children: [ Padding( padding: const EdgeInsetsDirectional.only(top: 8), child: Icon(icon, color: color), ), const SizedBox(width: 8), Expanded( child: Padding( padding: const EdgeInsets.symmetric(vertical: 8), child: Semantics( liveRegion: true, child: Text(notice.text, style: style), ), ), ), _dismissControl(cupertino), ], ), if (onRetry != null) Align( alignment: AlignmentDirectional.centerStart, child: cupertino ? CupertinoButton( padding: EdgeInsets.zero, onPressed: onRetry, child: const Text('Retry'), ) : TextButton(onPressed: onRetry, child: const Text('Retry')), ), ], ), ); } Widget _dismissControl(bool cupertino) { return _noticeDismissControl( cupertino: cupertino, label: chatNoticeDismissLabel(notice.kind), key: ValueKey('chat-notice-dismiss-${notice.kind.name}'), onPressed: () => onDismiss(notice), ); } } /// One reported usage metric: its web label, whether the harness reported it, /// and the displayed value. Unavailable is a word, never a zero. typedef _ChatInfoMetric = ({ String key, String label, bool available, String value, }); const _chatInfoUnavailable = 'Unavailable'; /// The four chat usage facts in the web order and wording. /// /// Values come only from [ChatThreadController.usage]; a missing count, amount /// or window is "Unavailable". A reported zero stays a reported zero, and the /// context row keeps the web's partial forms when only one side was reported. List<_ChatInfoMetric> _chatInfoMetrics(JsonMap? usage) { final scope = '${usage?['scope'] ?? ''}'; final basis = '${usage?['rate_basis'] ?? ''}'; final rate = _chatInfoAmount(usage?['output_tokens_per_second']); final total = _chatInfoCount(usage?['total_tokens']); final used = _chatInfoCount(usage?['context_tokens']); final reportedWindow = _chatInfoCount(usage?['context_window']); // The web treats a zero context window as no reported limit. final limit = reportedWindow != null && reportedWindow > 0 ? reportedWindow : null; final cost = _chatInfoAmount(usage?['cost_usd']); final context = used != null && limit != null ? '${_chatInfoInteger(used)} / ${_chatInfoInteger(limit)}' : limit != null ? '${_chatInfoInteger(limit)} limit' : used != null ? '${_chatInfoInteger(used)} used' : _chatInfoUnavailable; return [ ( key: 'rate', label: basis == 'turn' ? 'Avg output rate' : 'Output rate', available: rate != null, value: rate == null ? _chatInfoUnavailable : _chatInfoRate(rate), ), ( key: 'tokens', label: scope == 'turn' ? 'Turn tokens' : 'Total tokens', available: total != null, value: total == null ? _chatInfoUnavailable : _chatInfoInteger(total), ), ( key: 'context', label: 'Context', available: used != null || limit != null, value: context, ), ( key: 'cost', label: 'Reported cost', available: cost != null, value: cost == null ? _chatInfoUnavailable : _chatInfoDollars(cost), ), ]; } int? _chatInfoCount(Object? value) => value is int && value >= 0 ? value : null; num? _chatInfoAmount(Object? value) => value is num && value.isFinite && value >= 0 ? value : null; String _chatInfoInteger(int value) { final digits = value.toString(); final grouped = StringBuffer(); for (var index = 0; index < digits.length; index++) { if (index > 0 && (digits.length - index) % 3 == 0) grouped.write(','); grouped.write(digits[index]); } return grouped.toString(); } String _chatInfoRate(num value) { final atMostOneDecimal = value.toStringAsFixed(1); final number = atMostOneDecimal.endsWith('.0') ? atMostOneDecimal.substring(0, atMostOneDecimal.length - 2) : atMostOneDecimal; return value > 0 && value < 0.1 ? '<0.1 tok/s' : '$number tok/s'; } String _chatInfoDollars(num value) { if (value > 0 && value < 0.000001) return '<\$0.000001'; final fixed = value.toStringAsFixed(6); final point = fixed.indexOf('.'); var decimals = fixed.substring(point + 1); while (decimals.length > 4 && decimals.endsWith('0')) { decimals = decimals.substring(0, decimals.length - 1); } final whole = int.parse(fixed.substring(0, point)); return '\$${_chatInfoInteger(whole)}.$decimals'; } /// The "Chat information" panel. It rebuilds from the controller, so metrics /// that arrive while it is open replace the displayed snapshot. class _ChatInfoSheet extends StatelessWidget { const _ChatInfoSheet({required this.controller}); final ChatThreadController controller; @override Widget build(BuildContext context) { final cupertino = chatControlsStyleOf(context) == ChatControlsStyle.cupertino; return AnimatedBuilder( animation: controller, builder: (context, _) { final titleStyle = cupertino ? CupertinoTheme.of(context).textTheme.navTitleTextStyle : Theme.of(context).textTheme.titleLarge; final content = Column( key: const Key('chat-info-sheet'), mainAxisSize: MainAxisSize.min, crossAxisAlignment: CrossAxisAlignment.stretch, children: [ Padding( padding: const EdgeInsetsDirectional.fromSTEB(24, 8, 16, 4), child: Row( children: [ Expanded( child: Semantics( header: true, child: Text('Chat information', style: titleStyle), ), ), if (cupertino) CupertinoButton( key: const Key('chat-info-close'), padding: EdgeInsets.zero, onPressed: () => Navigator.of(context).pop(), child: const Text('Close'), ) else TextButton( key: const Key('chat-info-close'), onPressed: () => Navigator.of(context).pop(), child: const Text('Close'), ), ], ), ), for (final metric in _chatInfoMetrics(controller.usage)) _ChatInfoRow(metric: metric, cupertino: cupertino), Padding( padding: const EdgeInsetsDirectional.fromSTEB(24, 8, 24, 16), child: Text( 'Last reported by the harness. ' 'Unavailable values are not estimated.', style: (cupertino ? CupertinoTheme.of(context).textTheme.textStyle : Theme.of(context).textTheme.bodySmall) ?.copyWith( color: cupertino ? CupertinoColors.secondaryLabel.resolveFrom( context, ) : Theme.of(context).colorScheme.onSurfaceVariant, ), ), ), ], ); if (!cupertino) return SingleChildScrollView(child: content); // A tall text scale must scroll inside the popup rather than push its // heading off-screen. The height follows the viewport, not a fixed size. return ConstrainedBox( constraints: BoxConstraints( maxHeight: MediaQuery.sizeOf(context).height * 0.8, ), child: SingleChildScrollView(child: content), ); }, ); } } class _ChatInfoRow extends StatelessWidget { const _ChatInfoRow({required this.metric, required this.cupertino}); final _ChatInfoMetric metric; final bool cupertino; @override Widget build(BuildContext context) { final secondary = cupertino ? CupertinoColors.secondaryLabel.resolveFrom(context) : Theme.of(context).colorScheme.onSurfaceVariant; final labelStyle = (cupertino ? CupertinoTheme.of(context).textTheme.textStyle : Theme.of(context).textTheme.bodySmall) ?.copyWith(color: secondary); final valueStyle = cupertino ? CupertinoTheme.of(context).textTheme.textStyle : Theme.of(context).textTheme.bodyLarge; return Padding( key: Key('chat-info-metric-${metric.key}'), padding: const EdgeInsetsDirectional.fromSTEB(24, 6, 24, 6), child: Column( crossAxisAlignment: CrossAxisAlignment.start, children: [ Text(metric.label, style: labelStyle), Text( metric.value, key: Key('chat-info-value-${metric.key}'), style: metric.available ? valueStyle : valueStyle?.copyWith(color: secondary), ), ], ), ); } } /// The transcript's follow control: a standard filled button that returns to the /// end and says how many messages arrived while the operator was reading above /// it. The count is part of the visible label and therefore its accessible name. class _ChatJumpToLatest extends StatelessWidget { const _ChatJumpToLatest({ super.key, required this.label, required this.cupertino, required this.onPressed, }); final String label; final bool cupertino; final VoidCallback onPressed; @override Widget build(BuildContext context) { final button = cupertino ? CupertinoButton.filled( padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8), onPressed: onPressed, child: Row( mainAxisSize: MainAxisSize.min, children: [ Icon( CupertinoIcons.arrow_down, color: CupertinoTheme.of(context).primaryContrastingColor, ), const SizedBox(width: 8), Flexible(child: Text(label, textAlign: TextAlign.center)), ], ), ) : FilledButton.tonalIcon( onPressed: onPressed, icon: const Icon(Icons.arrow_downward), label: Text(label, textAlign: TextAlign.center), ); // A long count at a large text scale wraps inside the pane instead of // pushing the control past the transcript's edge. return ConstrainedBox( constraints: BoxConstraints( maxWidth: MediaQuery.sizeOf(context).width - 32, ), child: button, ); } } /// One recorded activity line for a turn. /// /// The line is a summary of the recorded sequence. Its wording and state come /// from the recorded row, and the icon only repeats that state with theme roles, /// so an unknown kind or state is still readable without colour. The trailing /// control expands the same line into the recorded lifecycle and any recorded /// input, output, error, duration and edit diff; collapsing restores the single /// line without touching the turn. class _ChatActivityLine extends StatefulWidget { const _ChatActivityLine({required this.row, this.onDismiss}); final JsonMap row; /// Set only for a running compaction, whose line is the local notice the /// operator can hide until that compaction's condition changes. final VoidCallback? onDismiss; @override State<_ChatActivityLine> createState() => _ChatActivityLineState(); } class _ChatActivityLineState extends State<_ChatActivityLine> { bool _expanded = false; void _toggle() => setState(() => _expanded = !_expanded); /// The latest recorded update, which is also the line's label/state. With no /// records (a caller-built row) the row itself carries the same fields. JsonMap _record() { final records = widget.row['records']; if (records is List) { for (final record in records.reversed) { if (record is Map) return JsonMap.from(record); } } return widget.row; } @override Widget build(BuildContext context) { final cupertino = chatControlsStyleOf(context) == ChatControlsStyle.cupertino; final state = '${widget.row['state'] ?? ''}'.trim().toLowerCase(); final failed = state == 'failed' || state == 'error'; final running = state == 'running'; final completed = state == 'completed' || state == 'ended' || state == 'succeeded'; final secondary = _secondary(context, cupertino); final color = failed ? (cupertino ? CupertinoColors.systemRed.resolveFrom(context) : Theme.of(context).colorScheme.error) : secondary; final style = (cupertino ? CupertinoTheme.of(context).textTheme.textStyle : Theme.of(context).textTheme.bodySmall) ?.copyWith(color: color); final icon = failed ? (cupertino ? CupertinoIcons.exclamationmark_circle : Icons.error_outline) : running ? (cupertino ? CupertinoIcons.arrow_2_circlepath : Icons.sync) : completed ? (cupertino ? CupertinoIcons.check_mark_circled : Icons.check_circle_outline) : (cupertino ? CupertinoIcons.circle : Icons.circle_outlined); final label = '${widget.row['label'] ?? ''}'.trim(); return Padding( padding: const EdgeInsets.symmetric(vertical: 6), child: Column( mainAxisSize: MainAxisSize.min, crossAxisAlignment: CrossAxisAlignment.stretch, children: [ Row( crossAxisAlignment: CrossAxisAlignment.start, children: [ Expanded( child: Semantics( container: true, label: label, value: state, child: ExcludeSemantics( child: Row( crossAxisAlignment: CrossAxisAlignment.start, children: [ Icon(icon, color: color), const SizedBox(width: 8), Expanded(child: Text(label, style: style)), ], ), ), ), ), _toggleControl(cupertino), if (widget.onDismiss != null) _noticeDismissControl( cupertino: cupertino, label: chatNoticeDismissLabel(ChatNoticeKind.compaction), key: const ValueKey('chat-notice-dismiss-compaction'), onPressed: widget.onDismiss!, ), ], ), if (_expanded) _detail(context, cupertino, secondary), ], ), ); } /// The host's own disclosure control, with an action label that states what a /// tap does. Cupertino's button has no built-in label, so the wrapping node /// carries it and the button keeps the pointer handling. Widget _toggleControl(bool cupertino) { const key = ValueKey('chat-activity-toggle'); final label = _expanded ? 'Collapse activity' : 'Expand activity'; final icon = Icon( _expanded ? (cupertino ? CupertinoIcons.chevron_up : Icons.expand_less) : (cupertino ? CupertinoIcons.chevron_down : Icons.expand_more), ); if (!cupertino) { return IconButton( key: key, tooltip: label, onPressed: _toggle, icon: icon, ); } return Semantics( container: true, button: true, label: label, onTap: _toggle, child: ExcludeSemantics( child: CupertinoButton( key: key, padding: EdgeInsets.zero, onPressed: _toggle, child: icon, ), ), ); } /// The expanded section: every recorded field, with the exact absence sentence /// for one the record did not carry. Only [ChatActivityDetail] reads the /// record, so the line and its details cannot disagree about a field. Widget _detail(BuildContext context, bool cupertino, Color secondary) { final detail = chatActivityDetail(_record()); final baseStyle = cupertino ? CupertinoTheme.of(context).textTheme.textStyle : Theme.of(context).textTheme.bodyMedium; final labelStyle = TextStyle(color: secondary, fontWeight: FontWeight.w600); Widget field(String label, String value) { final absent = value == chatActivityLifecycleAbsent || value == chatActivityInputAbsent || value == chatActivityOutputAbsent || value == chatActivityErrorAbsent || value == chatActivityDurationAbsent || value == chatActivityDiffAbsent; return Padding( padding: const EdgeInsetsDirectional.only(top: 8), child: Column( crossAxisAlignment: CrossAxisAlignment.start, children: [ Text(label, style: labelStyle), DefaultTextStyle.merge( style: absent ? TextStyle(color: secondary) : const TextStyle(), child: SelectableText(value), ), ], ), ); } return DefaultTextStyle.merge( style: baseStyle, child: Padding( key: const ValueKey('chat-activity-details'), padding: const EdgeInsetsDirectional.only(bottom: 2), child: Column( crossAxisAlignment: CrossAxisAlignment.stretch, children: [ field('Lifecycle', detail.lifecycle), field('Input', detail.input), field('Output', detail.output), field('Error', detail.error), field('Duration', detail.duration), field('Edit diff', detail.diff), ], ), ), ); } Color _secondary(BuildContext context, bool cupertino) => cupertino ? CupertinoColors.secondaryLabel.resolveFrom(context) : Theme.of(context).colorScheme.onSurfaceVariant; }