| import { |
| CounterfactualReport, |
| CounterfactualSimulationParams, |
| FLRoundResult, |
| FLSimulationRequest, |
| PredictPayload, |
| PredictResponse, |
| SystemHealthStatus, |
| } from '../types'; |
|
|
| const BASE_URL = import.meta.env.VITE_API_BASE_URL || '/api/v1'; |
|
|
| export async function checkSystemHealth(): Promise<SystemHealthStatus> { |
| try { |
| const res = await fetch('/health'); |
| if (!res.ok) throw new Error('Health check failed'); |
| return await res.json(); |
| } catch { |
| return { |
| status: 'offline', |
| service: 'cfi-backend', |
| environment: 'development', |
| redis_connected: false, |
| version: '2.4.0', |
| }; |
| } |
| } |
|
|
| export async function predictTransaction(payload: PredictPayload): Promise<PredictResponse> { |
| const res = await fetch(`${BASE_URL}/predict`, { |
| method: 'POST', |
| headers: { 'Content-Type': 'application/json' }, |
| body: JSON.stringify(payload), |
| }); |
| if (!res.ok) { |
| throw new Error(`Prediction API error: ${res.statusText}`); |
| } |
| return res.json(); |
| } |
|
|
| export async function fetchCounterfactual( |
| alertIdOrParams: string | CounterfactualSimulationParams = 'alt_1001', |
| targetScore: number = 350.0 |
| ): Promise<CounterfactualReport> { |
| const query = new URLSearchParams(); |
|
|
| if (typeof alertIdOrParams === 'object') { |
| query.set('alert_id', alertIdOrParams.alert_id || 'alt_1001'); |
| query.set('target_score', String(alertIdOrParams.target_score ?? targetScore)); |
| if (alertIdOrParams.amount !== undefined) query.set('amount', String(alertIdOrParams.amount)); |
| if (alertIdOrParams.velocity !== undefined) query.set('velocity', String(alertIdOrParams.velocity)); |
| if (alertIdOrParams.merchant_risk !== undefined) query.set('merchant_risk', String(alertIdOrParams.merchant_risk)); |
| } else { |
| query.set('alert_id', alertIdOrParams || 'alt_1001'); |
| query.set('target_score', String(targetScore)); |
| } |
|
|
| const res = await fetch(`${BASE_URL}/explainability/counterfactuals?${query.toString()}`); |
| if (!res.ok) { |
| throw new Error(`Counterfactual API error (${res.status}): ${res.statusText}`); |
| } |
|
|
| const data = await res.json(); |
| return { |
| alert_id: data.alert_id, |
| original_score: data.original_score, |
| remediated_score: data.remediated_score, |
| is_cleared: data.is_cleared, |
| changes: (data.changes || []).map((c: any) => ({ |
| feature: c.feature, |
| original_value: c.original_value, |
| suggested_value: c.suggested_value ?? c.remediated_value, |
| delta: c.delta ?? 0, |
| description: c.description ?? c.delta_explanation ?? '', |
| })), |
| summary_text: data.summary_text, |
| }; |
| } |
|
|
| export async function runFLSimulation( |
| simReq: FLSimulationRequest |
| ): Promise<FLRoundResult[]> { |
| const methodMap: Record<string, string> = { |
| FED_AVG: 'fed_avg', |
| FED_ADAM: 'fed_avg_weighted', |
| KRUM: 'krum', |
| BULYAN: 'bulyan', |
| SCAFFOLD: 'fed_avg', |
| FED_ASYNC: 'fed_avg', |
| }; |
| const aggregation_method = methodMap[simReq.algorithm] || simReq.algorithm || 'fed_avg_weighted'; |
|
|
| const res = await fetch(`${BASE_URL}/simulations`, { |
| method: 'POST', |
| headers: { 'Content-Type': 'application/json' }, |
| body: JSON.stringify({ |
| num_rounds: simReq.num_rounds, |
| local_epochs: simReq.local_epochs || 2, |
| learning_rate: simReq.learning_rate || 0.01, |
| privacy_mechanism: simReq.dp_epsilon ? 'differential_privacy' : 'none', |
| dp_epsilon: simReq.dp_epsilon || 1.0, |
| dp_delta: simReq.dp_delta || 1e-5, |
| aggregation_method, |
| }), |
| }); |
|
|
| if (!res.ok) { |
| throw new Error(`Federated learning simulation request failed: ${res.status} ${res.statusText}`); |
| } |
|
|
| const data = await res.json(); |
| if (Array.isArray(data.rounds)) { |
| return data.rounds; |
| } |
|
|
| const simulationId = data.id; |
| if (!simulationId) { |
| return []; |
| } |
|
|
| |
| const maxAttempts = 30; |
| for (let attempt = 0; attempt < maxAttempts; attempt++) { |
| await new Promise((resolve) => setTimeout(resolve, 800)); |
| const statusRes = await fetch(`${BASE_URL}/simulations/${simulationId}`); |
| if (statusRes.ok) { |
| const statusData = await statusRes.json(); |
| if (Array.isArray(statusData.rounds) && statusData.rounds.length > 0) { |
| if (statusData.status === 'completed' || statusData.rounds.length >= simReq.num_rounds) { |
| return statusData.rounds.map((r: any) => ({ |
| round_number: r.round_number, |
| global_loss: r.global_loss, |
| per_bank_loss: r.per_bank_loss || { |
| bank_a: r.global_loss, |
| bank_b: r.global_loss, |
| bank_c: r.global_loss, |
| }, |
| participating_bank_ids: r.participating_banks || ['bank_a', 'bank_b', 'bank_c'], |
| dropped_bank_ids: r.dropped_banks || [], |
| aggregation_time_ms: r.duration_ms || 25, |
| })); |
| } |
| } |
| if (statusData.status === 'failed') { |
| throw new Error(statusData.error_message || 'Federated learning simulation execution failed'); |
| } |
| } |
| } |
|
|
| throw new Error('Simulation timed out waiting for round completion'); |
| } |
|
|
|
|
