Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

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.rs
index 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.rs
index 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.rs
index 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 &current {
+ 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.rs
index 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