Skip to content

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

Merge remote-tracking branch 'fork/epic/8088-tinyagents-slim' into epic-8088-216-thread-purge

Steven Enamakel7b6d16cd2414
diff --cc crates/openhuman-core/src/agent/orchestration/background_delivery.rs
index 34e4dc7af5,e9cd18a2c2..67672eea12
--- a/crates/openhuman-core/src/agent/orchestration/background_delivery.rs
+++ b/crates/openhuman-core/src/agent/orchestration/background_delivery.rs
@@@ -250,11 -244,11 +250,11 @@@ wher
let router = background_completions::router_for_workspace_ctx(&busy_ctx, &workspace_dir);
let delivery = CompletionDelivery::new(
CompletionDeliveryConfig {
- debounce: DEBOUNCE,
+ debounce: initial_delay,
recovery_delay: RECOVERY_DELAY,
retry_backoff: Duration::from_secs(2),
- busy_poll: RECOVERY_BUSY_POLL,
- max_busy_polls: super::delivery_drain::RECOVERY_BUSY_POLLS,
+ busy_poll: CompletionDeliveryConfig::default().busy_poll,
+ max_busy_polls: CompletionDeliveryConfig::default().max_busy_polls,
batch_size: usize::MAX,
},
delivery_leases().clone(),
diff --cc crates/openhuman-core/src/agent/orchestration/background_delivery_tests.rs
index 89213c7736,1494929551..8ecd30282e
--- a/crates/openhuman-core/src/agent/orchestration/background_delivery_tests.rs
+++ b/crates/openhuman-core/src/agent/orchestration/background_delivery_tests.rs
@@@ -1,105 -1,109 +1,208 @@@
use super::*;
- use crate::agent::orchestration::delivery_drain::DrainFence;
- use std::sync::Arc;
- use std::time::Duration;
- use tinyagents_tasks::{
- CompletionRecord, CompletionResult, CompletionStatus, InMemoryCompletionStore,
+ use crate::agent::orchestration::background_completions::{
+ forget_workspace_for_test, pending_for, record_completion, router_for_workspace, TestWorkspace,
};
+ use std::path::Path;
+ use std::sync::{Arc, Mutex};
+ use tokio::sync::MutexGuard;
- fn delivery_target(router: &tinyagents_tasks::CompletionRouter) -> DeliveryTarget<'_> {
- DeliveryTarget {
- router,
- parent_key: "parent-thread",
- tenant_key: "profile",
- thread_key: "profile:parent-thread",
- }
+ async fn test_guard() -> MutexGuard<'static, ()> {
+ crate::config::TEST_ENV_LOCK.lock().await
}
- fn immediate_delivery() -> CompletionDelivery {
- CompletionDelivery::new(
- CompletionDeliveryConfig {
- debounce: Duration::ZERO,
- recovery_delay: Duration::ZERO,
- retry_backoff: Duration::ZERO,
- busy_poll: Duration::ZERO,
- max_busy_polls: 0,
- batch_size: 32,
+ async fn record(ws: &Path, session: &str, task: &str, summary: &str, thread: &str) {
+ record_completion(
+ &DispatchCtx::ambient(),
+ ws,
+ session,
+ task,
+ "researcher",
+ summary,
+ Some(thread.to_owned()),
+ )
+ .await;
+ }
+
+ #[tokio::test]
+ async fn try_deliver_applies_the_requested_turn_end_delay() {
+ let _guard = test_guard().await;
+ let workspace = TestWorkspace::new();
+ let workspace_dir = workspace.path().to_path_buf();
+ let thread_id = "thread-turn-end-delay";
+ record(
+ &workspace_dir,
+ "session-turn-end-delay",
+ "sub-delay",
+ "done",
+ thread_id,
+ )
+ .await;
+ let ctx = DispatchCtx::ambient();
+ let requested_delay = Duration::from_millis(300);
+ let started = std::time::Instant::now();
+ let delivered_after = Arc::new(Mutex::new(None));
+ let observed = Arc::clone(&delivered_after);
+
+ try_deliver(
+ ctx.clone(),
+ thread_id.to_owned(),
+ DrainFence::current(&ctx),
+ false,
+ requested_delay,
+ move |_ctx, _workspace, _thread, _notice| {
+ let observed = Arc::clone(&observed);
+ async move {
+ *observed.lock().expect("delivery timestamp") = Some(started.elapsed());
+ Ok(())
+ }
},
- ThreadDeliveryLeases::default(),
)
+ .await;
+
+ let delivered_after = delivered_after
+ .lock()
+ .expect("delivery timestamp")
+ .expect("try_deliver should invoke the turn callback");
+ assert!(delivered_after >= requested_delay);
+ assert!(
+ delivered_after < Duration::from_secs(2),
+ "requested {requested_delay:?} delay was replaced by the 3s debounce: {delivered_after:?}"
+ );
+ assert!(pending_for(&workspace_dir, thread_id).is_empty());
+ }
+
+ #[tokio::test]
+ async fn an_unexpired_completion_claim_stays_leased_after_router_reopen() {
+ let _guard = test_guard().await;
+ let workspace = TestWorkspace::new();
+ let workspace_dir = workspace.path();
+ record(
+ workspace_dir,
+ "bd-claimed-restart",
+ "sub-1",
+ "claimed before restart",
+ "thread-claimed-restart",
+ )
+ .await;
+
+ let router = router_for_workspace(workspace_dir);
+ let claimed = router
+ .claim_pending("thread-claimed-restart", usize::MAX)
+ .expect("completion claim succeeds");
+ assert_eq!(claimed.len(), 1);
+ drop(claimed);
+ drop(router);
+ forget_workspace_for_test(workspace_dir);
+
+ let reopened = router_for_workspace(workspace_dir);
+ assert!(
+ reopened
+ .claim_pending("thread-claimed-restart", usize::MAX)
+ .expect("reopened claim succeeds")
+ .is_empty(),
+ "an unexpired durable claim prevents duplicate delivery after reopening"
+ );
+ assert_eq!(
+ pending_for(workspace_dir, "thread-claimed-restart")[0].task_id,
+ "sub-1"
+ );
}
+
+#[tokio::test]
+async fn upstream_delivery_claims_and_acknowledges_one_parent_batch() {
- let router = tinyagents_tasks::CompletionRouter::new(Arc::new(InMemoryCompletionStore::new()));
++ let router = tinyagents_tasks::CompletionRouter::new(Arc::new(
++ tinyagents_tasks::InMemoryCompletionStore::new(),
++ ));
+ for (task_id, text) in [("child-a", "A"), ("child-b", "B")] {
+ router
- .record(CompletionRecord::new(
++ .record(tinyagents_tasks::CompletionRecord::new(
+ task_id,
+ "parent-thread",
+ "researcher",
- CompletionStatus::Success,
- CompletionResult::text(text),
++ tinyagents_tasks::CompletionStatus::Success,
++ tinyagents_tasks::CompletionResult::text(text),
+ ))
+ .await
+ .unwrap();
+ }
+
- let delivery = immediate_delivery();
++ let delivery = CompletionDelivery::new(
++ CompletionDeliveryConfig {
++ debounce: Duration::ZERO,
++ recovery_delay: Duration::ZERO,
++ retry_backoff: Duration::ZERO,
++ busy_poll: Duration::ZERO,
++ max_busy_polls: 0,
++ batch_size: 32,
++ },
++ ThreadDeliveryLeases::default(),
++ );
+ let mut delivered = Vec::new();
+ let outcome = delivery
+ .deliver_once(
- delivery_target(&router),
++ DeliveryTarget {
++ router: &router,
++ parent_key: "parent-thread",
++ tenant_key: "profile",
++ thread_key: "profile:parent-thread",
++ },
+ || false,
+ || true,
+ |batch| {
+ delivered = batch.iter().map(|record| record.task_id.clone()).collect();
+ async { Ok::<(), &'static str>(()) }
+ },
+ |_| {},
+ )
+ .await;
+
+ assert_eq!(outcome, DeliveryOutcome::Delivered { count: 2 });
+ assert_eq!(delivered, ["child-a", "child-b"]);
+ assert!(router.pending_for("parent-thread").is_empty());
+}
+
+#[tokio::test]
+async fn upstream_delivery_reports_parent_busy_without_claiming_completions() {
- let router = tinyagents_tasks::CompletionRouter::new(Arc::new(InMemoryCompletionStore::new()));
++ let router = tinyagents_tasks::CompletionRouter::new(Arc::new(
++ tinyagents_tasks::InMemoryCompletionStore::new(),
++ ));
+ router
- .record(CompletionRecord::new(
++ .record(tinyagents_tasks::CompletionRecord::new(
+ "child-busy",
+ "parent-thread",
+ "researcher",
- CompletionStatus::Success,
- CompletionResult::text("done"),
++ tinyagents_tasks::CompletionStatus::Success,
++ tinyagents_tasks::CompletionResult::text("done"),
+ ))
+ .await
+ .unwrap();
+
- let delivery = immediate_delivery();
++ let delivery = CompletionDelivery::new(
++ CompletionDeliveryConfig {
++ debounce: Duration::ZERO,
++ recovery_delay: Duration::ZERO,
++ retry_backoff: Duration::ZERO,
++ busy_poll: Duration::ZERO,
++ max_busy_polls: 0,
++ batch_size: 32,
++ },
++ ThreadDeliveryLeases::default(),
++ );
+ let outcome = delivery
+ .deliver_once(
- delivery_target(&router),
++ DeliveryTarget {
++ router: &router,
++ parent_key: "parent-thread",
++ tenant_key: "profile",
++ thread_key: "profile:parent-thread",
++ },
+ || true,
+ || true,
+ |_| async { Ok::<(), &'static str>(()) },
+ |_| {},
+ )
+ .await;
+
+ assert_eq!(outcome, DeliveryOutcome::ParentBusy);
+ assert_eq!(router.pending_for("parent-thread")[0].attempts, 0);
+}
-
- #[tokio::test]
- async fn production_drain_uses_the_upstream_path_for_a_thread_without_pending_work() {
- let ctx = crate::core::runtime::DispatchCtx::ambient();
- let thread_id = format!("unmapped-{}", uuid::Uuid::new_v4());
-
- let outcome = try_deliver(ctx, thread_id, DrainFence::none(), false).await;
-
- assert_eq!(outcome, DeliveryOutcome::Empty);
- }