solverforge-cli 3.3.2

CLI for scaffolding and managing SolverForge constraint solver projects
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use std::sync::Arc;
use std::time::Duration;

use rmcp::model::Task;
use rmcp::model::{CallToolResult, ProgressNotificationParam, ProgressToken};
use rmcp::service::Peer;
use rmcp::task_manager::{TaskExit, TaskManager, TaskOptions};
use rmcp::{ErrorData, RoleServer};

use crate::api::dto::{lifecycle_state_label, JobSnapshotDto};
use crate::solver::SolverService;
use solverforge::{HardSoftScore, SolverStatus};

use super::dto::SolveResultDto;

/// How often the solve watcher samples the retained job status.
const STATUS_POLL_INTERVAL: Duration = Duration::from_millis(250);

/// Spawns the MCP task that watches a retained solver job until it reaches a
/// terminal lifecycle state. Progress rides the request progress token while
/// the caller is attached; detached clients observe the task through
/// `tasks/get`, whose terminal payload carries the best-solution snapshot.
/// Active tasks have no TTL because SolverForge jobs have no maximum run time;
/// task records remain available for the lifetime of this server process.
pub fn spawn_solve_task(
    tasks: &TaskManager,
    solver: Arc<SolverService>,
    peer: Peer<RoleServer>,
    progress_token: Option<ProgressToken>,
    job_id: String,
) -> Task {
    tasks.spawn(
        TaskOptions::new()
            .with_poll_interval_ms(STATUS_POLL_INTERVAL.as_millis() as u64)
            .with_ttl_ms(None)
            .with_status_message("solving"),
        move |ctx| {
            Box::pin(async move {
                loop {
                    tokio::select! {
                        _ = ctx.cancelled() => {
                            // Protocol cancellation maps onto runtime
                            // cancellation; the best solution stays retained.
                            let _ = solver.cancel(&job_id);
                            return Err(TaskExit::Cancelled);
                        }
                        _ = tokio::time::sleep(STATUS_POLL_INTERVAL) => {
                            match solver.get_status(&job_id) {
                                Err(_) => {
                                    // The job was deleted while the task was
                                    // still watching it.
                                    return Err(TaskExit::Error(ErrorData::internal_error(
                                        format!(
                                            "job {job_id} was deleted before reaching a terminal state"
                                        ),
                                        None,
                                    )));
                                }
                                Ok(status) => {
                                    if let Some(token) = &progress_token {
                                        let _ = peer
                                            .notify_progress(
                                                ProgressNotificationParam::new(
                                                    token.clone(),
                                                    status.telemetry.step_count as f64,
                                                )
                                                .with_message(format!(
                                                    "{} (revision {:?})",
                                                    lifecycle_state_label(status.lifecycle_state),
                                                    status.latest_snapshot_revision,
                                                )),
                                            )
                                            .await;
                                    }

                                    match status.lifecycle_state {
                                        solverforge::SolverLifecycleState::Solving
                                        | solverforge::SolverLifecycleState::PauseRequested => {}
                                        solverforge::SolverLifecycleState::Paused => {
                                            ctx.set_status_message("paused");
                                        }
                                        solverforge::SolverLifecycleState::Completed => {
                                            return terminal_result(
                                                &solver,
                                                &job_id,
                                                &status,
                                                status.latest_snapshot_revision,
                                            )
                                            .map_err(TaskExit::Error);
                                        }
                                        solverforge::SolverLifecycleState::Cancelled => {
                                            return Err(TaskExit::Cancelled);
                                        }
                                        solverforge::SolverLifecycleState::Failed => {
                                            return Err(TaskExit::Error(ErrorData::internal_error(
                                                format!("solver job {job_id} failed"),
                                                None,
                                            )));
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            })
        },
    )
}

fn terminal_result(
    solver: &SolverService,
    job_id: &str,
    status: &SolverStatus<HardSoftScore>,
    snapshot_revision: Option<u64>,
) -> Result<CallToolResult, ErrorData> {
    let numeric_id = job_id.parse::<usize>().map_err(|_| {
        ErrorData::internal_error(format!("retained job id '{job_id}' is not numeric"), None)
    })?;

    let mut result = SolveResultDto::from_status(numeric_id, status);
    match solver.get_snapshot(job_id, snapshot_revision) {
        Ok(snapshot) => result.snapshot = Some(JobSnapshotDto::from_snapshot(&snapshot)),
        Err(error) => {
            // Cancelled or failed jobs may legitimately have no snapshot; the
            // terminal lifecycle state itself is the result then.
            result.snapshot_error = Some(error.to_string());
        }
    }

    Ok(CallToolResult::structured(
        serde_json::to_value(result).expect("solve result serializes to JSON"),
    ))
}