diff --git a/app/lib/features/chat/conversation/chat_composer_controller.dart b/app/lib/features/chat/conversation/chat_composer_controller.dart new file mode 100644 index 00000000..3f56cc9d --- /dev/null +++ b/app/lib/features/chat/conversation/chat_composer_controller.dart @@ -0,0 +1,249 @@ +import 'dart:async'; + +import 'package:flutter/foundation.dart'; + +import '../../../core/api_gateway.dart'; +import '../data/chat_repository.dart'; +import 'chat_draft_store.dart'; + +/// One plain-message send: the optimistic identity the thread shows and the +/// exact wire intent. A lost response retries the same intent with these ids. +class ChatComposerSend { + const ChatComposerSend({ + required this.sessionId, + required this.text, + required this.operationId, + required this.nativeMessageId, + }); + + final String sessionId; + + /// The trimmed wire text. + final String text; + final String operationId; + final String nativeMessageId; + + /// Mirrors the web's `nativeChatMessageId(operationId) || local-`. + String get optimisticId => + nativeMessageId.isEmpty ? 'local-$operationId' : nativeMessageId; +} + +typedef ChatSendCallback = void Function(ChatComposerSend send); +typedef ChatSendRejected = void Function(ChatComposerSend send, String error); + +/// The composer state for one conversation: exact draft, the one plain prompt +/// in flight, the reply's queued flag and Stop. It is not a transcript: +/// [onOptimistic] and [onRejected] are the thread's seam; Stop settles nothing. +class ChatComposerController extends ChangeNotifier { + ChatComposerController( + this.gateway, + this.sessionId, { + ChatDraftStore? drafts, + this.onOptimistic, + this.onRejected, + this.newOperationId, + }) : _drafts = drafts ?? const SharedPreferencesChatDraftStore() { + _subscription = gateway.frames.listen(_onFrame); + } + + final ApiGateway gateway; + final String sessionId; + final ChatSendCallback? onOptimistic; + final ChatSendRejected? onRejected; + final ChatDraftStore _drafts; + + /// Test/fixture seam; production mints a unique id per new intent. + final String Function()? newOperationId; + late final ChatRepository _repository = ChatRepository(gateway); + StreamSubscription? _subscription; + + static const String draftSaveFailed = + 'This draft could not be saved on this device.'; + + String _draft = ''; + bool _edited = false; + bool _sending = false; + bool _stopping = false; + bool _queued = false; + String? _error; + String? _draftError; + int _operationSeq = 0; + int _loadGeneration = 0; + Future _writes = Future.value(); + ChatComposerSend? _pending; + bool _disposed = false; + + /// The exact text in the composer. A refusal restores it only when the + /// operator has not typed anything newer. + String get draft => _draft; + + /// One prompt request is awaiting its reply; a second send is refused. + bool get sending => _sending; + + /// One `chat_interrupt` is awaiting its reply. + bool get stopping => _stopping; + + /// The reply said the prompt waits behind the in-flight turn. + bool get queued => _queued; + + /// The last send or Stop refusal, kept visible until the next action. + String? get error => _error; + + /// Set when the draft could not be persisted; in-memory text still holds. + String? get draftError => _draftError; + + /// Reads this session's saved draft. Text typed while the read is pending + /// wins, so a slow store can never replace the operator's newer typing. + Future loadDraft() async { + if (_disposed) return; + final generation = ++_loadGeneration; + var saved = ''; + try { + saved = await _drafts.read(sessionId); + } catch (_) { + saved = ''; + } + if (_disposed || _edited || generation != _loadGeneration) return; + if (saved == _draft) return; + _draft = saved; + _notify(); + } + + /// Updates the draft exactly as typed and persists it. A save failure leaves + /// the in-memory draft untouched and sets [draftError]. + Future setDraft(String text) { + if (_disposed || text == _draft) return Future.value(); + _draft = text; + _edited = true; + _draftError = null; + _notify(); + return _persistDraft(text); + } + + /// Sends the non-blank draft as one plain message. Only the wire text is + /// trimmed. A refused unchanged intent reuses its operation id; a refusal + /// restores the exact draft unless newer text is already present. + Future send() async { + if (_disposed || _sending) return; + final exact = _draft; + final text = exact.trim(); + if (text.isEmpty) return; + final previous = _pending; + late final ChatComposerSend intent; + if (previous != null && previous.text == text) { + intent = previous; + } else { + final operationId = _nextOperationId(); + intent = ChatComposerSend( + sessionId: sessionId, + text: text, + operationId: operationId, + nativeMessageId: nativeChatMessageId(operationId), + ); + } + _pending = intent; + _sending = true; + _error = null; + _draft = ''; + _edited = true; + _notify(); + await _persistDraft(''); + if (_disposed) return; + onOptimistic?.call(intent); + try { + final reply = await _repository.prompt( + sessionId, + text, + operationId: intent.operationId, + ); + if (_disposed) return; + _queued = reply['chat_queued'] == true; + _pending = null; + _sending = false; + _error = null; + _notify(); + } catch (error) { + if (_disposed) return; + final message = '$error'; + _sending = false; + _error = message; + if (_draft.isEmpty) { + _draft = exact; + _edited = true; + _notify(); + await _persistDraft(exact); + if (_disposed) return; + } + onRejected?.call(intent, message); + _notify(); + } + } + + /// Stops the running turn with the exact `chat_interrupt` query. A failure + /// stays visible and settles nothing; only a reply or frame changes state. + Future stop() async { + if (_disposed || _stopping) return; + _stopping = true; + _error = null; + _notify(); + try { + await _repository.interrupt(sessionId); + } catch (error) { + if (!_disposed) _error = '$error'; + } finally { + if (!_disposed) { + _stopping = false; + _notify(); + } + } + } + + void _onFrame(JsonMap envelope) { + if (_disposed || !_queued) return; + if (envelope['type'] != 'chat_event') return; + final body = envelope['chat_event']; + if (body is! Map || body['session_id'] != sessionId) return; + // Usage or compaction does not admit a queued prompt; any other frame for + // this session means the turn it waited behind moved on (web parity). + final kind = body['kind']; + if (kind == 'usage' || kind == 'compaction') return; + _queued = false; + _notify(); + } + + String _nextOperationId() => + newOperationId?.call() ?? + 'native-chat-${DateTime.now().microsecondsSinceEpoch}-${_operationSeq++}'; + + Future _persistDraft(String text) { + final write = _writes.then((_) async { + var stored = false; + try { + stored = await _drafts.write(sessionId, text); + } catch (_) { + stored = false; + } + if (_disposed || text != _draft) return; + final failure = stored ? null : draftSaveFailed; + if (failure != _draftError) { + _draftError = failure; + _notify(); + } + }); + _writes = write; + return write; + } + + void _notify() { + if (!_disposed) notifyListeners(); + } + + @override + void dispose() { + if (_disposed) return; + _disposed = true; + _loadGeneration++; + unawaited(_subscription?.cancel()); + super.dispose(); + } +} diff --git a/app/lib/features/chat/conversation/chat_draft_store.dart b/app/lib/features/chat/conversation/chat_draft_store.dart new file mode 100644 index 00000000..3cb29151 --- /dev/null +++ b/app/lib/features/chat/conversation/chat_draft_store.dart @@ -0,0 +1,92 @@ +import 'package:shared_preferences/shared_preferences.dart'; + +/// One conversation's persisted composer draft, keyed by session id. +/// +/// The draft is stored exactly as typed (untrimmed); only the wire copy is +/// trimmed. Attachments are intentionally absent: a file handle cannot be +/// serialised, and the web build keeps them memory-only too. +abstract interface class ChatDraftStore { + /// The saved draft, or an empty string when there is none or the store is + /// unavailable. Implementations may throw; the controller treats that as + /// "nothing saved" and keeps its in-memory draft. + Future read(String sessionId); + + /// Stores [text] exactly. A blank draft removes the entry so the store does + /// not grow without bound. Returns false when nothing was stored. + Future write(String sessionId, String text); +} + +/// The app's per-session draft keys. Independent of the legacy web/Android +/// storage: no old draft is imported or written under an old key. +const String chatDraftKeyPrefix = 'pipelines.next.chatDraft.v1.'; + +/// `shared_preferences`-backed draft storage. +/// +/// Reads are tolerant and a write reports failure instead of throwing, so the +/// composer can keep the in-memory draft and say plainly that it was not saved. +class SharedPreferencesChatDraftStore implements ChatDraftStore { + const SharedPreferencesChatDraftStore(); + + Future _preferences() async { + try { + return await SharedPreferences.getInstance(); + } catch (_) { + return null; + } + } + + @override + Future read(String sessionId) async { + final preferences = await _preferences(); + if (preferences == null) return ''; + try { + return preferences.getString('$chatDraftKeyPrefix$sessionId') ?? ''; + } catch (_) { + return ''; + } + } + + @override + Future write(String sessionId, String text) async { + final preferences = await _preferences(); + if (preferences == null) return false; + try { + final key = '$chatDraftKeyPrefix$sessionId'; + if (text.isEmpty) return await preferences.remove(key); + return await preferences.setString(key, text); + } catch (_) { + return false; + } + } +} + +/// An in-memory store for tests and previews. It never touches the platform +/// store, so no production preference can be mutated by a fixture. +class MemoryChatDraftStore implements ChatDraftStore { + MemoryChatDraftStore({Map? drafts}) : _drafts = {...?drafts}; + + final Map _drafts; + bool failReads = false; + bool failWrites = false; + + /// A snapshot of the stored entries, so a test can tell a removed key from an + /// empty string. + Map get entries => Map.unmodifiable(_drafts); + + @override + Future read(String sessionId) async { + if (failReads) throw StateError('Draft storage is unavailable.'); + return _drafts[sessionId] ?? ''; + } + + @override + Future write(String sessionId, String text) async { + if (failWrites) return false; + if (text.isEmpty) { + _drafts.remove(sessionId); + } else { + _drafts[sessionId] = text; + } + return true; + } +} diff --git a/app/notes/C3-state.md b/app/notes/C3-state.md new file mode 100644 index 00000000..f10869a2 --- /dev/null +++ b/app/notes/C3-state.md @@ -0,0 +1,122 @@ +# C3-state — per-chat composer draft, prompt identity, queued flag and Stop + +Plain-message composer state for one conversation. Nonvisual item: no UI, +widget, shell, transport, server, pubspec or platform change. The existing +`ChatRepository.prompt`/`interrupt`/`nativeChatMessageId` are reused unchanged. + +## What changed + +New files only (no existing file edited): + +| File | Lines | Responsibility | +| --- | --- | --- | +| `lib/features/chat/conversation/chat_draft_store.dart` | 92 | injected draft store, `shared_preferences` implementation, in-memory fixture store | +| `lib/features/chat/conversation/chat_composer_controller.dart` | 249 | one conversation's draft, single in-flight prompt, queued flag, Stop, optimistic/rejection seam | +| `test/features/chat/conversation/chat_composer_fixtures.dart` | 40 | fake gateway recording `chat_prompt`/`chat_interrupt` and pushing frames | +| `test/features/chat/conversation/chat_composer_send_test.dart` | 240 | wire identity, guard, retry, queue/frames, Stop, disposal | +| `test/features/chat/conversation/chat_composer_draft_test.dart` | 180 | exact persistence, isolation, load race, storage failures | + +## Draft state + +- `draft` is the exact field text (untrimmed). Only the wire copy is trimmed, + matching the task's "trim wire text only". +- `setDraft` updates memory at once and persists in a serialised write chain, so + rapid edits cannot land out of order. It adds no UI copy of its own. +- The key is `pipelines.next.chatDraft.v1.`; blank drafts remove the + entry. No legacy web/Android key is read or written. Attachments are not + modelled or persisted. +- `loadDraft` is explicit (the thread/screen integration calls it). A store read + that completes after the operator has typed, or after a new load, is ignored, + so a slow store cannot replace newer text. Storage reads that fail mean "no + saved draft"; saves return false, keep the in-memory text and expose + `draftError = "This draft could not be saved on this device."`. +- `MemoryChatDraftStore` is fixture-only; the production default is + `SharedPreferencesChatDraftStore`. + +## Send and identity + +`send()` is a no-op for a blank/whitespace-only draft and while a previous send +is awaiting its reply (`sending` guard). It clears the draft and broadcasts, +then emits the optimistic seam before the request: + +- wire: `{'chat_prompt': {session_id, text: trimmed, operation_id, + native_message_id: nativeChatMessageId(operation_id)}}`, no `files` or + `attachments` keys; +- `ChatComposerSend` gives the thread `operationId`, `nativeMessageId`, + `optimisticId` (`nativeChatMessageId`, else `local-`), trimmed + text and session. No transcript rows are built here. +- A refused send keeps its operation id; sending the same trimmed intent again + reuses that id and native message id (response-loss retry). A different intent + mints a new id. Success clears the retry id, so the next message is new. +- A refusal sets `error`, restores the exact original draft and persists it only + when the composer is still empty. Newer typing wins and is not overwritten; + the rejection callback still reports the refused intent. A failed draft write + is reported through `draftError` and does not prevent the prompt being sent. + +Default operation ids are `native-chat--`; tests inject a +deterministic factory. + +## Queued and Stop + +- `chat_queued == true` on the prompt reply sets `queued`; an absent/false field + clears it. +- Only a `chat_event` for this controller's session clears `queued`, and only + for a frame that means the turn moved on. `usage` and `compaction` frames are + ignored, mirroring `queuedAfterFrame` in `web/src/chat.js`. Other sessions' + frames are ignored. +- `stop()` sends exactly + `chat_interrupt` `{'chat_query': {'session_id': }}`. A failure stays in + `error`; success/failure changes neither `queued` nor any running bit. The + thread's frame owns settlement; no synthetic settle or notice is invented. + +## Checks actually run + +``` +flutter pub get +dart format lib/features/chat/conversation test/features/chat/conversation + # formatted 5 files +flutter analyze # No issues found! (ran in 1.4s) +flutter test test/features/chat # 74 passed +flutter test test/features/chat/conversation # 28 passed +``` + +New regressions (17) cover: + +- exact `chat_prompt` body plus trimmed text, exact native id, cleared draft; +- whitespace-only/no request and double-send guard; +- refusal exposes the server words, restores the exact draft, reuses the same + operation/native id for the unchanged retry, and mints a new id for a new + intent; +- newer typing survives a refusal while the rejected callback still carries the + original intent; +- reply queued flag, other-session/usage/compaction frames ignored, owned frame + clears it, absent reply flag clears a previous one; +- exact `chat_interrupt` body, refusal visible and no queued state change; +- late reply after disposal changes nothing and calls no rejection seam; +- SharedPreferences exact round-trip and blank-key removal; +- per-session isolation, explicit load, load-versus-typing race, unreadable + store, failed save recovery, ordered rapid edits, failed clear still sends. + +## Honest limits + +- **No UI, keyboard, Enter/Ctrl/Cmd+Enter, slash, attachment picker or model + work.** Draft typing, send, Stop and queued notices are not wired into + `chat_thread_controller` or a screen yet; the callbacks and `loadDraft` are the + integration seam for that later item. Attachments remain unsupported. +- **Queued clearing copies the web's `queuedAfterFrame` rule** but does not own + the running bit; a UI must read the thread controller for Send/Stop choice. +- **No browser capture or fixture proof.** Nothing renders in this item; only + unit/controller tests with fake gateways and mock SharedPreferences ran. The + real-device preference write path was not exercised (no device/ADB). +- **Mobile unverified.** Source is pure Dart/Flutter and portable; no Android, + iOS or emulator build was run. +- **No production session, provider turn or network fixture** was used. +- **Committed, not pushed or deployed.** The feature lives on + `flutter/chat-composer`; the landing stage merged `main` into it and the server + owns landing. This lane pushed nothing and changed no service. + +## Preserved work + +`git status --short` shows only the six new paths (the five above plus this +note); no tracked file, pubspec/lock, shell, server, `web/`, legacy client or +platform file changed. Concurrent lanes' and manager commits are untouched. diff --git a/app/test/features/chat/conversation/chat_composer_draft_test.dart b/app/test/features/chat/conversation/chat_composer_draft_test.dart new file mode 100644 index 00000000..99e6f07c --- /dev/null +++ b/app/test/features/chat/conversation/chat_composer_draft_test.dart @@ -0,0 +1,180 @@ +import 'dart:async'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_composer_controller.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_draft_store.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +import 'chat_composer_fixtures.dart'; + +/// A store whose read resolves only when the test says so. +class _DelayedDraftStore implements ChatDraftStore { + _DelayedDraftStore(this.saved); + final String saved; + final reads = >[]; + final writes = []; + + @override + Future read(String sessionId) { + final completer = Completer(); + reads.add(completer); + return completer.future; + } + + @override + Future write(String sessionId, String text) async { + writes.add(text); + return true; + } +} + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + + test( + 'SharedPreferences stores the exact per-session draft and clears it', + () async { + SharedPreferences.setMockInitialValues({}); + const store = SharedPreferencesChatDraftStore(); + + expect(await store.write('a', ' line one\nline two '), isTrue); + expect(await store.read('a'), ' line one\nline two '); + expect(await store.read('b'), ''); + + final preferences = await SharedPreferences.getInstance(); + expect( + preferences.getString('${chatDraftKeyPrefix}a'), + ' line one\nline two ', + ); + + expect(await store.write('a', ''), isTrue); + expect(await store.read('a'), ''); + expect(preferences.getString('${chatDraftKeyPrefix}a'), isNull); + }, + ); + + test('drafts stay isolated per conversation and load exactly', () async { + final drafts = MemoryChatDraftStore(); + final firstGateway = FakeComposerGateway(); + final secondGateway = FakeComposerGateway(); + final first = ChatComposerController(firstGateway, 'a', drafts: drafts); + final second = ChatComposerController(secondGateway, 'b', drafts: drafts); + addTearDown(first.dispose); + addTearDown(second.dispose); + addTearDown(firstGateway.close); + addTearDown(secondGateway.close); + + await first.setDraft('draft a\n'); + await second.setDraft('draft b'); + + expect(drafts.entries, {'a': 'draft a\n', 'b': 'draft b'}); + + final reopened = ChatComposerController( + FakeComposerGateway(), + 'a', + drafts: drafts, + ); + addTearDown(reopened.dispose); + await reopened.loadDraft(); + expect(reopened.draft, 'draft a\n'); + }); + + test('a draft typed while the saved draft loads is not replaced', () async { + final store = _DelayedDraftStore('saved'); + final controller = ChatComposerController( + FakeComposerGateway(), + 's', + drafts: store, + ); + addTearDown(controller.dispose); + + final loading = controller.loadDraft(); + await pumpEventQueue(); + await controller.setDraft('typed'); + store.reads.single.complete('saved'); + await loading; + + expect(controller.draft, 'typed'); + expect(store.writes.last, 'typed'); + }); + + test( + 'an unreadable store leaves the draft empty and can load later', + () async { + final drafts = MemoryChatDraftStore(drafts: {'s': 'saved'}) + ..failReads = true; + final controller = ChatComposerController( + FakeComposerGateway(), + 's', + drafts: drafts, + ); + addTearDown(controller.dispose); + + await controller.loadDraft(); + expect(controller.draft, ''); + + drafts.failReads = false; + await controller.loadDraft(); + expect(controller.draft, 'saved'); + }, + ); + + test( + 'a failed draft save keeps the text and reports it, then clears', + () async { + final drafts = MemoryChatDraftStore()..failWrites = true; + final controller = ChatComposerController( + FakeComposerGateway(), + 's', + drafts: drafts, + ); + addTearDown(controller.dispose); + + await controller.setDraft('still here'); + expect(controller.draft, 'still here'); + expect(controller.draftError, ChatComposerController.draftSaveFailed); + expect(drafts.entries, isEmpty); + + drafts.failWrites = false; + await controller.setDraft('saved now'); + expect(controller.draftError, isNull); + expect(drafts.entries, {'s': 'saved now'}); + }, + ); + + test('rapid edits persist in order and the newest draft wins', () async { + final drafts = MemoryChatDraftStore(); + final controller = ChatComposerController( + FakeComposerGateway(), + 's', + drafts: drafts, + ); + addTearDown(controller.dispose); + + final first = controller.setDraft('a'); + final second = controller.setDraft('ab'); + final third = controller.setDraft('abc'); + await Future.wait([first, second, third]); + + expect(controller.draft, 'abc'); + expect(drafts.entries, {'s': 'abc'}); + }); + + test('a failed draft clear still sends and stays visibly unsaved', () async { + final drafts = MemoryChatDraftStore()..failWrites = true; + final gateway = FakeComposerGateway(); + gateway.prompt = (_, _) async => const {}; + final controller = ChatComposerController(gateway, 's', drafts: drafts); + addTearDown(controller.dispose); + addTearDown(gateway.close); + + await controller.setDraft('send me'); + await controller.send(); + + expect(gateway.promptBodies.single['text'], 'send me'); + expect(controller.draft, ''); + expect(controller.error, isNull); + // The in-memory draft cleared; the device store still reports the failure. + expect(controller.draftError, ChatComposerController.draftSaveFailed); + }); +} diff --git a/app/test/features/chat/conversation/chat_composer_fixtures.dart b/app/test/features/chat/conversation/chat_composer_fixtures.dart new file mode 100644 index 00000000..121ff138 --- /dev/null +++ b/app/test/features/chat/conversation/chat_composer_fixtures.dart @@ -0,0 +1,40 @@ +import 'dart:async'; + +import 'package:pipelines_app/core/api_gateway.dart'; + +/// A fake gateway for the composer. The test controls each prompt/interrupt +/// reply; unsolicited frames are pushed through [emitEvent]. +class FakeComposerGateway implements ApiGateway { + final calls = <({String type, JsonMap fields})>[]; + final _frames = StreamController.broadcast(); + Future Function(String text, String operationId)? prompt; + Future Function()? interrupt; + + @override + Future call(String type, [JsonMap fields = const {}]) async { + calls.add((type: type, fields: fields)); + switch (type) { + case 'chat_prompt': + final body = fields['chat_prompt'] as JsonMap? ?? const {}; + return prompt == null + ? {} + : prompt!('${body['text'] ?? ''}', '${body['operation_id'] ?? ''}'); + case 'chat_interrupt': + return interrupt == null ? {} : interrupt!(); + } + return {}; + } + + @override + Stream get frames => _frames.stream; + + void emitEvent(JsonMap body) => + _frames.add({'type': 'chat_event', 'chat_event': body}); + + List get promptBodies => calls + .where((call) => call.type == 'chat_prompt') + .map((call) => call.fields['chat_prompt'] as JsonMap) + .toList(); + + void close() => _frames.close(); +} diff --git a/app/test/features/chat/conversation/chat_composer_send_test.dart b/app/test/features/chat/conversation/chat_composer_send_test.dart new file mode 100644 index 00000000..a7f6257f --- /dev/null +++ b/app/test/features/chat/conversation/chat_composer_send_test.dart @@ -0,0 +1,240 @@ +import 'dart:async'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_composer_controller.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_draft_store.dart'; + +import 'chat_composer_fixtures.dart'; + +void main() { + late FakeComposerGateway gateway; + late MemoryChatDraftStore drafts; + late ChatComposerController controller; + late List optimistic; + late List rejected; + late int sequence; + + setUp(() { + gateway = FakeComposerGateway(); + drafts = MemoryChatDraftStore(); + optimistic = []; + rejected = []; + sequence = 0; + controller = ChatComposerController( + gateway, + 's', + drafts: drafts, + newOperationId: () => 'op/${++sequence}', + onOptimistic: optimistic.add, + onRejected: (send, error) => rejected.add(error), + ); + }); + + tearDown(() { + controller.dispose(); + gateway.close(); + }); + + test('sends the exact trimmed wire identity and clears the draft', () async { + await controller.setDraft(' hello '); + + await controller.send(); + + expect(gateway.calls, hasLength(1)); + expect(gateway.calls.single.type, 'chat_prompt'); + expect(gateway.calls.single.fields, { + 'chat_prompt': { + 'session_id': 's', + 'text': 'hello', + 'operation_id': 'op/1', + 'native_message_id': 'msg_op1', + }, + }); + expect(controller.draft, ''); + expect(drafts.entries, isEmpty); + expect(controller.sending, isFalse); + expect(controller.error, isNull); + expect(optimistic.single.text, 'hello'); + expect(optimistic.single.operationId, 'op/1'); + expect(optimistic.single.nativeMessageId, 'msg_op1'); + expect(optimistic.single.optimisticId, 'msg_op1'); + }); + + test('a whitespace-only draft sends nothing', () async { + await controller.setDraft(' \n '); + + await controller.send(); + + expect(gateway.calls, isEmpty); + expect(optimistic, isEmpty); + expect(controller.draft, ' \n '); + expect(controller.sending, isFalse); + }); + + test('a second send is refused while one request is in flight', () async { + final reply = Completer>(); + gateway.prompt = (_, _) => reply.future; + await controller.setDraft('one'); + + final first = controller.send(); + await pumpEventQueue(); + expect(controller.sending, isTrue); + expect(gateway.promptBodies, hasLength(1)); + + await controller.send(); + expect(gateway.promptBodies, hasLength(1)); + expect(optimistic, hasLength(1)); + + reply.complete(const {}); + await first; + expect(controller.sending, isFalse); + }); + + test('a refused unchanged intent retries with the same identity', () async { + var fail = true; + gateway.prompt = (_, _) async { + if (fail) throw StateError('response lost'); + return const {}; + }; + await controller.setDraft(' keep me '); + + await controller.send(); + expect(controller.error, contains('response lost')); + expect(controller.draft, ' keep me '); + expect(await drafts.read('s'), ' keep me '); + expect(rejected.single, contains('response lost')); + + fail = false; + await controller.send(); + expect(gateway.promptBodies.map((body) => body['operation_id']), [ + 'op/1', + 'op/1', + ]); + expect(gateway.promptBodies.map((body) => body['native_message_id']), [ + 'msg_op1', + 'msg_op1', + ]); + expect(controller.draft, ''); + expect(controller.error, isNull); + + fail = true; + await controller.setDraft('other'); + await controller.send(); + expect(gateway.promptBodies.last['operation_id'], 'op/2'); + expect(gateway.promptBodies.last['native_message_id'], 'msg_op2'); + }); + + test('a refusal keeps newer typing instead of restoring the draft', () async { + final reply = Completer>(); + gateway.prompt = (_, _) => reply.future; + await controller.setDraft('original'); + + final sending = controller.send(); + await pumpEventQueue(); + await controller.setDraft('newer'); + + reply.completeError(StateError('refused')); + await sending; + + expect(controller.draft, 'newer'); + expect(await drafts.read('s'), 'newer'); + expect(controller.error, contains('refused')); + expect(rejected.single, contains('refused')); + // The optimistic turn still carries the intent that was refused. + expect(optimistic.single.text, 'original'); + }); + + test( + 'takes the queued flag from the reply and clears it on a live frame', + () async { + gateway.prompt = (_, _) async => {'chat_queued': true}; + + await controller.setDraft('first'); + await controller.send(); + expect(controller.queued, isTrue); + + gateway.emitEvent({'session_id': 'other', 'kind': 'text'}); + await pumpEventQueue(); + expect(controller.queued, isTrue, reason: 'not this conversation'); + + gateway.emitEvent({'session_id': 's', 'kind': 'usage'}); + gateway.emitEvent({'session_id': 's', 'kind': 'compaction'}); + await pumpEventQueue(); + expect(controller.queued, isTrue, reason: 'no turn moved on'); + + gateway.emitEvent({'session_id': 's', 'kind': 'step'}); + await pumpEventQueue(); + expect(controller.queued, isFalse); + }, + ); + + test('a reply without chat_queued clears a previous queued flag', () async { + gateway.prompt = (_, _) async => {'chat_queued': true}; + await controller.setDraft('first'); + await controller.send(); + expect(controller.queued, isTrue); + + gateway.prompt = (_, _) async => const {}; + await controller.setDraft('second'); + await controller.send(); + expect(controller.queued, isFalse); + }); + + test( + 'Stop sends the exact interrupt query and leaves state to the frame', + () async { + gateway.prompt = (_, _) async => {'chat_queued': true}; + await controller.setDraft('queued'); + await controller.send(); + + await controller.stop(); + + final stop = gateway.calls.singleWhere( + (call) => call.type == 'chat_interrupt', + ); + expect(stop.fields, { + 'chat_query': {'session_id': 's'}, + }); + expect(controller.error, isNull); + expect(controller.stopping, isFalse); + // Nothing settles the queued prompt behind the composer's back. + expect(controller.queued, isTrue); + }, + ); + + test('a refused Stop stays visible and settles nothing', () async { + gateway.prompt = (_, _) async => {'chat_queued': true}; + await controller.setDraft('queued'); + await controller.send(); + gateway.interrupt = () async => throw StateError('cannot stop'); + + await controller.stop(); + + expect(controller.error, contains('cannot stop')); + expect(controller.stopping, isFalse); + expect(controller.queued, isTrue); + expect(controller.sending, isFalse); + }); + + test('a late reply after disposal changes and reports nothing', () async { + final reply = Completer>(); + gateway.prompt = (_, _) => reply.future; + await controller.setDraft('bye'); + + final sending = controller.send(); + await pumpEventQueue(); + expect(optimistic, hasLength(1)); + + controller.dispose(); + gateway.emitEvent({'session_id': 's', 'kind': 'step'}); + await controller.send(); + expect(gateway.promptBodies, hasLength(1)); + + reply.completeError(StateError('late response')); + await sending; + + expect(rejected, isEmpty); + expect(controller.error, isNull); + expect(controller.draft, ''); + }); +}