rightkit_memory_client/backend/
unavailable.rs1use crate::backend::contract::{CallContext, MemoryBackend};
7use crate::backend::error::MemoryBackendError;
8use crate::backend::types::{
9 BackendBinding, BackendIdentity, FullMemoryRecord, JsonValue, MemoryEntry, MemoryId,
10 MemoryListRow, MemoryTier, Score,
11};
12use async_trait::async_trait;
13
14pub struct UnavailableMemoryBackend {
15 binding: BackendBinding,
16 error: MemoryBackendError,
17}
18
19impl UnavailableMemoryBackend {
20 pub fn new(code: impl Into<String>, message: impl Into<String>) -> Self {
21 Self {
22 binding: BackendBinding::new(BackendIdentity::service(
23 "membrane-unavailable",
24 1,
25 1,
26 None,
27 )),
28 error: MemoryBackendError::BackendUnavailable {
29 code: code.into(),
30 message: message.into(),
31 },
32 }
33 }
34
35 fn failure(&self) -> MemoryBackendError {
36 self.error.clone()
37 }
38}
39
40#[async_trait]
41impl MemoryBackend for UnavailableMemoryBackend {
42 fn binding(&self) -> &BackendBinding {
43 &self.binding
44 }
45
46 async fn activity_json(
47 &self,
48 _: &CallContext,
49 _: usize,
50 ) -> Result<JsonValue, MemoryBackendError> {
51 Err(self.failure())
52 }
53 async fn delete(&self, _: &CallContext, _: &str) -> Result<bool, MemoryBackendError> {
54 Err(self.failure())
55 }
56 async fn embedder_dim(&self, _: &CallContext) -> Result<usize, MemoryBackendError> {
57 Err(self.failure())
58 }
59 async fn entries(
60 &self,
61 _: &CallContext,
62 _: usize,
63 ) -> Result<Vec<MemoryEntry>, MemoryBackendError> {
64 Err(self.failure())
65 }
66 async fn get_full(
67 &self,
68 _: &CallContext,
69 _: &str,
70 ) -> Result<FullMemoryRecord, MemoryBackendError> {
71 Err(self.failure())
72 }
73
74 #[allow(clippy::too_many_arguments)]
75 async fn log_recall_with_replay(
76 &self,
77 _: &CallContext,
78 _: &str,
79 _: Option<&str>,
80 _: usize,
81 _: usize,
82 _: usize,
83 _: usize,
84 _: &str,
85 _: Option<&str>,
86 _: Option<&str>,
87 _: Option<&str>,
88 _: Option<&str>,
89 _: Option<&str>,
90 _: Option<&str>,
91 _: Option<&str>,
92 _: &str,
93 _: &str,
94 _: &str,
95 ) -> Result<(), MemoryBackendError> {
96 Err(self.failure())
97 }
98
99 async fn metrics_json(&self, _: &CallContext) -> Result<JsonValue, MemoryBackendError> {
100 Err(self.failure())
101 }
102 async fn put(
103 &self,
104 _: &CallContext,
105 _: &str,
106 _: &str,
107 _: &str,
108 _: MemoryTier,
109 ) -> Result<MemoryId, MemoryBackendError> {
110 Err(self.failure())
111 }
112 async fn recall_scored(
113 &self,
114 _: &CallContext,
115 _: &str,
116 _: usize,
117 _: &[String],
118 ) -> Result<Vec<(MemoryEntry, Score)>, MemoryBackendError> {
119 Err(self.failure())
120 }
121 async fn record_injections(
122 &self,
123 _: &CallContext,
124 _: &[String],
125 ) -> Result<(), MemoryBackendError> {
126 Err(self.failure())
127 }
128 async fn remember(
129 &self,
130 _: &CallContext,
131 _: &str,
132 _: Vec<String>,
133 ) -> Result<MemoryEntry, MemoryBackendError> {
134 Err(self.failure())
135 }
136 async fn scopes(&self, _: &CallContext) -> Result<Vec<String>, MemoryBackendError> {
137 Err(self.failure())
138 }
139 async fn search(
140 &self,
141 _: &CallContext,
142 _: &str,
143 _: usize,
144 ) -> Result<Vec<MemoryEntry>, MemoryBackendError> {
145 Err(self.failure())
146 }
147 async fn try_put(
148 &self,
149 _: &CallContext,
150 _: &str,
151 _: &str,
152 _: &str,
153 _: MemoryTier,
154 ) -> Result<MemoryId, MemoryBackendError> {
155 Err(self.failure())
156 }
157 async fn list(
158 &self,
159 _: &CallContext,
160 _: Option<&str>,
161 ) -> Result<Vec<MemoryListRow>, MemoryBackendError> {
162 Err(self.failure())
163 }
164 async fn remember_consolidated(
165 &self,
166 _: &CallContext,
167 _: &str,
168 _: &str,
169 _: Vec<String>,
170 _: Score,
171 ) -> Result<Option<MemoryEntry>, MemoryBackendError> {
172 Err(self.failure())
173 }
174}