Files
pipelines/app/lib/features/runs/data/runs_repository.dart
T

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);
}
}