kasy-cli 1.21.9 → 1.22.0

package/templates/firebase/lib/features/{llm_chat/providers/llm_chat_notifier.dart → ai_chat/providers/ai_chat_notifier.dart}

@@ -6,8 +6,9 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:kasy_kit/core/config/app_env.dart';
 import 'package:kasy_kit/core/states/translations.dart';
 import 'package:kasy_kit/core/states/user_state_notifier.dart';
-import 'package:kasy_kit/features/llm_chat/api/llm_chat_api.dart';
-import 'package:kasy_kit/features/llm_chat/api/llm_chat_message_entity.dart';
+import 'package:kasy_kit/features/ai_chat/api/ai_chat_api.dart';
+import 'package:kasy_kit/features/ai_chat/api/ai_chat_message_entity.dart';
+import 'package:kasy_kit/features/ai_chat/providers/ai_conversations_notifier.dart';
 import 'package:logger/logger.dart';
 
 /// Maximum number of recent messages sent to the AI as context.
@@ -34,39 +35,39 @@ class ChatMessage {
   factory ChatMessage.assistant(String content) =>
       ChatMessage(role: 'assistant', content: content);
 
-  factory ChatMessage.fromEntity(LlmChatMessageEntity entity) =>
+  factory ChatMessage.fromEntity(AiChatMessageEntity entity) =>
       ChatMessage(role: entity.role, content: entity.content);
 
-  LlmChatMessageEntity toEntity() => LlmChatMessageEntity(
+  AiChatMessageEntity toEntity() => AiChatMessageEntity(
     role: role,
     content: content,
     createdAt: DateTime.now(),
   );
 }
 
-/// UI state for the LLM chat screen.
-class LlmChatState {
+/// UI state for the AI chat screen.
+class AiChatState {
   final List<ChatMessage> messages;
 
-  /// True while the HTTP request to the LLM backend is in-flight.
+  /// True while the HTTP request to the AI backend is in-flight.
   final bool isReplying;
 
   /// True once the first SSE chunk has been received.
   /// While true the last message in [messages] is the partial assistant reply.
   final bool streamingStarted;
 
-  const LlmChatState({
+  const AiChatState({
     required this.messages,
     this.isReplying = false,
     this.streamingStarted = false,
   });
 
-  LlmChatState copyWith({
+  AiChatState copyWith({
     List<ChatMessage>? messages,
     bool? isReplying,
     bool? streamingStarted,
   }) {
-    return LlmChatState(
+    return AiChatState(
       messages: messages ?? this.messages,
       isReplying: isReplying ?? this.isReplying,
       streamingStarted: streamingStarted ?? this.streamingStarted,
@@ -74,39 +75,56 @@ class LlmChatState {
   }
 }
 
-/// Manages LLM chat state: loads history from the backend on init,
+/// Manages AI chat state for the conversation currently selected
+/// ([selectedConversationIdProvider]): loads that conversation's history,
 /// persists each message, and streams the assistant reply word-by-word via SSE.
-final llmChatNotifierProvider =
-    AsyncNotifierProvider<LlmChatNotifier, LlmChatState>(LlmChatNotifier.new);
+/// Re-runs [build] whenever the selected conversation changes.
+final aiChatNotifierProvider =
+    AsyncNotifierProvider<AiChatNotifier, AiChatState>(AiChatNotifier.new);
 
-class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
+class AiChatNotifier extends AsyncNotifier<AiChatState> {
   final Logger _logger = Logger();
 
+  /// The conversation a reply is currently streaming into. Used to ignore UI
+  /// updates if the user switches conversations mid-stream (the reply is still
+  /// persisted to the right conversation, just not shown on the wrong one).
+  String? _streamingConversationId;
+
+  bool get _streamStillActive =>
+      ref.read(selectedConversationIdProvider) == _streamingConversationId;
+
   @override
-  Future<LlmChatState> build() async {
+  Future<AiChatState> build() async {
+    final conversationId = ref.watch(selectedConversationIdProvider);
     final userId = ref.read(userStateNotifierProvider).user.idOrNull;
-    if (userId == null) return const LlmChatState(messages: []);
+    if (conversationId == null || userId == null) {
+      return const AiChatState(messages: []);
+    }
 
     try {
-      final entities = await ref.read(llmChatApiProvider).loadMessages(userId);
-      return LlmChatState(
+      final entities = await ref
+          .read(aiChatApiProvider)
+          .loadMessages(userId, conversationId);
+      return AiChatState(
         messages: entities.map(ChatMessage.fromEntity).toList(),
       );
     } catch (e) {
-      _logger.e('Failed to load LLM chat history: $e');
+      _logger.e('Failed to load AI chat history: $e');
       // Graceful fallback: start fresh if the backend is unavailable.
-      return const LlmChatState(messages: []);
+      return const AiChatState(messages: []);
     }
   }
 
   /// Adds the user message to the conversation, persists it, then streams
   /// the assistant reply chunk-by-chunk via SSE, updating state on each token.
   Future<void> sendMessage(String prompt) async {
+    final conversationId = ref.read(selectedConversationIdProvider);
     final current = switch (state) {
       AsyncData(:final value) => value,
       _ => null,
     };
-    if (current == null || current.isReplying) return;
+    if (conversationId == null || current == null || current.isReplying) return;
+    _streamingConversationId = conversationId;
 
     final userMsg = ChatMessage.user(prompt);
     state = AsyncData(
@@ -117,26 +135,29 @@ class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
       ),
     );
 
-    _persistMessage(userMsg);
+    _persistMessage(userMsg, conversationId);
 
     // Pass only the last _kMaxContextMessages messages to the AI.
     // The full history is still stored in the DB for the user to read.
-    final allMessages = (state as AsyncData<LlmChatState>).value.messages;
+    final allMessages = (state as AsyncData<AiChatState>).value.messages;
     final history = allMessages.length > _kMaxContextMessages
         ? allMessages.sublist(allMessages.length - _kMaxContextMessages)
         : allMessages;
-    await _requestReplyStream(history);
+    await _requestReplyStream(history, conversationId);
   }
 
   // ---------------------------------------------------------------------------
   // SSE streaming
   // ---------------------------------------------------------------------------
 
-  Future<void> _requestReplyStream(List<ChatMessage> history) async {
-    final t = ref.read(translationsProvider).llm_chat;
-    final String llmChatEndpoint = AppEnv.llmChatEndpoint;
+  Future<void> _requestReplyStream(
+    List<ChatMessage> history,
+    String conversationId,
+  ) async {
+    final t = ref.read(translationsProvider).ai_chat;
+    final String aiChatEndpoint = AppEnv.aiChatEndpoint;
 
-    if (llmChatEndpoint.isEmpty) {
+    if (aiChatEndpoint.isEmpty) {
       _finalizeAssistantMessage(t.error_not_configured);
       return;
     }
@@ -158,7 +179,7 @@ class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
 
     try {
       final response = await dio.post<ResponseBody>(
-        llmChatEndpoint,
+        aiChatEndpoint,
         data: {
           'message': history.last.content,
           'history': history
@@ -199,7 +220,7 @@ class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
       // Persist the complete assistant reply once the stream ends.
       final fullContent = contentBuffer.toString();
       if (fullContent.isNotEmpty) {
-        _persistMessage(ChatMessage.assistant(fullContent));
+        _persistMessage(ChatMessage.assistant(fullContent), conversationId);
       } else {
         // Stream ended with no content (e.g. error event)
         _finalizeAssistantMessage(t.error_no_reply);
@@ -211,19 +232,21 @@ class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
         AsyncData(:final value) => value,
         _ => null,
       };
-      if (latest != null) {
+      if (latest != null && _streamStillActive) {
         state = AsyncData(
           latest.copyWith(isReplying: false, streamingStarted: false),
         );
       }
     } catch (error) {
-      _logger.e('LLM chat stream failed: $error');
+      _logger.e('AI chat stream failed: $error');
       _finalizeAssistantMessage(t.error_network);
     }
   }
 
   /// Called on every incoming SSE token to update the last assistant bubble.
   void _appendStreamingChunk(String partialContent) {
+    // Ignore chunks if the user navigated to another conversation mid-stream.
+    if (!_streamStillActive) return;
     final current = switch (state) {
       AsyncData(:final value) => value,
       _ => null,
@@ -241,22 +264,24 @@ class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
         : [...msgs, ChatMessage.assistant(partialContent)];
 
     state = AsyncData(
-      LlmChatState(messages: newMsgs, isReplying: true, streamingStarted: true),
+      AiChatState(messages: newMsgs, isReplying: true, streamingStarted: true),
     );
   }
 
   /// Replaces (or appends) the assistant bubble with [content] and marks
   /// the reply as finished. Used for error messages and empty-stream fallback.
   void _finalizeAssistantMessage(String content) {
+    // Ignore if the user navigated to another conversation mid-stream.
+    if (!_streamStillActive) return;
     final current = switch (state) {
       AsyncData(:final value) => value,
-      _ => const LlmChatState(messages: []),
+      _ => const AiChatState(messages: []),
     };
     final msgs = current.messages;
     final newMsgs = current.streamingStarted
         ? [...msgs.sublist(0, msgs.length - 1), ChatMessage.assistant(content)]
         : [...msgs, ChatMessage.assistant(content)];
-    state = AsyncData(LlmChatState(messages: newMsgs));
+    state = AsyncData(AiChatState(messages: newMsgs));
   }
 
   // ---------------------------------------------------------------------------
@@ -302,14 +327,24 @@ class LlmChatNotifier extends AsyncNotifier<LlmChatState> {
   // Persistence
   // ---------------------------------------------------------------------------
 
-  void _persistMessage(ChatMessage message) {
+  void _persistMessage(ChatMessage message, String conversationId) {
     final userId = ref.read(userStateNotifierProvider).user.idOrNull;
     if (userId == null) return;
+    final entity = message.toEntity();
     ref
-        .read(llmChatApiProvider)
-        .saveMessage(userId, message.toEntity())
+        .read(aiChatApiProvider)
+        .saveMessage(userId, conversationId, entity)
         .catchError((e) {
           _logger.e('Failed to persist message: $e');
         });
+    // Keep the conversation list preview + ordering in sync.
+    ref
+        .read(aiConversationsNotifierProvider.notifier)
+        .touch(
+          conversationId,
+          role: message.role,
+          content: message.content,
+          at: entity.createdAt,
+        );
   }
 }

package/templates/firebase/lib/features/ai_chat/providers/ai_conversations_notifier.dart

@@ -0,0 +1,103 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_riverpod/legacy.dart';
+import 'package:kasy_kit/core/states/user_state_notifier.dart';
+import 'package:kasy_kit/features/ai_chat/api/ai_chat_api.dart';
+import 'package:kasy_kit/features/ai_chat/api/ai_chat_conversation_entity.dart';
+import 'package:logger/logger.dart';
+
+/// The conversation currently open in the detail pane (null = none selected).
+///
+/// On wide layouts a null value shows the "pick a conversation" placeholder;
+/// on phones a null value means the list is showing (no conversation pushed).
+final selectedConversationIdProvider = StateProvider<String?>((ref) => null);
+
+/// Loads and mutates the user's conversation list. Backend-agnostic: it only
+/// talks to [aiChatApiProvider] and [AiChatConversationEntity], so this single
+/// file is shared across the Firebase / Supabase / API templates.
+final aiConversationsNotifierProvider =
+    AsyncNotifierProvider<
+      AiConversationsNotifier,
+      List<AiChatConversationEntity>
+    >(AiConversationsNotifier.new);
+
+class AiConversationsNotifier
+    extends AsyncNotifier<List<AiChatConversationEntity>> {
+  final Logger _logger = Logger();
+
+  String? get _userId => ref.read(userStateNotifierProvider).user.idOrNull;
+
+  List<AiChatConversationEntity>? get _current => switch (state) {
+    AsyncData(:final value) => value,
+    _ => null,
+  };
+
+  @override
+  Future<List<AiChatConversationEntity>> build() async {
+    final userId = _userId;
+    if (userId == null) return const [];
+    try {
+      return await ref.read(aiChatApiProvider).loadConversations(userId);
+    } catch (e) {
+      _logger.e('Failed to load conversations: $e');
+      // Graceful fallback: start with an empty list if the backend is down.
+      return const [];
+    }
+  }
+
+  /// Creates an empty conversation, prepends it to the list, and returns its id.
+  Future<String?> create() async {
+    final userId = _userId;
+    if (userId == null) return null;
+    try {
+      final conversation = await ref
+          .read(aiChatApiProvider)
+          .createConversation(userId);
+      state = AsyncData([conversation, ...?_current]);
+      return conversation.id;
+    } catch (e) {
+      _logger.e('Failed to create conversation: $e');
+      return null;
+    }
+  }
+
+  /// Deletes a conversation (and its messages) and removes it from the list.
+  Future<void> delete(String conversationId) async {
+    final userId = _userId;
+    if (userId == null) return;
+    // Optimistic removal so the UI feels instant.
+    state = AsyncData(
+      (_current ?? const []).where((c) => c.id != conversationId).toList(),
+    );
+    if (ref.read(selectedConversationIdProvider) == conversationId) {
+      ref.read(selectedConversationIdProvider.notifier).state = null;
+    }
+    try {
+      await ref
+          .read(aiChatApiProvider)
+          .deleteConversation(userId, conversationId);
+    } catch (e) {
+      _logger.e('Failed to delete conversation: $e');
+    }
+  }
+
+  /// Updates the denormalized last-message fields and moves the conversation to
+  /// the top of the list. Called by the chat notifier after each message.
+  void touch(
+    String conversationId, {
+    required String role,
+    required String content,
+    required DateTime at,
+  }) {
+    final current = _current;
+    if (current == null) return;
+    final index = current.indexWhere((c) => c.id == conversationId);
+    if (index == -1) return;
+    final updated = current[index].copyWith(
+      lastMessageRole: role,
+      lastMessageContent: content,
+      updatedAt: at,
+    );
+    final rest = [...current]..removeAt(index);
+    state = AsyncData([updated, ...rest]);
+  }
+}

package/templates/firebase/lib/features/{llm_chat/ui/widgets/llm_chat_avatars.dart → ai_chat/ui/widgets/ai_chat_avatars.dart}

@@ -8,19 +8,19 @@ import 'package:kasy_kit/features/settings/ui/widgets/avatar_utils.dart';
 import 'package:kasy_kit/i18n/translations.g.dart';
 
 /// Diameter used beside chat bubbles.
-const double kLlmChatAvatarDiameter = 32;
+const double kAiChatAvatarDiameter = 32;
 
 /// Diameter shown in the empty state hero.
-const double kLlmChatEmptyAvatarDiameter = 64;
+const double kAiChatEmptyAvatarDiameter = 64;
 
 /// Bundled launcher icon ([flutter_launcher_icons] → `assets/images/icon.png`).
-const String kLlmChatAppIconAsset = 'assets/images/icon.png';
+const String kAiChatAppIconAsset = 'assets/images/icon.png';
 
 /// Project / assistant avatar — app icon when bundled, [KasyAvatar] fallback otherwise.
-class LlmChatAssistantAvatar extends StatelessWidget {
-  const LlmChatAssistantAvatar({
+class AiChatAssistantAvatar extends StatelessWidget {
+  const AiChatAssistantAvatar({
     super.key,
-    this.diameter = kLlmChatAvatarDiameter,
+    this.diameter = kAiChatAvatarDiameter,
     this.showShadow = false,
   });
 
@@ -31,7 +31,7 @@ class LlmChatAssistantAvatar extends StatelessWidget {
   Widget build(BuildContext context) {
     return KasyAvatar(
       diameter: diameter,
-      image: const AssetImage(kLlmChatAppIconAsset),
+      image: const AssetImage(kAiChatAppIconAsset),
       icon: KasyIcons.packageOutline,
       fallbackSurface: KasyAvatarFallbackSurface.soft,
       showShadow: showShadow,
@@ -41,10 +41,10 @@ class LlmChatAssistantAvatar extends StatelessWidget {
 }
 
 /// User avatar resolved from profile photo, initials, or [KasyAvatar] fallback.
-class LlmChatUserAvatar extends ConsumerWidget {
-  const LlmChatUserAvatar({
+class AiChatUserAvatar extends ConsumerWidget {
+  const AiChatUserAvatar({
     super.key,
-    this.diameter = kLlmChatAvatarDiameter,
+    this.diameter = kAiChatAvatarDiameter,
     this.showShadow = false,
   });
 
@@ -61,7 +61,7 @@ class LlmChatUserAvatar extends ConsumerWidget {
         :final email,
         :final avatarPath,
       ) =>
-        _LlmChatUserAvatarContent(
+        _AiChatUserAvatarContent(
           diameter: diameter,
           userId: id,
           avatarPath: avatarPath,
@@ -91,8 +91,8 @@ class LlmChatUserAvatar extends ConsumerWidget {
   }
 }
 
-class _LlmChatUserAvatarContent extends StatelessWidget {
-  const _LlmChatUserAvatarContent({
+class _AiChatUserAvatarContent extends StatelessWidget {
+  const _AiChatUserAvatarContent({
     required this.diameter,
     required this.userId,
     required this.avatarPath,

package/templates/firebase/lib/features/{llm_chat/ui/widgets/llm_chat_composer.dart → ai_chat/ui/widgets/ai_chat_composer.dart}

@@ -6,11 +6,11 @@ import 'package:kasy_kit/core/theme/theme.dart';
 import 'package:kasy_kit/i18n/translations.g.dart';
 
 /// Maximum characters allowed in a single chat message.
-const int kLlmChatMaxMessageLength = 2000;
+const int kAiChatMaxMessageLength = 2000;
 
 /// Unified chat bar: primary [KasyTextField] shell (surface, border, shadow) + send orb inside.
-class LlmChatComposer extends StatefulWidget {
-  const LlmChatComposer({
+class AiChatComposer extends StatefulWidget {
+  const AiChatComposer({
     super.key,
     required this.controller,
     required this.onSend,
@@ -24,10 +24,10 @@ class LlmChatComposer extends StatefulWidget {
   static const int _maxLines = 5;
 
   @override
-  State<LlmChatComposer> createState() => _LlmChatComposerState();
+  State<AiChatComposer> createState() => _AiChatComposerState();
 }
 
-class _LlmChatComposerState extends State<LlmChatComposer> {
+class _AiChatComposerState extends State<AiChatComposer> {
   bool _canSend = false;
 
   @override
@@ -45,7 +45,7 @@ class _LlmChatComposerState extends State<LlmChatComposer> {
 
   bool _hasSendableText(String value) {
     final String trimmed = value.trim();
-    return trimmed.isNotEmpty && trimmed.length <= kLlmChatMaxMessageLength;
+    return trimmed.isNotEmpty && trimmed.length <= kAiChatMaxMessageLength;
   }
 
   void _onTextChanged() {
@@ -90,13 +90,13 @@ class _LlmChatComposerState extends State<LlmChatComposer> {
                 controller: widget.controller,
                 enabled: enabled,
                 variant: KasyTextFieldVariant.embedded,
-                hint: t.llm_chat.hint,
+                hint: t.ai_chat.hint,
                 minLines: 1,
-                maxLines: LlmChatComposer._maxLines,
+                maxLines: AiChatComposer._maxLines,
                 textCapitalization: TextCapitalization.sentences,
                 textInputAction: TextInputAction.newline,
                 inputFormatters: [
-                  LengthLimitingTextInputFormatter(kLlmChatMaxMessageLength),
+                  LengthLimitingTextInputFormatter(kAiChatMaxMessageLength),
                 ],
                 onSubmitted: (_) => _handleSend(),
               ),
@@ -112,7 +112,7 @@ class _LlmChatComposerState extends State<LlmChatComposer> {
                   size: KasyButtonSize.small,
                   iconOnlyLayoutExtent: 36,
                   iconGlyphSize: 18,
-                  semanticLabel: t.llm_chat.hint,
+                  semanticLabel: t.ai_chat.hint,
                 ),
               ),
             ],