feat: task based send flow

lib/shared/services/tasks/task_queue.dart

@@ -0,0 +1,210 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:uuid/uuid.dart';
+
+import '../../../core/providers/app_providers.dart';
+import 'outbound_task.dart';
+import 'task_worker.dart';
+
+final taskQueueProvider =
+    StateNotifierProvider<TaskQueueNotifier, List<OutboundTask>>((ref) {
+  return TaskQueueNotifier(ref);
+});
+
+class TaskQueueNotifier extends StateNotifier<List<OutboundTask>> {
+  TaskQueueNotifier(this._ref) : super(const []) {
+    _load();
+  }
+
+  static const _prefsKey = 'outbound_task_queue_v1';
+  final Ref _ref;
+  final _uuid = const Uuid();
+
+  bool _processing = false;
+  final Set<String> _activeThreads = <String>{};
+  int _maxParallel = 2; // bounded parallelism across conversations
+
+  Future<void> _load() async {
+    try {
+      final prefs = _ref.read(sharedPreferencesProvider);
+      final jsonStr = prefs.getString(_prefsKey);
+      if (jsonStr == null || jsonStr.isEmpty) return;
+      final raw = (jsonDecode(jsonStr) as List).cast<Map<String, dynamic>>();
+      final tasks = raw.map(OutboundTask.fromJson).toList();
+      // Only restore non-completed tasks
+      state = tasks
+          .where((t) => t.status == TaskStatus.queued || t.status == TaskStatus.running)
+          .map((t) => t.copyWith(
+                status: TaskStatus.queued,
+                startedAt: null,
+                completedAt: null,
+              ))
+          .toList();
+      // Kick processing after load
+      _process();
+    } catch (e) {
+      debugPrint('DEBUG: Failed to load task queue: $e');
+    }
+  }
+
+  Future<void> _save() async {
+    try {
+      final prefs = _ref.read(sharedPreferencesProvider);
+      final raw = state.map((t) => t.toJson()).toList(growable: false);
+      await prefs.setString(_prefsKey, jsonEncode(raw));
+    } catch (e) {
+      debugPrint('DEBUG: Failed to persist task queue: $e');
+    }
+  }
+
+  Future<String> enqueueSendText({
+    required String? conversationId,
+    required String text,
+    List<String>? attachments,
+    List<String>? toolIds,
+    String? idempotencyKey,
+  }) async {
+    final id = _uuid.v4();
+    final task = OutboundTask.sendTextMessage(
+      id: id,
+      conversationId: conversationId,
+      text: text,
+      attachments: attachments ?? const [],
+      toolIds: toolIds ?? const [],
+      idempotencyKey: idempotencyKey,
+      enqueuedAt: DateTime.now(),
+    );
+    state = [...state, task];
+    await _save();
+    _process();
+    return id;
+  }
+
+  Future<void> cancel(String id) async {
+    state = [
+      for (final t in state)
+        if (t.id == id)
+          t.copyWith(
+            status: TaskStatus.cancelled,
+            completedAt: DateTime.now(),
+          )
+        else
+          t,
+    ];
+    await _save();
+  }
+
+  Future<void> cancelByConversation(String conversationId) async {
+    state = [
+      for (final t in state)
+        if ((t.conversationId ?? '') == conversationId &&
+            (t.status == TaskStatus.queued || t.status == TaskStatus.running))
+          t.copyWith(
+            status: TaskStatus.cancelled,
+            completedAt: DateTime.now(),
+          )
+        else
+          t,
+    ];
+    await _save();
+  }
+
+  Future<void> retry(String id) async {
+    state = [
+      for (final t in state)
+        if (t.id == id)
+          t.copyWith(
+            status: TaskStatus.queued,
+            attempt: (t.attempt + 1),
+            error: null,
+            startedAt: null,
+            completedAt: null,
+          )
+        else
+          t,
+    ];
+    await _save();
+    _process();
+  }
+
+  Future<void> _process() async {
+    if (_processing) return;
+    _processing = true;
+    try {
+      // Pump while there is capacity and queued tasks remain
+      while (true) {
+        // Filter runnable tasks
+        final queued = state.where((t) => t.status == TaskStatus.queued).toList();
+        if (queued.isEmpty) break;
+
+        // Respect parallelism and one-per-thread
+        final availableCapacity = _maxParallel - _activeThreads.length;
+        if (availableCapacity <= 0) break;
+
+        OutboundTask? next;
+        for (final t in queued) {
+          final thread = t.threadKey;
+          if (!_activeThreads.contains(thread)) {
+            next = t;
+            break;
+          }
+        }
+
+        // If no eligible task (all threads busy), exit loop
+        if (next == null) break;
+
+        // Mark running and launch without awaiting (parallel across threads)
+        final threadKey = next.threadKey;
+        _activeThreads.add(threadKey);
+        state = [
+          for (final t in state)
+            if (t.id == next.id)
+              next.copyWith(status: TaskStatus.running, startedAt: DateTime.now())
+            else
+              t,
+        ];
+        await _save();
+
+        // Launch worker
+        unawaited(_run(next).whenComplete(() {
+          _activeThreads.remove(threadKey);
+          // After a task completes, try to schedule more
+          _process();
+        }));
+      }
+    } finally {
+      _processing = false;
+    }
+  }
+
+  Future<void> _run(OutboundTask task) async {
+    try {
+      await TaskWorker(_ref).perform(task);
+      state = [
+        for (final t in state)
+          if (t.id == task.id)
+            t.copyWith(status: TaskStatus.succeeded, completedAt: DateTime.now())
+          else
+            t,
+      ];
+    } catch (e, st) {
+      debugPrint('Task failed (${task.runtimeType}): $e\n$st');
+      state = [
+        for (final t in state)
+          if (t.id == task.id)
+            t.copyWith(
+              status: TaskStatus.failed,
+              error: e.toString(),
+              completedAt: DateTime.now(),
+            )
+          else
+            t,
+      ];
+    } finally {
+      await _save();
+    }
+  }
+}