143 lines
4.7 KiB
Dart
143 lines
4.7 KiB
Dart
import '../../../core/api_gateway.dart';
|
|
import '../domain/run_models.dart';
|
|
|
|
/// Protocol failure kept separate from transport errors; server error envelopes
|
|
/// are otherwise propagated unchanged by [ApiGateway].
|
|
class RunsRepositoryException implements Exception {
|
|
const RunsRepositoryException(this.message);
|
|
final String message;
|
|
@override
|
|
String toString() => message;
|
|
}
|
|
|
|
/// Run protocol requests over the application's shared gateway.
|
|
class RunsRepository {
|
|
RunsRepository(this._gateway);
|
|
final ApiGateway _gateway;
|
|
|
|
/// Composition/actions reuse this feature's existing gateway, never a socket.
|
|
ApiGateway get gateway => _gateway;
|
|
|
|
Future<RunListResult> listRuns() async {
|
|
final reply = await _gateway.call('list_runs');
|
|
final runs = reply['runs'];
|
|
return RunListResult(
|
|
runs is List
|
|
? runs
|
|
.whereType<Map>()
|
|
.map((r) => Map<String, dynamic>.from(r))
|
|
.toList()
|
|
: const [],
|
|
reply['usage'] is Map
|
|
? Map<String, dynamic>.from(reply['usage'] as Map)
|
|
: null,
|
|
);
|
|
}
|
|
|
|
Future<JsonMap> getRun(num id) async =>
|
|
_required(await _gateway.call('get_run', {'run_id': id}), 'run_detail');
|
|
Future<JsonMap> cancelRun(num id) async => _required(
|
|
await _gateway.call('cancel_run', {'run_id': id}),
|
|
'run_detail',
|
|
);
|
|
|
|
/// Reads the exact recorded visit again; it never reruns its stage or tools.
|
|
///
|
|
/// The body is the web client's `repair_session_export` request: the run and
|
|
/// the recorded export sequence only. The reply is the whole run detail, so
|
|
/// the caller can show exactly what the server recorded next.
|
|
Future<JsonMap> repairSessionExport(num id, int sequence) async {
|
|
if (id is! int || id < 1 || sequence < 1) {
|
|
throw const RunsRepositoryException(
|
|
'An exact run and visit are required.',
|
|
);
|
|
}
|
|
return _required(
|
|
await _gateway.call('repair_session_export', {
|
|
'run_id': id,
|
|
'export_sequence': sequence,
|
|
}),
|
|
'run_detail',
|
|
);
|
|
}
|
|
|
|
Future<JsonMap> retryRun(
|
|
num id, {
|
|
required String requestKey,
|
|
String? mode,
|
|
}) async {
|
|
final fields = <String, dynamic>{'run_id': id, 'request_key': requestKey};
|
|
if (mode == 'restart') fields['retry_mode'] = mode;
|
|
return _required(await _gateway.call('retry_run', fields), 'run_detail');
|
|
}
|
|
|
|
Future<JsonMap> decideRun(
|
|
num id, {
|
|
String? stage,
|
|
required String option,
|
|
String feedback = '',
|
|
}) async {
|
|
final selected = option.trim();
|
|
if (selected.isEmpty) {
|
|
throw const RunsRepositoryException(
|
|
'Choose an option before continuing.',
|
|
);
|
|
}
|
|
final fields = <String, dynamic>{'run_id': id, 'option': selected};
|
|
if (stage != null && stage.trim().isNotEmpty) fields['stage'] = stage;
|
|
if (feedback.trim().isNotEmpty) fields['feedback'] = feedback.trim();
|
|
return _required(await _gateway.call('decide_run', fields), 'run_detail');
|
|
}
|
|
|
|
Future<JsonMap> setRunTitle(num id, String title) async => _required(
|
|
await _gateway.call('set_run_title', {'run_id': id, 'title': title}),
|
|
'run_detail',
|
|
);
|
|
|
|
/// Reads a run by the idempotency key of a launch whose reply was lost.
|
|
///
|
|
/// This is a read, not a launch: a server that never admitted the key answers
|
|
/// without a run detail, which is reported as null rather than invented.
|
|
Future<JsonMap?> runByRequestKey(String requestKey) async {
|
|
final key = requestKey.trim();
|
|
if (key.isEmpty) {
|
|
throw const RunsRepositoryException('A launch request key is required.');
|
|
}
|
|
final reply = await _gateway.call('get_run', {'request_key': key});
|
|
final detail = reply['run_detail'];
|
|
return detail is Map ? Map<String, dynamic>.from(detail) : null;
|
|
}
|
|
|
|
Future<JsonMap> startRun({
|
|
required num pipelineId,
|
|
required num version,
|
|
required String prompt,
|
|
required String workspace,
|
|
required String requestKey,
|
|
String title = '',
|
|
String outputFormat = '',
|
|
String? notifyMode,
|
|
}) async {
|
|
final fields = <String, dynamic>{
|
|
'pipeline_id': pipelineId,
|
|
'version': version,
|
|
'request_key': requestKey,
|
|
'workspace': workspace.trim(),
|
|
'input': {'prompt': prompt},
|
|
};
|
|
if (title.trim().isNotEmpty) fields['title'] = title.trim();
|
|
if (outputFormat.isNotEmpty) fields['output_format'] = outputFormat;
|
|
final mode = (notifyMode ?? '').trim().toLowerCase();
|
|
if (mode == 'on' || mode == 'off') fields['notify_mode'] = mode;
|
|
return _required(await _gateway.call('run_pipeline', fields), 'run_detail');
|
|
}
|
|
|
|
JsonMap _required(JsonMap reply, String key) {
|
|
final value = reply[key];
|
|
if (value is! Map) {
|
|
throw RunsRepositoryException('The server returned no $key.');
|
|
}
|
|
return Map<String, dynamic>.from(value);
|
|
}
|
|
}
|