reasoninglayer 0.1.2

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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195

//! Scenario DTOs.

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ClarificationQuestionDto {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub choices: Option<Vec<serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default: Option<String>,
    pub field: String,
    pub id: String,
    pub question: String,
    #[serde(rename = "type")]
    pub question_type: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CycleOutcomeSummaryDto {
    pub actions_executed: u64,
    pub goals_achieved: u64,
    pub goals_failed: u64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MaterializationSummaryDto {
    pub beliefs_created: u64,
    pub constraints_created: u64,
    pub curriculum_stages_created: u64,
    pub goal_created: bool,
    pub groundings_created: u64,
    pub guard_constraints_created: u64,
    pub rules_created: u64,
    #[serde(default)]
    pub sort_names: Vec<String>,
    pub sorts_created: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ScenarioSummaryDto {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    pub beliefs_created: u64,
    pub created_at: u64,
    pub prompt: String,
    pub rules_created: u64,
    pub scenario_id: String,
    pub sorts_created: u64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateScenarioRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub answers: Option<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub create_agent: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enable_curriculum: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enable_grounding: Option<bool>,
    pub prompt: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_initial_cycle: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
}

/// Response from scenario creation. Discriminated by `status`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "status", rename_all = "snake_case")]
pub enum CreateScenarioResponse {
    NeedsClarification {
        questions: Vec<ClarificationQuestionDto>,
        session_id: String,
        understood: serde_json::Value,
    },
    Complete {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        agent_id: Option<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        cycle_outcome: Option<CycleOutcomeSummaryDto>,
        groundings_applied: u64,
        materialization: MaterializationSummaryDto,
        scenario: serde_json::Value,
        scenario_id: String,
        total_time_ms: u64,
    },
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ListScenariosResponse {
    #[serde(default)]
    pub scenarios: Vec<ScenarioSummaryDto>,
    pub total: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GetScenarioResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    pub beliefs_created: u64,
    pub constraints_created: u64,
    pub created_at: u64,
    pub guard_constraints_created: u64,
    pub prompt: String,
    pub rules_created: u64,
    pub scenario: serde_json::Value,
    pub scenario_id: String,
    pub sorts_created: u64,
    pub temporal_constraints_created: u64,
    pub webhook_actions_created: u64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct UpdateScenarioRequest {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub add_beliefs: Vec<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub add_constraints: Vec<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub add_guard_constraints: Vec<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub add_rules: Vec<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub add_sorts: Vec<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub add_temporal_constraints: Vec<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub add_webhook_actions: Vec<serde_json::Value>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct UpdateScenarioResponse {
    pub beliefs_added: u64,
    pub constraints_added: u64,
    pub guard_constraints_added: u64,
    pub rules_added: u64,
    pub scenario_id: String,
    pub sorts_added: u64,
    pub temporal_constraints_added: u64,
    pub total_beliefs: u64,
    pub total_constraints: u64,
    pub total_guard_constraints: u64,
    pub total_rules: u64,
    pub total_sorts: u64,
    pub total_temporal_constraints: u64,
    pub total_webhook_actions: u64,
    pub webhook_actions_added: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VerificationStepDto {
    pub description: String,
    pub name: String,
    pub passed: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LayerResultSummaryDto {
    pub facts_checked: u64,
    pub facts_satisfied: u64,
    pub layer: String,
    pub score: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FormalVerdictDto {
    pub confidence: f64,
    pub deterministic_facts: u64,
    #[serde(default)]
    pub layer_results: Vec<LayerResultSummaryDto>,
    pub overall_verdict: String,
    pub semantic_facts: u64,
    pub total_llm_calls: u64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct VerifyScenarioRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Value>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct VerifyScenarioResponse {
    pub confidence: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub formal_verdict: Option<FormalVerdictDto>,
    pub scenario_id: String,
    #[serde(default)]
    pub steps: Vec<VerificationStepDto>,
    pub summary: String,
    pub verdict: String,
}