diff --git a/app/lib/features/chat/ui/transcript/chat_message_view.dart b/app/lib/features/chat/ui/transcript/chat_message_view.dart index 6f5831b2..4254cf55 100644 --- a/app/lib/features/chat/ui/transcript/chat_message_view.dart +++ b/app/lib/features/chat/ui/transcript/chat_message_view.dart @@ -7,7 +7,7 @@ import '../../../../core/api_gateway.dart'; import '../sessions/chat_adaptive.dart'; import '../../domain/chat_tool_calls.dart'; import 'chat_tool_calls_view.dart'; -import 'chat_reasoning_disclosure.dart'; +import 'chat_reasoning_chip.dart'; import 'native_disclosure.dart'; /// Builds an assistant text part; the default keeps the server's text exactly. @@ -26,8 +26,8 @@ class ChatMessageView extends StatelessWidget { final JsonMap row; final ChatMessageTextBuilder? textBuilder; - /// More of an agent turn's summary chips, after its tools chip (the turn's - /// settled permission requests). + /// More of an agent turn's summary chips, after its reasoning and tools chips + /// (the turn's settled permission requests). final List footer; @override @@ -198,7 +198,9 @@ class ChatMessageView extends StatelessWidget { return widgets; } - /// Reasoning stays in the transcript so an open body follows live deltas. + /// The turn's footer: its reasoning, tools and permissions chips, then its + /// model. Each chip opens a native sheet; an open reasoning sheet follows + /// live deltas. Widget _agentTurn(BuildContext context, List content, Widget bubble) { final parts = _partsOf(row); final reasoning = [ @@ -213,6 +215,12 @@ class ChatMessageView extends StatelessWidget { ]; final model = '${row['model'] ?? ''}'.trim(); final footer = [ + if (reasoning.isNotEmpty) + ChatReasoningChip( + key: const Key('chat-turn-reasoning'), + steps: reasoning, + streaming: row['streaming'] == true && _reasoningIsNewest(parts), + ), if (tools.isNotEmpty) ChatToolCallsChip(calls: tools), ...this.footer, if (model.isNotEmpty) @@ -230,15 +238,9 @@ class ChatMessageView extends StatelessWidget { crossAxisAlignment: CrossAxisAlignment.start, children: [ if (content.isNotEmpty) bubble, - if (reasoning.isNotEmpty) - ChatReasoningDisclosure( - key: const Key('chat-turn-reasoning'), - steps: reasoning, - streaming: row['streaming'] == true, - trailing: footer, - ), - if (reasoning.isEmpty && footer.isNotEmpty) + if (footer.isNotEmpty) Wrap( + key: const Key('chat-message-footer'), spacing: 8, crossAxisAlignment: WrapCrossAlignment.center, children: footer, @@ -337,6 +339,21 @@ class ChatMessageView extends StatelessWidget { SelectableText(const JsonEncoder.withIndent(' ').convert(part)); } +/// Whether the turn's newest drawn part is reasoning: while it streams, that +/// is the step still arriving. Once an answer or a tool call starts after it, +/// the reasoning chip stops spinning (a running tool spins its own chip). +bool _reasoningIsNewest(List parts) { + for (final part in parts.reversed) { + final type = part['type']; + if (type == 'tool') return false; + if ((type == 'text' || type == 'reasoning') && + '${part['text'] ?? ''}'.trim().isNotEmpty) { + return type == 'reasoning'; + } + } + return false; +} + List _partsOf(Map source) { final parts = source['parts']; if (parts is! List) return const []; diff --git a/app/lib/features/chat/ui/transcript/chat_reasoning_chip.dart b/app/lib/features/chat/ui/transcript/chat_reasoning_chip.dart new file mode 100644 index 00000000..f9eba1bf --- /dev/null +++ b/app/lib/features/chat/ui/transcript/chat_reasoning_chip.dart @@ -0,0 +1,195 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/foundation.dart'; +import 'package:flutter/material.dart'; + +import '../sessions/chat_adaptive.dart'; +import 'chat_turn_chip.dart'; + +/// `Reasoning` / `Reasoning · N steps`. +String chatReasoningLabel(int steps) => + steps == 1 ? 'Reasoning' : 'Reasoning · $steps steps'; + +/// A turn's reasoning as the first chip of its footer, the same pattern as its +/// tools and permissions: it spins while the turn streams and opens a native +/// sheet with every step. Only reasoning the backend supplied is shown. +/// +/// The open sheet follows live deltas: this state owns the steps the sheet +/// listens to and updates them on every rebuild of the turn. +class ChatReasoningChip extends StatefulWidget { + const ChatReasoningChip({ + super.key, + required this.steps, + required this.streaming, + }); + + final List steps; + final bool streaming; + + @override + State createState() => _ChatReasoningChipState(); +} + +typedef _Reasoning = ({List steps, bool streaming}); + +class _ChatReasoningChipState extends State { + late final _live = _LiveReasoning(( + steps: widget.steps, + streaming: widget.streaming, + )); + + @override + void didUpdateWidget(ChatReasoningChip oldWidget) { + super.didUpdateWidget(oldWidget); + final current = _live.value; + if (widget.streaming == current.streaming && + listEquals(widget.steps, current.steps)) { + return; + } + // The sheet lives in another route, outside this subtree, so it may only + // be marked dirty once this build is over; the next frame shows the delta. + WidgetsBinding.instance.addPostFrameCallback((_) { + if (!mounted) return; + _live.value = (steps: widget.steps, streaming: widget.streaming); + }); + } + + @override + void dispose() { + _live.release(); + super.dispose(); + } + + @override + Widget build(BuildContext context) { + final cupertino = + chatControlsStyleOf(context) == ChatControlsStyle.cupertino; + final color = cupertino + ? CupertinoColors.secondaryLabel.resolveFrom(context) + : Theme.of(context).colorScheme.onSurfaceVariant; + final label = chatReasoningLabel(widget.steps.length); + return ChatTurnChip( + chipKey: const Key('chat-reasoning-chip'), + leading: widget.streaming + ? _spinner(cupertino) + : Icon( + cupertino ? CupertinoIcons.lightbulb : Icons.lightbulb_outline, + size: 14, + color: color, + ), + label: label, + color: color, + semanticsLabel: '$label, expand for details', + sheet: ValueListenableBuilder<_Reasoning>( + valueListenable: _live, + builder: (context, reasoning, _) => _ReasoningSheet( + steps: reasoning.steps, + streaming: reasoning.streaming, + ), + ), + ); + } +} + +Widget _spinner(bool cupertino) => cupertino + ? const CupertinoActivityIndicator(radius: 7) + : const SizedBox.square( + dimension: 12, + child: CircularProgressIndicator(strokeWidth: 2), + ); + +/// The steps an open sheet listens to. The turn can leave the tree while its +/// sheet is still open (its row scrolled away or replaced), so the notifier is +/// disposed only once its owner released it and no sheet listens any more. +class _LiveReasoning extends ValueNotifier<_Reasoning> { + _LiveReasoning(super.value); + + bool _released = false; + bool _disposed = false; + + void release() { + _released = true; + _disposeIfUnused(); + } + + @override + void removeListener(VoidCallback listener) { + super.removeListener(listener); + _disposeIfUnused(); + } + + void _disposeIfUnused() { + if (!_released || _disposed || hasListeners) return; + _disposed = true; + dispose(); + } +} + +class _ReasoningSheet extends StatelessWidget { + const _ReasoningSheet({required this.steps, required this.streaming}); + + final List steps; + final bool streaming; + + @override + Widget build(BuildContext context) { + final cupertino = + chatControlsStyleOf(context) == ChatControlsStyle.cupertino; + final style = cupertino + ? CupertinoTheme.of(context).textTheme.textStyle + : Theme.of(context).textTheme.bodyMedium; + final secondary = cupertino + ? CupertinoColors.secondaryLabel.resolveFrom(context) + : Theme.of(context).colorScheme.onSurfaceVariant; + return DefaultTextStyle.merge( + style: style, + child: ConstrainedBox( + constraints: BoxConstraints( + maxHeight: MediaQuery.sizeOf(context).height * 0.8, + ), + child: ListView( + key: const Key('chat-reasoning-sheet'), + shrinkWrap: true, + padding: const EdgeInsets.fromLTRB(16, 8, 16, 16), + children: [ + Padding( + padding: const EdgeInsets.only(bottom: 8), + child: Row( + children: [ + Flexible( + child: Text( + chatReasoningLabel(steps.length), + style: const TextStyle(fontWeight: FontWeight.w600), + ), + ), + if (streaming) ...[ + const SizedBox(width: 8), + _spinner(cupertino), + ], + ], + ), + ), + for (final (index, step) in steps.indexed) + Padding( + padding: const EdgeInsets.only(bottom: 12), + child: Column( + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + if (steps.length > 1) + Text( + 'STEP ${index + 1}', + style: TextStyle( + fontSize: 11, + fontWeight: FontWeight.w600, + color: secondary, + ), + ), + SelectableText(step), + ], + ), + ), + ], + ), + ), + ); + } +} diff --git a/app/lib/features/chat/ui/transcript/chat_reasoning_disclosure.dart b/app/lib/features/chat/ui/transcript/chat_reasoning_disclosure.dart deleted file mode 100644 index 5af336f9..00000000 --- a/app/lib/features/chat/ui/transcript/chat_reasoning_disclosure.dart +++ /dev/null @@ -1,101 +0,0 @@ -import 'package:flutter/cupertino.dart'; -import 'package:flutter/material.dart'; - -import '../sessions/chat_adaptive.dart'; - -/// Only reasoning actually supplied by the backend. Keeping its body in the -/// transcript (rather than a modal snapshot) lets an open disclosure rebuild -/// with every delta, even while answer text is also arriving. -class ChatReasoningDisclosure extends StatefulWidget { - const ChatReasoningDisclosure({ - super.key, - required this.steps, - required this.streaming, - this.trailing = const [], - }); - - final List steps; - final bool streaming; - final List trailing; - - @override - State createState() => - _ChatReasoningDisclosureState(); -} - -class _ChatReasoningDisclosureState extends State { - late bool _expanded = widget.streaming; - - void _toggle() => setState(() => _expanded = !_expanded); - - @override - Widget build(BuildContext context) { - final cupertino = - chatControlsStyleOf(context) == ChatControlsStyle.cupertino; - final label = widget.steps.length == 1 - ? 'Reasoning' - : 'Reasoning · ${widget.steps.length} steps'; - final control = Semantics( - key: const Key('chat-reasoning-toggle'), - button: true, - expanded: _expanded, - label: label, - onTap: _toggle, - excludeSemantics: true, - child: cupertino - ? CupertinoButton( - padding: const EdgeInsets.symmetric(horizontal: 4, vertical: 4), - minimumSize: Size.zero, - onPressed: _toggle, - child: Row( - mainAxisSize: MainAxisSize.min, - children: [ - Flexible(child: Text(label)), - Icon( - _expanded - ? CupertinoIcons.chevron_up - : CupertinoIcons.chevron_down, - size: 14, - ), - ], - ), - ) - : TextButton( - onPressed: _toggle, - child: Row( - mainAxisSize: MainAxisSize.min, - children: [ - Flexible(child: Text(label)), - Icon( - _expanded ? Icons.expand_less : Icons.expand_more, - size: 14, - ), - ], - ), - ), - ); - return DefaultTextStyle.merge( - style: cupertino - ? CupertinoTheme.of(context).textTheme.textStyle - : Theme.of(context).textTheme.bodyMedium, - child: Column( - key: const Key('chat-reasoning-disclosure'), - crossAxisAlignment: CrossAxisAlignment.stretch, - children: [ - Wrap( - key: const Key('chat-message-footer'), - spacing: 8, - crossAxisAlignment: WrapCrossAlignment.center, - children: [control, ...widget.trailing], - ), - if (_expanded) - for (final (index, step) in widget.steps.indexed) - Padding( - padding: EdgeInsets.only(top: index == 0 ? 0 : 12, bottom: 8), - child: SelectableText(step), - ), - ], - ), - ); - } -} diff --git a/app/notes/chat-reasoning-chip.md b/app/notes/chat-reasoning-chip.md new file mode 100644 index 00000000..bf19dcf3 --- /dev/null +++ b/app/notes/chat-reasoning-chip.md @@ -0,0 +1,25 @@ +# Chat reasoning chip + +User request: reasoning expanded differently from tools; make it the same as tools. + +- Reasoning is now `ChatReasoningChip` (`lib/features/chat/ui/transcript/chat_reasoning_chip.dart`), + built on the shared `ChatTurnChip`: lightbulb icon, `Reasoning` / `Reasoning · N steps`, + chevron, accessible name `... , expand for details`. It opens the same native sheet + (Material bottom sheet / Cupertino popup) listing every step as plain selectable text + (`STEP n` headings when there are several), as the old inline disclosure did (no markdown). +- Footer order: reasoning, tools, permissions, model label (`chat-message-footer` Wrap). + The inline disclosure (`chat_reasoning_disclosure.dart`) is removed; this supersedes the + inline layout in `per-message-reasoning-footer.md`. +- The chip spins while the turn streams and reasoning is its newest part; once an answer + or tool call follows, it shows its icon (a running tool spins its own chip). +- An open sheet follows live deltas: the chip state owns a notifier the sheet listens to, + updated after each rebuild of the turn (one frame later, since the sheet is another route). + If the row leaves the tree, the open sheet keeps its last steps and closes cleanly. +- Behaviour change: a newly streaming reply no longer shows its reasoning inline without a + tap; the operator opens the chip (a modal must not pop up by itself). + +Evidence: full `flutter test` passes (1,865), `flutter analyze` clean. Browser probe +`tool/chat_message_probe.{dart,mjs}` now also has a live turn whose step grows every 0.5 s; +both hosts passed, including OCR that the open sheet's tick advanced (Material 36 -> 42, +Cupertino 38 -> 45). Captures: `build/reasoning-chip-{material,cupertino}/`. +No device verification. diff --git a/app/test/features/chat/conversation/chat_composer_bar_state_test.dart b/app/test/features/chat/conversation/chat_composer_bar_state_test.dart index 0b89327b..b1d465f1 100644 --- a/app/test/features/chat/conversation/chat_composer_bar_state_test.dart +++ b/app/test/features/chat/conversation/chat_composer_bar_state_test.dart @@ -112,7 +112,7 @@ void main() { }); for (final cupertino in [false, true]) { - testWidgets('reasoning first arriving after a queued follow-up opens live ' + testWidgets('reasoning first arriving after a queued follow-up stays live ' '($cupertino)', (tester) async { gateway.prompt = (_, _) async => {'chat_queued': true}; await tester.pumpWidget( @@ -145,7 +145,17 @@ void main() { 'part': {'id': 'live-reasoning-0', 'type': 'reasoning'}, 'delta': 'Provided reasoning after the follow-up', }); - await tester.pumpAndSettle(); + // The reasoning chip spins while its step is the newest part, so the + // frames are pumped rather than settled. + Future frames() async { + for (var frame = 0; frame < 8; frame++) { + await tester.pump(const Duration(milliseconds: 100)); + } + } + + await frames(); + await tester.tap(find.text('Reasoning')); + await frames(); expect( find.text('Provided reasoning after the follow-up'), findsOneWidget, diff --git a/app/test/features/chat/conversation/chat_live_reasoning_test.dart b/app/test/features/chat/conversation/chat_live_reasoning_test.dart index e20c6529..c274acea 100644 --- a/app/test/features/chat/conversation/chat_live_reasoning_test.dart +++ b/app/test/features/chat/conversation/chat_live_reasoning_test.dart @@ -24,9 +24,31 @@ Widget _host(Widget child, bool cupertino) => cupertino home: Scaffold(body: child), ); +/// A streaming reasoning chip spins for as long as reasoning is the newest +/// part, so pumpAndSettle would never return; this lets a sheet finish its +/// entrance or exit instead. +Future _settle(WidgetTester tester) async { + for (var frame = 0; frame < 8; frame++) { + await tester.pump(const Duration(milliseconds: 100)); + } +} + +final _sheet = find.byKey(const Key('chat-reasoning-sheet')); + +Finder _inSheet(String text) => + find.descendant(of: _sheet, matching: find.text(text)); + +Future _dismiss(WidgetTester tester) async { + await tester.tapAt(const Offset(10, 10)); + await _settle(tester); + expect(_sheet, findsNothing); +} + void main() { for (final cupertino in [false, true]) { - testWidgets('reasoning arriving after text opens live ($cupertino)', ( + final host = cupertino ? 'Cupertino' : 'Material'; + + testWidgets('reasoning arriving after text is a spinning chip ($host)', ( tester, ) async { final gateway = FakeChatGateway(); @@ -42,14 +64,39 @@ void main() { gateway.emitEvent(_delta('text', 'Answer first')); await tester.pumpAndSettle(); expect(find.text('Reasoning'), findsNothing); + gateway.emitEvent(_delta('reasoning', 'Only supplied reasoning')); - await tester.pumpAndSettle(); - expect(find.text('Only supplied reasoning'), findsOneWidget); + await _settle(tester); + // A chip in the footer like the tools chip, not an inline body. + expect(find.text('Only supplied reasoning'), findsNothing); expect(find.text('Answer first'), findsOneWidget); + final chip = find.byKey(const Key('chat-reasoning-chip')); + final spinner = find.descendant( + of: chip, + matching: find.byType( + cupertino ? CupertinoActivityIndicator : CircularProgressIndicator, + ), + ); + expect(spinner, findsOneWidget); + expect( + find.bySemanticsLabel('Reasoning, expand for details'), + findsOneWidget, + ); + + await tester.tap(find.text('Reasoning')); + await _settle(tester); + expect(_inSheet('Only supplied reasoning'), findsOneWidget); + await _dismiss(tester); + + // The step ends: the chip settles to its icon. + gateway.emitEvent(chatStepFrame('ended')); + await tester.pumpAndSettle(); + expect(spinner, findsNothing); + expect(tester.takeException(), isNull); }); - testWidgets('live reasoning survives text, collapse, paging and resync ' - '(${cupertino ? 'Cupertino' : 'Material'})', (tester) async { + testWidgets('an open reasoning sheet follows live deltas, paging and ' + 'resync ($host)', (tester) async { final gateway = FakeChatGateway(); addTearDown(gateway.close); gateway.history = (_) async => @@ -63,34 +110,41 @@ void main() { await tester.pumpAndSettle(); gateway.emitEvent(_delta('reasoning', 'Provided thought')); - await tester.pumpAndSettle(); - // No opening tap required for a newly streaming reply. - expect(find.text('Provided thought'), findsOneWidget); + await _settle(tester); final rowElement = tester.element(find.byType(ChatMessageView)); + await tester.tap(find.text('Reasoning')); + await _settle(tester); + expect(_inSheet('Provided thought'), findsOneWidget); + // The open sheet repaints with each delta while the answer streams too; + // the row and its chip are the same elements throughout. gateway.emitEvent(_delta('text', 'Answer')); gateway.emitEvent(_delta('reasoning', ' continues')); - await tester.pumpAndSettle(); - expect(find.text('Provided thought continues'), findsOneWidget); + await _settle(tester); + expect(_inSheet('Provided thought continues'), findsOneWidget); expect(find.text('Answer'), findsOneWidget); expect(tester.element(find.byType(ChatMessageView)), same(rowElement)); + gateway.emitEvent(_delta('reasoning', ' live')); + await _settle(tester); + expect(_inSheet('Provided thought continues live'), findsOneWidget); + await _dismiss(tester); - await tester.tap(find.text('Reasoning')); - await tester.pumpAndSettle(); - gateway.emitEvent(_delta('reasoning', ' while collapsed')); + // A closed sheet draws nothing; reopening shows the newest text. + gateway.emitEvent(_delta('reasoning', ' while closed')); gateway.emitEvent(_delta('text', ' continues')); await tester.pumpAndSettle(); - expect(find.textContaining('while collapsed'), findsNothing); + expect(find.textContaining('while closed'), findsNothing); expect(find.text('Answer continues'), findsOneWidget); await tester.tap(find.text('Reasoning')); await tester.pumpAndSettle(); expect( - find.text('Provided thought continues while collapsed'), + _inSheet('Provided thought continues live while closed'), findsOneWidget, ); + await _dismiss(tester); // Prepending another assistant message folds into the same turn without - // replacing the row or closing the already-open reasoning disclosure. + // replacing the row; the chip counts both steps. gateway.history = (_) async => chatPage([ chatMessage( 'older', @@ -106,20 +160,18 @@ void main() { ]); await tester.tap(find.text('Load older')); await tester.pumpAndSettle(); - expect(find.text('Older provided thought'), findsOneWidget); - expect( - find.text('Provided thought continues while collapsed'), - findsOneWidget, - ); + expect(find.text('Reasoning · 2 steps'), findsOneWidget); expect(tester.element(find.byType(ChatMessageView)), same(rowElement)); - - gateway.emitEvent(chatStepFrame('ended')); + await tester.tap(find.text('Reasoning · 2 steps')); await tester.pumpAndSettle(); + expect(_inSheet('Older provided thought'), findsOneWidget); expect( - find.text('Provided thought continues while collapsed'), + _inSheet('Provided thought continues live while closed'), findsOneWidget, ); + // A resync replaces the stored turn under the open sheet. + gateway.emitEvent(chatStepFrame('ended')); gateway.history = (_) async => chatPage([ chatMessage( 'a', @@ -136,16 +188,14 @@ void main() { ]); gateway.emitEvent({'session_id': 's', 'kind': 'resync'}); await tester.pumpAndSettle(); - expect(find.text('Stored provided thought'), findsOneWidget); + expect(_inSheet('Stored provided thought'), findsOneWidget); + expect(find.textContaining('while closed'), findsNothing); expect(find.text('Stored answer'), findsOneWidget); - expect(find.textContaining('while collapsed'), findsNothing); expect(tester.element(find.byType(ChatMessageView)), same(rowElement)); - await tester.tap(find.text('Reasoning')); - await tester.pumpAndSettle(); - expect(find.text('Stored provided thought'), findsNothing); + await _dismiss(tester); - // A fresh history visit starts collapsed; missing reasoning is never - // fabricated. Cupertino keeps only its native controls. + // A fresh history visit draws the chip closed; missing reasoning is + // never fabricated. Cupertino keeps only its native controls. await tester.pumpWidget(const SizedBox.shrink()); await tester.pumpWidget( _host( @@ -157,7 +207,7 @@ void main() { expect(find.text('Stored provided thought'), findsNothing); await tester.tap(find.text('Reasoning')); await tester.pumpAndSettle(); - expect(find.text('Stored provided thought'), findsOneWidget); + expect(_inSheet('Stored provided thought'), findsOneWidget); if (cupertino) expect(find.byType(Material), findsNothing); expect(tester.takeException(), isNull); }); diff --git a/app/test/features/chat/conversation/chat_thread_view_test.dart b/app/test/features/chat/conversation/chat_thread_view_test.dart index 4cedecab..d425cae5 100644 --- a/app/test/features/chat/conversation/chat_thread_view_test.dart +++ b/app/test/features/chat/conversation/chat_thread_view_test.dart @@ -168,8 +168,8 @@ void main() { ); await tester.pumpAndSettle(); - // The turn's reasoning is one disclosure below its answer; it counts the - // steps of every message folded into the turn. + // The turn's reasoning is one footer chip below its answer; it counts + // the steps of every message folded into the turn. expect(find.text('Reasoning · 2 steps'), findsOneWidget); await tester.tap(find.text('Load older')); @@ -182,10 +182,18 @@ void main() { 'NEWEST folded reasoning body.', 'OLDEST folded reasoning body.', ]) { - expect(find.text(body), findsOneWidget, reason: body); + expect( + find.descendant( + of: find.byKey(const Key('chat-reasoning-sheet')), + matching: find.text(body), + ), + findsOneWidget, + reason: body, + ); } - await tester.tap(find.text('Reasoning · 4 steps')); + await tester.tapAt(const Offset(10, 10)); await tester.pumpAndSettle(); + expect(find.text('OLDEST folded reasoning body.'), findsNothing); expect( find.text('Load older'), keepsControl ? findsOneWidget : findsNothing, diff --git a/app/test/features/chat/ui/transcript/chat_message_view_test.dart b/app/test/features/chat/ui/transcript/chat_message_view_test.dart index 97e3e890..34dd3f17 100644 --- a/app/test/features/chat/ui/transcript/chat_message_view_test.dart +++ b/app/test/features/chat/ui/transcript/chat_message_view_test.dart @@ -124,7 +124,7 @@ void main() { expect(find.textContaining('"payload": 7'), findsNothing); expect(find.text('plain future text'), findsOneWidget); - // The answer keeps its own order; reasoning expands inline below it. + // The answer keeps its own order; the footer chips sit below it. double top(String text) => tester.getTopLeft(find.text(text)).dy; expect(top('First answer'), lessThan(top('Second answer'))); expect( @@ -134,13 +134,21 @@ void main() { expect(top('Unrecognised part: future_part'), lessThan(top('1 tool'))); expect(top('Unrecognised part: future_part'), lessThan(top('Reasoning'))); + // Reasoning is a chip like the tools chip: it opens a native sheet. await tester.ensureVisible(find.text('Reasoning')); await tester.pumpAndSettle(); await tester.tap(find.text('Reasoning')); await tester.pumpAndSettle(); - expect(find.text('private reasoning'), findsOneWidget); - await tester.tap(find.text('Reasoning')); + expect( + find.descendant( + of: find.byKey(const Key('chat-reasoning-sheet')), + matching: find.text('private reasoning'), + ), + findsOneWidget, + ); + await tester.tapAt(const Offset(10, 10)); await tester.pumpAndSettle(); + expect(find.text('private reasoning'), findsNothing); // The chip opens the calls; a call opens to its formatted input. await tester.ensureVisible(find.text('1 tool')); @@ -267,11 +275,20 @@ void main() { expect(reasoning.center.dy, closeTo(tools.center.dy, 2)); expect(reasoning.right, lessThan(tools.left)); - // The inline disclosure opens with every recorded step. + // The sheet lists every recorded step, in order. await tester.tap(find.text('Reasoning · 2 steps')); await tester.pumpAndSettle(); - expect(find.text('first thought'), findsOneWidget); - expect(find.text('second thought'), findsOneWidget); + final sheet = find.byKey(const Key('chat-reasoning-sheet')); + Finder inSheet(String text) => + find.descendant(of: sheet, matching: find.text(text)); + expect(inSheet('first thought'), findsOneWidget); + expect(inSheet('second thought'), findsOneWidget); + expect( + tester.getTopLeft(inSheet('first thought')).dy, + lessThan(tester.getTopLeft(inSheet('second thought')).dy), + ); + expect(inSheet('STEP 1'), findsOneWidget); + expect(inSheet('STEP 2'), findsOneWidget); }); } @@ -352,7 +369,7 @@ void main() { expect(find.byType(SelectableText), findsNothing); }); - testWidgets('Cupertino disclosure expands with the native control', ( + testWidgets('Cupertino reasoning and tool chips open native popups', ( tester, ) async { final row = _assistant([ @@ -369,9 +386,11 @@ void main() { expect(find.text('thought'), findsNothing); await tester.tap(find.text('Reasoning')); await tester.pumpAndSettle(); + expect(find.byType(CupertinoPopupSurface), findsOneWidget); expect(find.text('thought'), findsOneWidget); - await tester.tap(find.text('Reasoning')); + await tester.tapAt(const Offset(10, 10)); await tester.pumpAndSettle(); + expect(find.text('thought'), findsNothing); await tester.tap(find.text('1 tool')); await tester.pumpAndSettle(); diff --git a/app/test/features/chat/ui/transcript/chat_reasoning_chip_test.dart b/app/test/features/chat/ui/transcript/chat_reasoning_chip_test.dart new file mode 100644 index 00000000..11f6fa77 --- /dev/null +++ b/app/test/features/chat/ui/transcript/chat_reasoning_chip_test.dart @@ -0,0 +1,158 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/chat/domain/chat_transcript.dart'; +import 'package:pipelines_app/features/chat/ui/transcript/chat_message_view.dart'; + +JsonMap _turn(List parts, {String model = ''}) => transcriptRows([ + { + 'id': 'a1', + 'role': 'assistant', + if (model.isNotEmpty) 'model': model, + 'parts': parts, + }, +]).single; + +Widget _app(Widget body, bool cupertino) => cupertino + ? CupertinoApp(home: CupertinoPageScaffold(child: body)) + : MaterialApp( + theme: ThemeData(platform: TargetPlatform.android), + home: Scaffold(body: body), + ); + +final _sheet = find.byKey(const Key('chat-reasoning-sheet')); + +Finder _inSheet(String text) => + find.descendant(of: _sheet, matching: find.text(text)); + +void main() { + for (final cupertino in [false, true]) { + final host = cupertino ? 'Cupertino' : 'Material'; + + testWidgets('the footer reads reasoning, tools, permissions, model ' + '($host)', (tester) async { + tester.view.physicalSize = const Size(900, 600); + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.reset); + await tester.pumpWidget( + _app( + ListView( + children: [ + ChatMessageView( + row: _turn([ + {'type': 'text', 'text': 'Answer'}, + {'type': 'reasoning', 'text': 'thought'}, + { + 'type': 'tool', + 'name': 'read', + 'state': {'status': 'completed'}, + }, + ], model: 'model-x'), + footer: const [Text('permissions')], + ), + ], + ), + cupertino, + ), + ); + await tester.pumpAndSettle(); + // The test font draws every glyph as a full square, so the row may wrap; + // each item then follows the previous one in reading order. + final rects = [ + for (final text in ['Reasoning', '1 tool', 'permissions', 'model-x']) + tester.getRect(find.text(text)), + ]; + for (var index = 1; index < rects.length; index++) { + final before = rects[index - 1]; + final after = rects[index]; + final sameLine = (after.center.dy - before.center.dy).abs() < 3; + expect( + sameLine ? after.left > before.right : after.top >= before.bottom, + isTrue, + reason: 'footer item $index follows item ${index - 1}', + ); + } + expect( + (rects[1].center.dy - rects[0].center.dy).abs(), + lessThan(3), + reason: 'reasoning and tools share a line', + ); + // Same native chip as the tools: an icon and a chevron, one button node. + final chip = find.byKey(const Key('chat-reasoning-chip')); + expect( + find.descendant( + of: chip, + matching: find.byIcon( + cupertino ? CupertinoIcons.lightbulb : Icons.lightbulb_outline, + ), + ), + findsOneWidget, + ); + expect( + find.descendant( + of: chip, + matching: find.byIcon( + cupertino ? CupertinoIcons.chevron_up : Icons.expand_less, + ), + ), + findsOneWidget, + ); + final semantics = tester.getSemantics( + find.bySemanticsLabel('Reasoning, expand for details'), + ); + expect(semantics.flagsCollection.isButton, isTrue); + if (cupertino) expect(find.byType(Material), findsNothing); + }); + + testWidgets('an open sheet follows a rebuilt turn and outlives its row ' + '($host)', (tester) async { + final row = ValueNotifier( + _turn([ + {'type': 'reasoning', 'id': 'r1', 'text': 'first'}, + ]), + ); + addTearDown(row.dispose); + await tester.pumpWidget( + _app( + ValueListenableBuilder( + valueListenable: row, + builder: (context, value, _) => ListView( + children: [ + if (value != null) + ChatMessageView(key: const Key('turn'), row: value), + ], + ), + ), + cupertino, + ), + ); + await tester.pumpAndSettle(); + await tester.tap(find.text('Reasoning')); + await tester.pumpAndSettle(); + expect(_inSheet('Reasoning'), findsOneWidget); + expect(_inSheet('first'), findsOneWidget); + + row.value = _turn([ + {'type': 'reasoning', 'id': 'r1', 'text': 'first, longer'}, + {'type': 'text', 'text': 'Answer'}, + {'type': 'reasoning', 'id': 'r2', 'text': 'second'}, + ]); + await tester.pumpAndSettle(); + expect(_inSheet('Reasoning · 2 steps'), findsOneWidget); + expect(_inSheet('first, longer'), findsOneWidget); + expect(_inSheet('second'), findsOneWidget); + + // The row leaves the transcript while the sheet is open: the sheet keeps + // its last steps and closes cleanly. + row.value = null; + await tester.pumpAndSettle(); + expect(find.byKey(const Key('turn')), findsNothing); + expect(_inSheet('second'), findsOneWidget); + await tester.tapAt(const Offset(10, 10)); + await tester.pumpAndSettle(); + expect(_sheet, findsNothing); + expect(tester.takeException(), isNull); + }); + } +} diff --git a/app/tool/chat_message_probe.dart b/app/tool/chat_message_probe.dart index 89150fbb..be35537f 100644 --- a/app/tool/chat_message_probe.dart +++ b/app/tool/chat_message_probe.dart @@ -1,3 +1,5 @@ +import 'dart:async'; + import 'package:flutter/cupertino.dart'; import 'package:flutter/material.dart'; @@ -9,8 +11,9 @@ const _style = String.fromEnvironment( defaultValue: 'material', ); -/// Visible fixture for one user row and one folded assistant turn. The unknown -/// part and the tool body start collapsed so the browser probe has to open them. +/// Visible fixture for one user row, one folded assistant turn and one live +/// turn whose newest reasoning step grows every half second. The unknown part +/// and the tool body start collapsed so the browser probe has to open them. void main() { final rows = transcriptRows([ { @@ -57,10 +60,7 @@ void main() { ], }, ]); - final content = ListView( - padding: const EdgeInsets.all(16), - children: [for (final row in rows) ChatMessageView(row: row)], - ); + final content = _LiveTranscript(rows: rows); if (_style == 'cupertino') { runApp( CupertinoApp( @@ -80,3 +80,59 @@ void main() { ), ); } + +/// The fixture rows plus a streaming turn, rebuilt on each tick the way the +/// thread repaints a live delta. +class _LiveTranscript extends StatefulWidget { + const _LiveTranscript({required this.rows}); + + final List> rows; + + @override + State<_LiveTranscript> createState() => _LiveTranscriptState(); +} + +class _LiveTranscriptState extends State<_LiveTranscript> { + int _tick = 0; + late final Timer _timer; + + @override + void initState() { + super.initState(); + _timer = Timer.periodic( + const Duration(milliseconds: 500), + (_) => setState(() => _tick++), + ); + } + + @override + void dispose() { + _timer.cancel(); + super.dispose(); + } + + @override + Widget build(BuildContext context) { + final live = { + ...transcriptRows([ + { + 'id': 'probe-live', + 'role': 'assistant', + 'parts': [ + {'type': 'reasoning', 'id': 'r1', 'text': 'Live step one settled.'}, + {'type': 'text', 'id': 't1', 'text': 'Live answer so far.'}, + {'type': 'reasoning', 'id': 'r2', 'text': 'Live tick $_tick.'}, + ], + }, + ]).single, + 'streaming': true, + }; + return ListView( + padding: const EdgeInsets.all(16), + children: [ + for (final row in [...widget.rows, live]) + ChatMessageView(key: ValueKey(row['key']), row: row), + ], + ); + } +} diff --git a/app/tool/chat_message_probe.mjs b/app/tool/chat_message_probe.mjs index 6189e6ca..cd3be616 100644 --- a/app/tool/chat_message_probe.mjs +++ b/app/tool/chat_message_probe.mjs @@ -376,6 +376,50 @@ try { await assertOcr(openTool, text); } + // Dismiss the tool sheet, then bring the live turn into view. + for (const type of ['mousePressed', 'mouseReleased']) { + await send('Input.dispatchMouseEvent', { type, x: 10, y: 10, button: 'left', clickCount: 1 }, session); + } + await delay(800); + await send('Input.dispatchMouseEvent', { type: 'mouseWheel', x: 195, y: 420, deltaX: 0, deltaY: 3000 }, session); + await delay(800); + const liveName = 'Reasoning · 2 steps, expand for details'; + await requireNode(liveName); + const liveChip = await capture(`${style}-live-chip`); + await assertOcr(liveChip, 'Live answer so far'); + await assertOcr(liveChip, 'Reasoning'); + // The open sheet follows the live turn: its newest step keeps growing. + // A real pointer tap on the chip's own node (the smallest one carrying its + // name; its row group repeats the text). + const chipNode = (await nodes()) + .filter((node) => node.label === liveName || node.text === liveName) + .sort((a, b) => a.w * a.h - b.w * b.h)[0]; + for (const type of ['mousePressed', 'mouseReleased']) { + await send('Input.dispatchMouseEvent', { + type, + x: chipNode.x + chipNode.w / 2, + y: chipNode.y + chipNode.h / 2, + button: 'left', + clickCount: 1, + }, session); + } + await delay(800); + const tickOf = async (path) => { + const match = (await ocr(path)).match(/Live tick (\d+)/); + if (!match) throw new Error(`OCR of ${path} shows no live tick`); + return Number(match[1]); + }; + const liveA = await capture(`${style}-live-sheet-a`); + await assertOcr(liveA, 'Live step one settled'); + const first = await tickOf(liveA); + await delay(2000); + const liveB = await capture(`${style}-live-sheet-b`); + const second = await tickOf(liveB); + evidence.checks.push({ check: 'open reasoning sheet follows live deltas', first, second }); + if (second <= first) { + throw new Error(`Open sheet did not follow live deltas: ${first} then ${second}`); + } + const report = JSON.stringify(evidence, null, 2); await writeFile(join(out, `${style}-evidence.json`), report); console.log(report);