The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.
Rust agent-orchestrationai-agentsai-assistantdesktopllmlocal-firstmcppersonal-aiprivacyrustsecond-braintauri
fix(memory): queue deletions without re-entering the storage bridge
Steven Enamakel6f2ddb46c5ff
diff --git a/crates/openhuman-core/src/memory/deletion.rs b/crates/openhuman-core/src/memory/deletion.rsindex 78f03c7657..3758ec81b7 100644--- a/crates/openhuman-core/src/memory/deletion.rs+++ b/crates/openhuman-core/src/memory/deletion.rs@@ -59,10 +59,8 @@ impl ListStore<PendingDeletion> for FileStore {.map_err(|error| StoreError(error.to_string()));}let all = all.to_vec();- super::state_store::save_workspace(&self.workspace_dir, STATE, &all).map_err(|error| {- eprintln!("deletion queue save error: {error:#}");- StoreError(error.to_string())- })+ super::state_store::save_workspace(&self.workspace_dir, STATE, &all)+ .map_err(|error| StoreError(error.to_string()))}}@@ -102,6 +100,33 @@ pub fn pending(workspace_dir: &Path) -> Vec<PendingDeletion> {queue(workspace_dir).pending()}+/// Opens the workspace queue before entering a storage callback, where+/// synchronous storage calls would re-enter the storage bridge.+pub(crate) fn open_state(+ workspace_dir: &Path,+) -> anyhow::Result<crate::storage::state_kv::StateKv> {+ super::state_store::open_workspace_quarantining::<Vec<PendingDeletion>>(workspace_dir, STATE)+}++/// Queues one deletion from an async storage callback without re-entering the+/// synchronous storage bridge.+pub(crate) async fn enqueue_with_state(+ state: &crate::storage::state_kv::StateKv,+ deletion: PendingDeletion,+) -> anyhow::Result<()> {+ state+ .update_async(STATE, move |all: &mut Vec<PendingDeletion>| {+ if all.contains(&deletion) {+ ((), false)+ } else {+ all.push(deletion.clone());+ ((), true)+ }+ })+ .await?;+ Ok(())+}+/// Runs queued deletions against the engine.struct Executor<'a> {config: &'a Config,diff --git a/crates/openhuman-core/src/memory/state_store.rs b/crates/openhuman-core/src/memory/state_store.rsindex 830bd9be2e..d095f77457 100644--- a/crates/openhuman-core/src/memory/state_store.rs+++ b/crates/openhuman-core/src/memory/state_store.rs@@ -102,7 +102,7 @@ fn workspace_scope(workspace_dir: &Path) -> Result<crate::storage::Scope> {)?)}-fn open_workspace_quarantining<T: DeserializeOwned>(+pub(crate) fn open_workspace_quarantining<T: DeserializeOwned>(workspace_dir: &Path,name: &str,) -> Result<StateKv> {diff --git a/crates/openhuman-core/src/storage/state_kv.rs b/crates/openhuman-core/src/storage/state_kv.rsindex 18845ea67b..dd0c94297d 100644--- a/crates/openhuman-core/src/storage/state_kv.rs+++ b/crates/openhuman-core/src/storage/state_kv.rs@@ -277,6 +277,48 @@ impl StateKv {})}+ /// Async read-modify-write variant for callbacks already running on the+ /// storage executor. It avoids re-entering the synchronous storage bridge.+ pub async fn update_async<T, R>(+ &self,+ name: &str,+ change: impl Fn(&mut T) -> (R, bool) + Send + Sync,+ ) -> Result<R>+ where+ T: DeserializeOwned + Serialize + Default,+ {+ let storage = self.repo.scoped().clone();+ for _ in 0..32 {+ let current = storage.kv().get(&self.id(name)?).await?;+ let mut value: T = match ¤t {+ Some(record) => {+ let entry = self.decode_entry(&record.id, record.doc.clone())?;+ serde_json::from_value(entry.value)+ .map_err(|error| StorageError::invalid_input(error.to_string()))?+ }+ None => T::default(),+ };+ let (outcome, changed) = change(&mut value);+ if !changed {+ return Ok(outcome);+ }+ let body = self.entry(+ name,+ serde_json::to_value(&value)+ .map_err(|error| StorageError::serialization(error.to_string()))?,+ )?;+ let expected = current+ .as_ref()+ .map_or(Precondition::Absent, |record| record.unchanged());+ match storage.kv().cas(&self.id(name)?, body, expected).await {+ Ok(_) => return Ok(outcome),+ Err(error) if error.kind() == ErrorKind::Conflict => continue,+ Err(error) => return Err(error.into()),+ }+ }+ Err(StorageError::conflict("state update exceeded its retry budget").into())+ }+fn entry(&self, key: &str, value: Value) -> Result<Value, StorageError> {serde_json::to_value(KvEntry {owner: self.owner.to_owned(),diff --git a/crates/openhuman-core/src/threads/store/backend.rs b/crates/openhuman-core/src/threads/store/backend.rsindex 3233751c79..00472895f3 100644--- a/crates/openhuman-core/src/threads/store/backend.rs+++ b/crates/openhuman-core/src/threads/store/backend.rs@@ -362,26 +362,24 @@ impl ConversationStore {/// this workspace's existing best-effort queue as each header is removed./// Queue persistence keeps its existing IO and process-crash limitations.pub fn purge_threads(&self) -> Result<ConversationPurgeStats, String> {- let ctx = self.ctx.clone();let workspace_dir = self.workspace_dir.clone();+ let deletion_state = crate::memory::deletion::open_state(&workspace_dir)+ .map_err(|error| format!("{LOG_PREFIX} open deletion queue: {error:#}"))?;let stats = self.run("purge_threads", NONE, |s| async move {- let callback_ctx = ctx.clone();- let callback_workspace = workspace_dir.clone();+ let callback_state = deletion_state;s.purge_threads_with_async(move |thread_id| {- let ctx = callback_ctx.clone();- let workspace_dir = callback_workspace.clone();+ let state = callback_state.clone();async move {- // The TinyAgents callback runs inside the storage bridge.- // Persist off-bridge and await each header's queue write- // before the purge deletes the next one.- ctx.spawn_blocking(move || {- crate::memory::deletion::enqueue(- &workspace_dir,- crate::memory::deletion::PendingDeletion::Thread { thread_id },- );- })+ if let Err(error) = crate::memory::deletion::enqueue_with_state(+ &state,+ crate::memory::deletion::PendingDeletion::Thread { thread_id },+ ).await- .expect("conversation purge deletion callback worker must complete");+ {+ log::warn!(+ "[threads] queue conversation memory deletion failed: {error:#}"+ );+ }}}).await