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
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.rsindex 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 @@@ wherlet 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.rsindex 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);- }