reasoninglayer 0.2.1

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

//! Formal-judge oversight DTOs.

use std::collections::BTreeMap;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TrajectoryStepDto {
    pub action: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_used: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output: Option<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub success: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    /// ISO-8601 timestamp.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_content: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct JudgeConfigDto {
    /// Required minimum safety score in `[0, 1]`. Default 0.8.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub min_safety_score: Option<f64>,
    /// `"min"`, `"product"`, or `"lukasiewicz"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tnorm_strategy: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ViolationDto {
    pub layer: String,
    pub category: String,
    pub message: String,
    pub severity: f64,
    #[serde(default)]
    pub context: BTreeMap<String, serde_json::Value>,
}

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct LayerResultDto {
    pub layer_name: String,
    #[serde(default)]
    pub violations: Vec<ViolationDto>,
    #[serde(default)]
    pub fix_suggestions: Vec<FixSuggestionDto>,
}

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AttestationDto {
    pub kind: String,
    pub statement: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CertificateDto {
    pub proof_trace: ProofTraceDto,
    #[serde(default)]
    pub attestations: Vec<AttestationDto>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FormalJudgeRequest {
    pub user_intent: String,
    pub trajectory: Vec<TrajectoryStepDto>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub final_output: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execution_log: Option<String>,
    #[serde(default)]
    pub risk_categories: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<JudgeConfigDto>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct FormalJudgeResponse {
    pub verdict: bool,
    pub safety_score: f64,
    #[serde(default)]
    pub layers: Vec<LayerResultDto>,
    pub certificate: CertificateDto,
    pub elapsed_ms: u64,
}

/// Iterative-refinement response (paper §4.5). Wire shape follows backend's
/// `FormalJudgeRefinementResponse` — kept intentionally permissive since the structure
/// continues to evolve.
pub type FormalJudgeRefinementResponse = serde_json::Value;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreateOversightSessionRequest {
    pub tenant_id: String,
    pub user_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<JudgeConfigDto>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateOversightSessionResponse {
    pub session_id: String,
    /// ISO-8601 timestamp.
    pub created_at: String,
    pub message: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IngestStepRequest {
    pub session_id: String,
    pub step: TrajectoryStepDto,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct StepVerificationResponse {
    pub step_verified: bool,
    pub safety_score: f64,
    #[serde(default)]
    pub violations: Vec<ViolationDto>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct OversightSessionStatusResponse {
    pub session_id: String,
    pub status: String,
    pub created_at: String,
    pub updated_at: String,
    pub steps_ingested: u64,
    pub overall_safety_score: f64,
    #[serde(default)]
    pub violations: Vec<ViolationDto>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct FinalizeOversightSessionRequest {
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub summary: Option<String>,
}

/// Final verdict payload — backend returns a free-form JSON object summarising the run.
pub type FinalizeOversightSessionResponse = serde_json::Value;