neoagent 2.3.1-beta.86 → 2.3.1-beta.88

package/docs/capabilities.md

@@ -33,6 +33,7 @@ Recording sessions support:
 - Retry transcription and delete transcript segment actions.
 - Full session deletion with storage cleanup.
 - Agent tools for listing, opening, and searching transcripts: `recordings_list`, `recordings_get`, and `recordings_search`.
+- A keyless social video extractor for public YouTube, TikTok, Instagram, and X URLs through `social_video_extract`, with metadata-first fetch, captions-first transcript strategy, STT fallback, and representative frame extraction.
 
 Transcription uses Deepgram when `DEEPGRAM_API_KEY` is configured. The default speech model is `nova-3`, and the default language mode is `multi`. When `auto_recording_insights` is enabled in AI settings, NeoAgent can generate structured recording insights such as a summary, action items, and events.
 
@@ -102,6 +103,7 @@ NeoAgent's agent tool surface includes more than basic chat:
 | Output | Generate markdown tables and Mermaid graphs |
 | Images | Generate images with Grok and analyze local image files with a vision-capable model |
 | Recordings | List, inspect, and search recording transcripts |
+| Social video | Extract title, description, transcript, and a representative frame from public social video URLs |
 | Health | Read synced mobile health metrics |
 
 Generated binary or text artifacts can be promoted into user-scoped artifact storage under `~/.neoagent/data/artifacts` and served through authenticated `/api/artifacts/:id/content` URLs.

package/flutter_app/android/app/src/main/AndroidManifest.xml

@@ -56,6 +56,20 @@
                 <action android:name="android.intent.action.MAIN"/>
                 <category android:name="android.intent.category.LAUNCHER"/>
             </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.SEND" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="text/*" />
+                <data android:mimeType="video/*" />
+                <data android:mimeType="image/*" />
+                <data android:mimeType="audio/*" />
+                <data android:mimeType="application/*" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.SEND_MULTIPLE" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="*/*" />
+            </intent-filter>
         </activity>
         <provider
             android:name="androidx.core.content.FileProvider"

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/MainActivity.kt

@@ -8,6 +8,7 @@ import android.net.Uri
 import android.os.BatteryManager
 import android.os.Build
 import android.provider.Settings
+import android.provider.OpenableColumns
 import android.view.KeyEvent
 import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.contract.ActivityResultContracts
@@ -55,6 +56,7 @@ class MainActivity : FlutterFragmentActivity() {
     private var widgetEventSink: EventChannel.EventSink? = null
     private var appLaunchEventSink: EventChannel.EventSink? = null
     private var pendingAppLaunchAction: String? = null
+    private var pendingSharePayload: Map<String, Any?>? = null
 
     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
         super.configureFlutterEngine(flutterEngine)
@@ -590,6 +592,7 @@ class MainActivity : FlutterFragmentActivity() {
 
         captureWidgetIntent(intent)
         captureAppLaunchIntent(intent)
+        captureShareIntent(intent)
     }
 
     override fun onNewIntent(intent: Intent) {
@@ -597,6 +600,7 @@ class MainActivity : FlutterFragmentActivity() {
         setIntent(intent)
         captureWidgetIntent(intent)
         captureAppLaunchIntent(intent)
+        captureShareIntent(intent)
     }
 
     override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
@@ -723,11 +727,91 @@ class MainActivity : FlutterFragmentActivity() {
 
     private fun emitPendingAppLaunchIntent() {
         val sink = appLaunchEventSink ?: return
+        val sharePayload = pendingSharePayload
+        if (sharePayload != null) {
+            pendingSharePayload = null
+            sink.success(sharePayload)
+            return
+        }
         val action = pendingAppLaunchAction ?: return
         pendingAppLaunchAction = null
         sink.success(mapOf("action" to action))
     }
 
+    private fun captureShareIntent(intent: Intent?) {
+        if (intent == null) {
+            return
+        }
+        if (intent.action != Intent.ACTION_SEND && intent.action != Intent.ACTION_SEND_MULTIPLE) {
+            return
+        }
+
+        val sharedText = intent.getStringExtra(Intent.EXTRA_TEXT)?.trim().orEmpty()
+        val subject = intent.getStringExtra(Intent.EXTRA_SUBJECT)?.trim().orEmpty()
+        val fileUris = mutableListOf<Uri>()
+
+        @Suppress("DEPRECATION")
+        val single = intent.getParcelableExtra<Uri>(Intent.EXTRA_STREAM)
+        if (single != null) {
+            fileUris.add(single)
+        }
+        @Suppress("DEPRECATION")
+        val multiple = intent.getParcelableArrayListExtra<Uri>(Intent.EXTRA_STREAM)
+        if (multiple != null) {
+            fileUris.addAll(multiple)
+        }
+        val clip = intent.clipData
+        if (clip != null) {
+            for (index in 0 until clip.itemCount) {
+                val uri = clip.getItemAt(index)?.uri ?: continue
+                fileUris.add(uri)
+            }
+        }
+
+        val uniqueUris = linkedSetOf<String>()
+        val files = mutableListOf<Map<String, Any?>>()
+        for (uri in fileUris) {
+            val key = uri.toString()
+            if (!uniqueUris.add(key)) continue
+            files.add(buildSharedFileDescriptor(uri))
+        }
+
+        pendingSharePayload = mapOf(
+            "action" to "share_to_chat",
+            "text" to sharedText,
+            "subject" to subject,
+            "files" to files,
+        )
+        emitPendingAppLaunchIntent()
+    }
+
+    private fun buildSharedFileDescriptor(uri: Uri): Map<String, Any?> {
+        var name: String? = null
+        var sizeBytes: Long? = null
+        val type = contentResolver.getType(uri)?.trim().orEmpty()
+        contentResolver.query(uri, null, null, null, null)?.use { cursor ->
+            val nameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+            val sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE)
+            if (cursor.moveToFirst()) {
+                if (nameIndex >= 0) {
+                    name = cursor.getString(nameIndex)?.trim()
+                }
+                if (sizeIndex >= 0 && !cursor.isNull(sizeIndex)) {
+                    sizeBytes = cursor.getLong(sizeIndex)
+                }
+            }
+        }
+        val fallbackName = uri.lastPathSegment?.substringAfterLast('/')?.trim().orEmpty()
+        val resolvedName = (name ?: fallbackName).ifBlank { "Attachment" }
+        return mapOf(
+            "uri" to uri.toString(),
+            "name" to resolvedName,
+            "mimeType" to if (type.isBlank()) "application/octet-stream" else type,
+            "sizeBytes" to sizeBytes,
+            "source" to "android_share_intent",
+        )
+    }
+
     private fun buildVolumeState(audioManager: AudioManager): Map<String, Any> {
         val minVolume =
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {

package/flutter_app/lib/features/notifications/notification_interceptor.dart

@@ -5,7 +5,8 @@ import 'package:notification_listener_service/notification_listener_service.dart
 import 'package:notification_listener_service/notification_event.dart';
 
 class NotificationInterceptor {
-  static final NotificationInterceptor _instance = NotificationInterceptor._internal();
+  static final NotificationInterceptor _instance =
+      NotificationInterceptor._internal();
   factory NotificationInterceptor() => _instance;
   NotificationInterceptor._internal();
 
@@ -13,59 +14,27 @@ class NotificationInterceptor {
   String _backendUrl = '';
   String _token = '';
 
-  Future<void> initialize(BuildContext context, String backendUrl, String token) async {
+  Future<void> initialize(String backendUrl, String token) async {
     _backendUrl = backendUrl;
     _token = token;
 
-    bool isGranted = await NotificationListenerService.isPermissionGranted();
-    if (!isGranted) {
-      bool userAgreed = await _showPermissionRationale(context);
-      if (userAgreed) {
-        await NotificationListenerService.requestPermission();
-      }
-    }
-
-    isGranted = await NotificationListenerService.isPermissionGranted();
+    final isGranted = await NotificationListenerService.isPermissionGranted();
     if (isGranted && !_isListening) {
       _startListening();
     }
   }
 
-  Future<bool> _showPermissionRationale(BuildContext context) async {
-    return await showDialog<bool>(
-      context: context,
-      builder: (context) => AlertDialog(
-        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
-        title: const Text('Notification Access Needed'),
-        content: const Text(
-          'NeoAgent can read your incoming notifications (like Calendar alarms or urgent messages) and proactively act on them.\n\n'
-          'For example, if you receive a reminder, NeoAgent can automatically prepare relevant context for you.',
-        ),
-        actions: [
-          TextButton(
-            onPressed: () => Navigator.of(context).pop(false),
-            child: const Text('Not Now'),
-          ),
-          ElevatedButton(
-            style: ElevatedButton.styleFrom(
-              shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(10)),
-            ),
-            onPressed: () => Navigator.of(context).pop(true),
-            child: const Text('Allow Access'),
-          ),
-        ],
-      ),
-    ) ?? false;
-  }
-
   void _startListening() {
     _isListening = true;
-    NotificationListenerService.notificationsStream.listen((ServiceNotificationEvent event) {
+    NotificationListenerService.notificationsStream.listen((
+      ServiceNotificationEvent event,
+    ) {
       // Filter out noisy system notifications or ongoing foreground services
-      if (event.packageName == null || event.packageName!.contains('android.system')) {
+      if (event.packageName == null ||
+          event.packageName!.contains('android.system')) {
         return;
       }
-      
+
       // We only want to intercept newly posted notifications, not removed ones
       if (event.hasRemoved == true) return;
 
@@ -79,10 +48,7 @@ class NotificationInterceptor {
     try {
       await http.post(
         Uri.parse('$_backendUrl/api/triggers/notification'),
-        headers: {
-          'Content-Type': 'application/json',
-          'Cookie': _token,
-        },
+        headers: {'Content-Type': 'application/json', 'Cookie': _token},
         body: jsonEncode({
           'app_package': event.packageName ?? 'unknown',
           'title': event.title ?? '',

package/flutter_app/lib/main.dart

@@ -11,6 +11,7 @@ import 'package:flutter/gestures.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_markdown/flutter_markdown.dart';
+import 'package:file_picker/file_picker.dart';
 import 'package:flutter_secure_storage/flutter_secure_storage.dart';
 import 'package:google_fonts/google_fonts.dart';
 import 'package:image/image.dart' as img;

package/flutter_app/lib/main_app_shell.dart

@@ -13,17 +13,23 @@ class SplashView extends StatelessWidget {
           colors: <Color>[_accent, _bgSecondary, _bgPrimary],
         ),
       ),
-      child: const Scaffold(
+      child: Scaffold(
         backgroundColor: Colors.transparent,
         body: Center(
           child: Column(
             mainAxisSize: MainAxisSize.min,
             children: <Widget>[
               _BrandLockup(logoSize: 52),
-              SizedBox(height: 18),
-              CircularProgressIndicator(),
-              SizedBox(height: 16),
-              Text('Loading NeoOS'),
+              const SizedBox(height: 18),
+              SizedBox(
+                width: 180,
+                child: ClipRRect(
+                  borderRadius: BorderRadius.circular(999),
+                  child: const LinearProgressIndicator(minHeight: 4),
+                ),
+              ),
+              const SizedBox(height: 14),
+              const Text('Loading NeoOS'),
             ],
           ),
         ),
@@ -1090,11 +1096,7 @@ class _HomeViewState extends State<HomeView> {
             });
 
         if (Platform.isAndroid) {
-          NotificationInterceptor().initialize(
-            context,
-            backendUrl,
-            sessionCookie,
-          );
+          NotificationInterceptor().initialize(backendUrl, sessionCookie);
         }
       }
     }
@@ -1242,12 +1244,19 @@ class _HomeViewState extends State<HomeView> {
           onToggleGroup: _toggleSidebarGroup,
         ),
         appBar: AppBar(
+          toolbarHeight: 48,
+          titleSpacing: 0,
+          leadingWidth: 44,
+          centerTitle: false,
           title: Text(controller.selectedSection.navigationTitle),
+          titleTextStyle: Theme.of(
+            context,
+          ).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w700),
           elevation: 0,
         ),
         body: SafeArea(
           child: Padding(
-            padding: const EdgeInsets.fromLTRB(12, 0, 12, 12),
+            padding: const EdgeInsets.fromLTRB(12, 0, 12, 10),
             child: _GlassSurface(
               borderRadius: BorderRadius.circular(26),
               blurSigma: 24,
@@ -2014,7 +2023,7 @@ class _MobileDrawer extends StatelessWidget {
         child: Column(
           children: <Widget>[
             Padding(
-              padding: const EdgeInsets.fromLTRB(16, 18, 16, 14),
+              padding: const EdgeInsets.fromLTRB(16, 12, 16, 10),
               child: Column(
                 crossAxisAlignment: CrossAxisAlignment.start,
                 children: <Widget>[
@@ -2032,7 +2041,7 @@ class _MobileDrawer extends StatelessWidget {
                     ],
                   ),
                   if (controller.agentProfiles.isNotEmpty) ...<Widget>[
-                    const SizedBox(height: 12),
+                    const SizedBox(height: 10),
                     _AgentSwitcher(
                       controller: controller,
                       onChanged: () => Navigator.of(context).pop(),
@@ -2056,7 +2065,7 @@ class _MobileDrawer extends StatelessWidget {
               ),
             ),
             Padding(
-              padding: const EdgeInsets.all(8),
+              padding: const EdgeInsets.fromLTRB(8, 6, 8, 8),
               child: Row(
                 children: <Widget>[
                   const Spacer(),

package/flutter_app/lib/main_chat.dart

@@ -12,6 +12,9 @@ class ChatPanel extends StatefulWidget {
 class _ChatPanelState extends State<ChatPanel> {
   late final TextEditingController _composerController;
   final ScrollController _scrollController = ScrollController();
+  List<SharedChatAttachment> _pendingSharedAttachments =
+      const <SharedChatAttachment>[];
+  String? _appliedSharedPayloadSignature;
   int _lastMessageCount = 0;
   int _lastToolCount = 0;
   String _lastStream = '';
@@ -25,6 +28,17 @@ class _ChatPanelState extends State<ChatPanel> {
     _consumeQueuedDraft();
   }
 
+  @override
+  void didUpdateWidget(covariant ChatPanel oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (oldWidget.controller != widget.controller) {
+      oldWidget.controller.removeListener(_consumeQueuedDraft);
+      widget.controller.addListener(_consumeQueuedDraft);
+      _appliedSharedPayloadSignature = null;
+      _consumeQueuedDraft();
+    }
+  }
+
   @override
   void dispose() {
     widget.controller.removeListener(_consumeQueuedDraft);
@@ -34,13 +48,114 @@ class _ChatPanelState extends State<ChatPanel> {
   }
 
   void _consumeQueuedDraft() {
-    final draft = widget.controller.takePendingChatDraft();
-    if (draft == null || draft.isEmpty) {
+    final draft = widget.controller.peekPendingChatDraft();
+    final attachments = widget.controller.peekPendingSharedChatAttachments();
+    final signature = _sharedPayloadSignature(draft, attachments);
+    if (draft == null && attachments.isEmpty) {
+      return;
+    }
+    if (_appliedSharedPayloadSignature == signature) {
+      return;
+    }
+    _appliedSharedPayloadSignature = signature;
+    if (!mounted) {
+      return;
+    }
+    setState(() {
+      if ((draft ?? '').isNotEmpty && _composerController.text.trim().isEmpty) {
+        _composerController
+          ..text = draft!
+          ..selection = TextSelection.collapsed(offset: draft.length);
+      }
+      _pendingSharedAttachments = attachments;
+    });
+  }
+
+  String _sharedPayloadSignature(
+    String? draft,
+    List<SharedChatAttachment> attachments,
+  ) {
+    final attachmentSignature = attachments
+        .map((item) => '${item.uri}|${item.name}|${item.mimeType}')
+        .join('::');
+    return '${draft ?? ''}::$attachmentSignature';
+  }
+
+  void _clearSharedPayload() {
+    widget.controller.clearPendingSharedChatPayload();
+    _appliedSharedPayloadSignature = null;
+    if (!mounted) {
+      return;
+    }
+    setState(() {
+      _pendingSharedAttachments = const <SharedChatAttachment>[];
+    });
+  }
+
+  String _mimeTypeForFileName(String fileName) {
+    final ext = fileName.split('.').last.toLowerCase();
+    switch (ext) {
+      case 'jpg':
+      case 'jpeg':
+        return 'image/jpeg';
+      case 'png':
+        return 'image/png';
+      case 'webp':
+        return 'image/webp';
+      case 'gif':
+        return 'image/gif';
+      case 'mp4':
+        return 'video/mp4';
+      case 'mov':
+        return 'video/quicktime';
+      case 'm4v':
+        return 'video/x-m4v';
+      case 'mp3':
+        return 'audio/mpeg';
+      case 'm4a':
+        return 'audio/mp4';
+      case 'wav':
+        return 'audio/wav';
+      case 'pdf':
+        return 'application/pdf';
+      case 'txt':
+        return 'text/plain';
+      default:
+        return 'application/octet-stream';
+    }
+  }
+
+  Future<void> _attachFiles() async {
+    final result = await FilePicker.platform.pickFiles(
+      allowMultiple: true,
+      withData: false,
+      type: FileType.any,
+    );
+    if (!mounted || result == null || result.files.isEmpty) {
       return;
     }
-    _composerController
-      ..text = draft
-      ..selection = TextSelection.collapsed(offset: draft.length);
+    final attachments = result.files
+        .where((file) => file.path?.trim().isNotEmpty == true)
+        .map(
+          (file) => SharedChatAttachment(
+            uri: file.path!,
+            name: file.name,
+            mimeType: _mimeTypeForFileName(file.name),
+            sizeBytes: file.size,
+            source: 'file_picker',
+          ),
+        )
+        .where((item) => item.isValid)
+        .toList(growable: false);
+    if (attachments.isEmpty) {
+      return;
+    }
+    setState(() {
+      _pendingSharedAttachments = <SharedChatAttachment>[
+        ..._pendingSharedAttachments,
+        ...attachments,
+      ];
+    });
   }
 
   void _scrollToBottom() {
@@ -151,6 +266,29 @@ class _ChatPanelState extends State<ChatPanel> {
           ),
           child: Column(
             children: <Widget>[
+              if (_pendingSharedAttachments.isNotEmpty)
+                Padding(
+                  padding: const EdgeInsets.only(bottom: 10),
+                  child: _SharedAttachmentTray(
+                    attachments: _pendingSharedAttachments,
+                    onRemoveAt: (index) {
+                      setState(() {
+                        _pendingSharedAttachments = _pendingSharedAttachments
+                            .asMap()
+                            .entries
+                            .where((entry) => entry.key != index)
+                            .map((entry) => entry.value)
+                            .toList(growable: false);
+                      });
+                      if (_pendingSharedAttachments.isEmpty) {
+                        _clearSharedPayload();
+                      }
+                    },
+                    onClear: () {
+                      _clearSharedPayload();
+                    },
+                  ),
+                ),
               Container(
                 padding: const EdgeInsets.fromLTRB(16, 4, 4, 4),
                 decoration: BoxDecoration(
@@ -179,6 +317,13 @@ class _ChatPanelState extends State<ChatPanel> {
                       ),
                     ),
                     const SizedBox(width: 8),
+                    IconButton(
+                      tooltip: 'Attach files',
+                      onPressed: _attachFiles,
+                      icon: const Icon(Icons.attach_file_rounded),
+                      color: _textSecondary,
+                    ),
+                    const SizedBox(width: 2),
                     FilledButton(
                       onPressed: () => controller.setSelectedSection(
                         AppSection.voiceAssistant,
@@ -199,7 +344,8 @@ class _ChatPanelState extends State<ChatPanel> {
                           ? null
                           : () async {
                               final task = _composerController.text;
-                              if (task.trim().isEmpty ||
+                              if ((task.trim().isEmpty &&
+                                      _pendingSharedAttachments.isEmpty) ||
                                   _isSendingChatMessage) {
                                 return;
                               }
@@ -207,8 +353,14 @@ class _ChatPanelState extends State<ChatPanel> {
                                 _isSendingChatMessage = true;
                               });
                               _composerController.clear();
+                              final outgoingAttachments =
+                                  _pendingSharedAttachments;
+                              _clearSharedPayload();
                               try {
-                                await controller.sendMessage(task);
+                                await controller.sendMessage(
+                                  task,
+                                  sharedAttachments: outgoingAttachments,
+                                );
                               } finally {
                                 if (mounted) {
                                   setState(() {
@@ -268,6 +420,114 @@ class _ChatPanelState extends State<ChatPanel> {
   }
 }
 
+class _SharedAttachmentTray extends StatelessWidget {
+  const _SharedAttachmentTray({
+    required this.attachments,
+    required this.onRemoveAt,
+    required this.onClear,
+  });
+
+  final List<SharedChatAttachment> attachments;
+  final void Function(int index) onRemoveAt;
+  final VoidCallback onClear;
+
+  IconData _iconForMime(String mime) {
+    final normalized = mime.toLowerCase();
+    if (normalized.startsWith('image/')) return Icons.image_outlined;
+    if (normalized.startsWith('video/')) return Icons.videocam_outlined;
+    if (normalized.startsWith('audio/')) return Icons.audiotrack_outlined;
+    if (normalized.contains('pdf')) return Icons.picture_as_pdf_outlined;
+    return Icons.attach_file_rounded;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      width: double.infinity,
+      padding: const EdgeInsets.all(10),
+      decoration: BoxDecoration(
+        color: _bgSecondary,
+        borderRadius: BorderRadius.circular(12),
+        border: Border.all(color: _borderLight),
+      ),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: <Widget>[
+          Row(
+            children: <Widget>[
+              Icon(Icons.forward_to_inbox_outlined, size: 15, color: _info),
+              const SizedBox(width: 6),
+              Expanded(
+                child: Text(
+                  'Shared from another app',
+                  style: TextStyle(
+                    color: _textPrimary,
+                    fontSize: 12,
+                    fontWeight: FontWeight.w700,
+                  ),
+                ),
+              ),
+              TextButton(onPressed: onClear, child: const Text('Clear')),
+            ],
+          ),
+          const SizedBox(height: 6),
+          Wrap(
+            spacing: 8,
+            runSpacing: 8,
+            children: attachments
+                .asMap()
+                .entries
+                .map((entry) {
+                  final item = entry.value;
+                  return Container(
+                    padding: const EdgeInsets.symmetric(
+                      horizontal: 10,
+                      vertical: 7,
+                    ),
+                    decoration: BoxDecoration(
+                      color: _bgCard,
+                      borderRadius: BorderRadius.circular(999),
+                      border: Border.all(color: _border),
+                    ),
+                    child: Row(
+                      mainAxisSize: MainAxisSize.min,
+                      children: <Widget>[
+                        Icon(
+                          _iconForMime(item.mimeType),
+                          size: 14,
+                          color: _textSecondary,
+                        ),
+                        const SizedBox(width: 6),
+                        ConstrainedBox(
+                          constraints: const BoxConstraints(maxWidth: 170),
+                          child: Text(
+                            item.name,
+                            maxLines: 1,
+                            overflow: TextOverflow.ellipsis,
+                            style: TextStyle(color: _textPrimary, fontSize: 12),
+                          ),
+                        ),
+                        const SizedBox(width: 6),
+                        GestureDetector(
+                          onTap: () => onRemoveAt(entry.key),
+                          child: Icon(
+                            Icons.close_rounded,
+                            size: 14,
+                            color: _textMuted,
+                          ),
+                        ),
+                      ],
+                    ),
+                  );
+                })
+                .toList(growable: false),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
 class _TypingIndicatorBubble extends StatefulWidget {
   const _TypingIndicatorBubble();