import '../../../core/api_gateway.dart'; import '../../../core/error_reason.dart'; import '../../../core/transport/connection_state.dart'; import '../data/chat_repository.dart'; import '../domain/chat_commands.dart'; /// Shows one local line in the conversation the command ran in. typedef ChatCommandNoticeCallback = void Function(String text, {bool failed}); /// Hands the chat's row under its fresh native session id to the destination, /// with the id it replaces and the line the fresh conversation opens on. The /// destination owns navigation: it swaps the list row in place, opens the new /// id and refreshes the list from the server. typedef ChatNewSessionCallback = void Function(String previousId, JsonMap session, String notice); /// Runs the recorded commands that act on the open session: `/new`, `/close` /// and `/rename `. /// /// Every outcome is a local notice, never a prompt. `/new` is the server's /// `chat_new_session` (the same chat on a fresh context, as the harness's own /// `/new` or `/clear`); `/close` and `/rename` are the Close chat confirm's and /// Rename dialog's requests. `/stop` and `/help` are not run here; [runs] says /// which commands are. class ChatCommandActions { ChatCommandActions({ required this.repository, required this.sessionId, required this.showNotice, required this.confirmClose, required this.startedNewSession, this.onRenamed, this.onClosed, }); final ChatRepository repository; final String sessionId; final ChatCommandNoticeCallback showNotice; /// Opens the row's `Close chat?` confirm; false sends nothing. final Future<bool> Function() confirmClose; final ChatNewSessionCallback startedNewSession; /// The server accepted the shared rename with this trimmed title. final void Function(String title)? onRenamed; /// The server accepted the close; the conversation is finished here too. final void Function()? onClosed; /// Whether [command] is one this runner performs. static bool runs(ChatCommand command) => const { chatCommandNew, chatCommandClose, chatCommandRename, }.contains(command.name); /// Performs [command] with the draft's trimmed [argument]. The caller has /// already consumed the draft; a usage error here is a failed notice and /// sends nothing. Future<void> run(ChatCommand command, String argument) async { if (!command.takesArgument && argument.isNotEmpty) { showNotice(chatCommandArgumentReport(command), failed: true); return; } switch (command.name) { case chatCommandNew: await _startSession(); case chatCommandClose: await _closeSession(); case chatCommandRename: await _renameSession(argument); } } /// `/new`: `chat_new_session` keeps this chat (row, title, colour, star, /// directory, model and mode) and moves it to a fresh native session, so the /// agent starts from an empty context. The reply's row, under its new id, is /// handed to the destination with the notice the fresh conversation opens /// on; a refusal (a running turn, say) stays in this conversation. Future<void> _startSession() async { try { final reply = await repository.newSession( sessionId, instructions: chatDefaultSessionInstructions, ); final session = reply['chat_session']; final id = session is Map ? '${session['id'] ?? ''}'.trim() : ''; if (session is! Map || id.isEmpty || id == sessionId) { throw const ProtocolError( 'The server did not return the new session for this chat.', ); } final row = Map<String, dynamic>.from(session)..remove('previous_id'); startedNewSession(sessionId, row, chatNewSessionNotice); } catch (error) { showNotice(chatNewSessionFailedNotice(_reason(error)), failed: true); } } /// `/close`: the row's confirm, then the existing `chat_close`. Cancelling /// sends nothing; a refusal is the server's words. Future<void> _closeSession() async { if (!await confirmClose()) return; try { await repository.close(sessionId); onClosed?.call(); } catch (error) { showNotice(_reason(error), failed: true); } } /// `/rename <title>`: the same shared `chat_rename` the Rename dialog sends, /// with the trimmed title. No title is a usage error and sends nothing. Future<void> _renameSession(String title) async { if (title.isEmpty) { showNotice(chatRenameUsageReport, failed: true); return; } try { await repository.rename(sessionId, title); onRenamed?.call(title); showNotice(chatSessionRenamedNotice(title)); } catch (error) { showNotice(_reason(error), failed: true); } } /// The server's words without a Dart runtime prefix, as the web prints them. String _reason(Object error) => describeErrorReason(error, fallback: 'The server gave no reason.'); }