prismer-sdk 1.7.2

Prismer Cloud SDK — Context API, Parse API, IM, Evolution Engine
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

use serde::{Deserialize, Serialize};

/// Standard API response wrapper.
#[derive(Debug, Deserialize)]
pub struct ApiResponse<T> {
    pub success: Option<bool>,
    pub ok: Option<bool>,
    pub data: Option<T>,
    pub error: Option<ApiError>,
}

impl<T> ApiResponse<T> {
    pub fn is_ok(&self) -> bool {
        self.success.unwrap_or(false) || self.ok.unwrap_or(false)
    }
}

#[derive(Debug, Deserialize)]
pub struct ApiError {
    pub code: Option<String>,
    pub message: Option<String>,
}

/// SDK error types.
#[derive(Debug)]
pub enum PrismerError {
    Network(String),
    Api { status: u16, message: String },
    Parse(String),
}

impl std::fmt::Display for PrismerError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            PrismerError::Network(e) => write!(f, "Network error: {}", e),
            PrismerError::Api { status, message } => write!(f, "API error {}: {}", status, message),
            PrismerError::Parse(e) => write!(f, "Parse error: {}", e),
        }
    }
}

impl std::error::Error for PrismerError {}

/// Context Load result.
#[derive(Debug, Deserialize)]
pub struct ContextLoadResult {
    pub results: Option<Vec<ContextItem>>,
    #[serde(rename = "processingTime")]
    pub processing_time: Option<u64>,
}

#[derive(Debug, Deserialize)]
pub struct ContextItem {
    pub title: Option<String>,
    pub url: Option<String>,
    pub content: Option<String>,
    pub score: Option<f64>,
}

/// Parse result.
#[derive(Debug, Deserialize)]
pub struct ParseResult {
    #[serde(rename = "taskId")]
    pub task_id: Option<String>,
    pub status: Option<String>,
    pub document: Option<serde_json::Value>,
}

/// IM types.
#[derive(Debug, Serialize, Deserialize)]
pub struct SignalTag {
    #[serde(rename = "type")]
    pub signal_type: String,
    pub provider: Option<String>,
    pub stage: Option<String>,
    pub severity: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct Gene {
    pub id: String,
    pub category: Option<String>,
    pub title: Option<String>,
    pub signals_match: Option<Vec<serde_json::Value>>,
    pub strategy: Option<Vec<String>>,
    pub visibility: Option<String>,
    pub success_count: Option<i64>,
    pub failure_count: Option<i64>,
}

#[derive(Debug, Deserialize)]
pub struct EvolutionAdvice {
    pub action: String,
    pub gene: Option<Gene>,
    pub confidence: Option<f64>,
    pub signals: Option<Vec<serde_json::Value>>,
}

#[derive(Debug, Deserialize)]
pub struct EvolutionMetrics {
    pub standard: Option<serde_json::Value>,
    pub hypergraph: Option<serde_json::Value>,
    pub verdict: Option<String>,
}

// ============================================================================
// Realtime Event Payloads
// ============================================================================

/// Payload for a new message event.
#[derive(Debug, Serialize, Deserialize)]
pub struct MessageNewPayload {
    pub id: String,
    #[serde(rename = "conversationId")]
    pub conversation_id: String,
    pub content: String,
    #[serde(rename = "type")]
    pub msg_type: String,
    #[serde(rename = "senderId")]
    pub sender_id: String,
    pub routing: Option<serde_json::Value>,
    pub metadata: Option<serde_json::Value>,
    #[serde(rename = "createdAt")]
    pub created_at: String,
}

/// Payload for a message edit event.
#[derive(Debug, Serialize, Deserialize)]
pub struct MessageEditPayload {
    pub id: String,
    #[serde(rename = "conversationId")]
    pub conversation_id: String,
    pub content: String,
    #[serde(rename = "type")]
    pub msg_type: String,
    #[serde(rename = "editedAt")]
    pub edited_at: String,
    #[serde(rename = "editedBy")]
    pub edited_by: String,
    pub metadata: Option<serde_json::Value>,
}

/// Payload for a message deleted event.
#[derive(Debug, Serialize, Deserialize)]
pub struct MessageDeletedPayload {
    pub id: String,
    #[serde(rename = "conversationId")]
    pub conversation_id: String,
}