285 lines
8.8 KiB
Dart
285 lines
8.8 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter/foundation.dart';
|
|
|
|
import '../../../core/api_gateway.dart';
|
|
import '../../../core/error_reason.dart';
|
|
import '../data/chat_repository.dart';
|
|
import '../domain/chat_automations.dart';
|
|
import '../domain/chat_shells.dart';
|
|
|
|
/// One session's live background tasks and lazy, bounded output selection.
|
|
class ChatBackgroundTasksController extends ChangeNotifier {
|
|
ChatBackgroundTasksController(this.gateway, this.sessionId) {
|
|
_listen();
|
|
unawaited(refresh());
|
|
unawaited(refreshAutomations());
|
|
}
|
|
|
|
ApiGateway gateway;
|
|
String sessionId;
|
|
late ChatRepository _repository = ChatRepository(gateway);
|
|
StreamSubscription<JsonMap>? _frames;
|
|
List<JsonMap> _shells = const [];
|
|
Map<String, JsonMap>? _loadFrames;
|
|
String? selectedId;
|
|
ChatShellOutputSnapshot? output;
|
|
String? error;
|
|
bool loading = true;
|
|
bool _disposed = false;
|
|
int _generation = 0;
|
|
int _outputGeneration = 0;
|
|
Timer? _automationDebounce;
|
|
Future<void>? _automationRequest;
|
|
bool _automationRefreshPending = false;
|
|
ChatAutomationStatus _automations = const ChatAutomationStatus();
|
|
int _automationGeneration = 0;
|
|
|
|
List<JsonMap> get running => runningShells(_shells);
|
|
JsonMap? get selectedShell =>
|
|
running.where((shell) => shellIdOf(shell) == selectedId).firstOrNull;
|
|
ChatAutomationStatus get automationStatus => _automations;
|
|
|
|
void replace(
|
|
ApiGateway nextGateway,
|
|
String nextSessionId, {
|
|
bool notify = true,
|
|
}) {
|
|
if (_disposed) return;
|
|
unawaited(_frames?.cancel());
|
|
_automationRequest = null;
|
|
_automationRefreshPending = false;
|
|
gateway = nextGateway;
|
|
sessionId = nextSessionId;
|
|
_repository = ChatRepository(gateway);
|
|
_listen();
|
|
reconnect(notify: notify);
|
|
}
|
|
|
|
void reconnect({bool notify = true}) {
|
|
if (_disposed) return;
|
|
_shells = const [];
|
|
selectedId = null;
|
|
output = null;
|
|
error = null;
|
|
_outputGeneration++;
|
|
_automationGeneration++;
|
|
_automationRequest = null;
|
|
_automationRefreshPending = false;
|
|
_automationDebounce?.cancel();
|
|
_automationDebounce = null;
|
|
_automations = const ChatAutomationStatus();
|
|
unawaited(refresh(notify: notify));
|
|
unawaited(refreshAutomations(notify: notify));
|
|
}
|
|
|
|
void _listen() => _frames = gateway.frames.listen((envelope) {
|
|
if (_disposed || envelope['type'] != 'chat_event') return;
|
|
final frame = envelope['chat_event'];
|
|
_scheduleAutomationRefresh(frame);
|
|
if (frame is! Map ||
|
|
frame['session_id'] != sessionId ||
|
|
frame['kind'] != 'shell' ||
|
|
frame['shell'] is! Map) {
|
|
return;
|
|
}
|
|
_shells = mergeShellFrame(
|
|
_shells,
|
|
Map<String, dynamic>.from(frame['shell'] as Map),
|
|
);
|
|
final id = shellIdOf(Map<String, dynamic>.from(frame['shell'] as Map));
|
|
if (_loadFrames != null && !blankShellValue(id)) {
|
|
_loadFrames![id] = _shells.firstWhere((shell) => shellIdOf(shell) == id);
|
|
if (_loadFrames!.length > observedShellLimit) {
|
|
_loadFrames!.remove(_loadFrames!.keys.first);
|
|
}
|
|
}
|
|
_dropStaleSelection();
|
|
notifyListeners();
|
|
}, onError: (_) {});
|
|
|
|
void _scheduleAutomationRefresh(Object frame) {
|
|
if (frame is! Map) return;
|
|
if (frame['session_id'] != sessionId) return;
|
|
final kind = '${frame['kind'] ?? ''}'.toLowerCase();
|
|
final step = frame['step'];
|
|
final part = frame['part'];
|
|
final stepEnded =
|
|
kind == 'step' &&
|
|
step is Map &&
|
|
'${step['status'] ?? ''}'.toLowerCase() == 'ended';
|
|
final toolCompleted =
|
|
kind == 'tool' &&
|
|
part is Map &&
|
|
(part['state'] is Map) &&
|
|
{
|
|
'completed',
|
|
'error',
|
|
}.contains('${(part['state'] as Map)['status'] ?? ''}'.toLowerCase());
|
|
if (!stepEnded && !toolCompleted) {
|
|
return;
|
|
}
|
|
if (_automationRequest != null) _automationRefreshPending = true;
|
|
_automationDebounce?.cancel();
|
|
_automationDebounce = Timer(const Duration(milliseconds: 250), () {
|
|
_automationDebounce = null;
|
|
unawaited(refreshAutomations());
|
|
});
|
|
}
|
|
|
|
Future<void> refresh({bool notify = true}) async {
|
|
if (_disposed) return;
|
|
final token = ++_generation;
|
|
final observed = <String, JsonMap>{};
|
|
_loadFrames = observed;
|
|
loading = true;
|
|
if (notify) notifyListeners();
|
|
try {
|
|
final shells = await _repository.shells(sessionId);
|
|
if (_disposed || token != _generation) return;
|
|
_shells = shellsLoaded(_shells, shells);
|
|
// Live frames are newer than a snapshot requested before they arrived.
|
|
for (final frame in observed.values) {
|
|
_shells = mergeShellFrame(_shells, frame);
|
|
}
|
|
error = null;
|
|
_dropStaleSelection();
|
|
} catch (failure) {
|
|
if (_disposed || token != _generation) return;
|
|
error = describeErrorReason(
|
|
failure,
|
|
fallback: 'The server did not answer.',
|
|
);
|
|
}
|
|
loading = false;
|
|
_loadFrames = null;
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> refreshAutomations({bool notify = true}) async {
|
|
if (_disposed) return;
|
|
if (_automationRequest != null) {
|
|
_automationRefreshPending = true;
|
|
return;
|
|
}
|
|
final token = ++_automationGeneration;
|
|
final request = _readAutomations(token, notify: notify);
|
|
_automationRequest = request;
|
|
try {
|
|
await request;
|
|
} finally {
|
|
if (identical(_automationRequest, request)) {
|
|
_automationRequest = null;
|
|
if (_automationRefreshPending && !_disposed) {
|
|
_automationRefreshPending = false;
|
|
_automationDebounce?.cancel();
|
|
_automationDebounce = Timer(const Duration(milliseconds: 250), () {
|
|
_automationDebounce = null;
|
|
unawaited(refreshAutomations());
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> _readAutomations(int token, {required bool notify}) async {
|
|
final repository = _repository;
|
|
final id = sessionId;
|
|
// A legacy gateway can throw before returning a Future. Always cross an
|
|
// async boundary before notifying listeners, including didUpdateWidget.
|
|
await Future<void>.value();
|
|
if (_disposed || token != _automationGeneration) return;
|
|
final previous = _automations;
|
|
try {
|
|
final reply = await repository.automations(id);
|
|
if (_disposed || token != _automationGeneration) return;
|
|
_automations = ChatAutomationStatus.fromReply(
|
|
reply,
|
|
expectedSessionId: id,
|
|
);
|
|
} catch (_) {
|
|
// Older servers do not know this optional command. Keep shell state
|
|
// usable and present capability absence in the inspector instead.
|
|
if (_disposed || token != _automationGeneration) return;
|
|
_automations = const ChatAutomationStatus();
|
|
}
|
|
// Unsupported/unknown is intentionally quiet in the composer; supported
|
|
// reports need to reveal their positive count.
|
|
final changed =
|
|
previous.supported != _automations.supported ||
|
|
previous.count != _automations.count ||
|
|
previous.reason != _automations.reason ||
|
|
previous.observedAt != _automations.observedAt;
|
|
if (changed || (notify && _automations.supported)) {
|
|
notifyListeners();
|
|
}
|
|
}
|
|
|
|
void _dropStaleSelection() {
|
|
if (selectedId == null || selectedShell != null) return;
|
|
selectedId = null;
|
|
output = null;
|
|
_outputGeneration++;
|
|
}
|
|
|
|
void select(String id) {
|
|
if (_disposed) return;
|
|
if (selectedId == id) {
|
|
selectedId = null;
|
|
output = null;
|
|
_outputGeneration++;
|
|
notifyListeners();
|
|
return;
|
|
}
|
|
if (!running.any((shell) => shellIdOf(shell) == id)) return;
|
|
selectedId = id;
|
|
unawaited(readOutput());
|
|
}
|
|
|
|
Future<void> readOutput() async {
|
|
final id = selectedId;
|
|
if (_disposed || id == null) return;
|
|
final token = ++_outputGeneration;
|
|
output = const ChatShellOutputSnapshot(loading: true);
|
|
notifyListeners();
|
|
try {
|
|
final reply = await _repository.shellOutput(
|
|
sessionId,
|
|
id,
|
|
cursor: 0,
|
|
limit: chatShellOutputLimit,
|
|
);
|
|
if (_disposed || token != _outputGeneration || selectedId != id) return;
|
|
final page = ChatShellOutputPage.fromReply(reply);
|
|
if (page.shell case final shell? when !blankShellValue(shell['id'])) {
|
|
_shells = mergeShellFrame(_shells, shell);
|
|
}
|
|
output = ChatShellOutputSnapshot(page: page);
|
|
_dropStaleSelection();
|
|
} catch (failure) {
|
|
if (_disposed || token != _outputGeneration || selectedId != id) return;
|
|
output = ChatShellOutputSnapshot(
|
|
error: describeErrorReason(
|
|
failure,
|
|
fallback: 'The server did not answer.',
|
|
),
|
|
);
|
|
}
|
|
notifyListeners();
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_disposed = true;
|
|
_generation++;
|
|
_outputGeneration++;
|
|
_automationGeneration++;
|
|
_automationDebounce?.cancel();
|
|
_automationDebounce = null;
|
|
_automationRequest = null;
|
|
_automationRefreshPending = false;
|
|
unawaited(_frames?.cancel());
|
|
super.dispose();
|
|
}
|
|
}
|