reasoninglayer 1.0.3

Rust client SDK for the Reasoning Layer API
Documentation 
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
135
136
137
138
139
140

//! Computation space DTOs.

use std::collections::BTreeMap;

use serde::{Deserialize, Serialize};

/// Space constraint — free-form because the backend enumerates many variants.
/// See the OpenAPI schema for the full list.
pub type SpaceConstraintDto = serde_json::Value;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum SpaceStatusDto {
    Running,
    Failed,
    Succeeded,
    Alternatives { count: u32 },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum SearchStrategyDto {
    DepthFirst,
    BreadthFirst,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChoicePointDto {
    pub description: String,
    pub alternative_count: u32,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variable_name: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChoiceSelection {
    pub description: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub selected_index: Option<i32>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchStatsDto {
    pub nodes_explored: u64,
    pub nodes_pruned: u64,
    pub backtracks: u64,
    pub solve_time_ms: u64,
    pub scorer_calls: u64,
    pub restarts: u64,
    pub learned_clauses: u64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub forced_choices: Option<Vec<ChoiceSelection>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TraceEventDto {
    pub assignment: String,
    pub event_type: String,
    pub id: u64,
    pub value_label: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variable: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpaceSolutionDto {
    pub space_id: String,
    pub status: SpaceStatusDto,
    #[serde(default)]
    pub choices: Vec<ChoiceSelection>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub events: Option<Vec<TraceEventDto>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreateSpaceRequest {
    pub choice_points: Vec<ChoicePointDto>,
    pub constraints: Vec<SpaceConstraintDto>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpaceResponse {
    pub id: String,
    pub status: SpaceStatusDto,
    pub constraint_count: u32,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub selected_alternative: Option<i32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommitRequest {
    pub alternative_index: u32,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SearchModeDto {
    Solutions,
    Feasibility,
    Scheduling,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VariableFeasibilityDto {
    pub can_be_true: bool,
    pub can_be_false: bool,
    pub verified: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpaceSearchRequest {
    pub strategy: SearchStrategyDto,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_solutions: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub collect_traces: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub use_neural_guidance: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<SearchModeDto>,
}

/// Response from space search — discriminated by `kind`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum SpaceSearchResponse {
    Solutions {
        solutions: Vec<SpaceSolutionDto>,
        count: u64,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        search_stats: Option<SearchStatsDto>,
    },
    Feasibility {
        variables: BTreeMap<String, VariableFeasibilityDto>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        search_stats: Option<SearchStatsDto>,
    },
}