Skip to main content

rightkit_memory_client/backend/
unavailable.rs

1//! Explicit no-memory backend used when Hub is inactive or incompatible.
2//!
3//! This is a typed refusal surface, never a local fallback.  It keeps the host app
4//! alive for non-memory routes while every memory operation remains fail-closed.
5
6use 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}