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: update split work from epic branch
Steven Enamakel3b82fa397de4
diff --cc crates/openhuman-core/src/agent/session_host/runtime_session/ensure.rsindex d2777295dd,0000000000..e36bd8b6d0mode 100644,000000..100644--- a/crates/openhuman-core/src/agent/session_host/runtime_session/ensure.rs+++ b/crates/openhuman-core/src/agent/session_host/runtime_session/ensure.rs@@@ -1,307 -1,0 +1,307 @@@+use super::*;++impl OpenHumanSessionHost {+ pub(in crate::agent::session_host) fn ensure_runtime_session(&mut self) -> Result<()> {+ if self.runtime_session.is_some() {+ return Ok(());+ }+ let context_config = &self.context_config;+ let tool_result_budget_bytes = context_config.tool_result_budget_bytes;+ let tokenjuice_compaction_enabled = context_config.compaction_enabled;+ let microcompact_keep_recent = if context_config.microcompact_enabled {+ context_config.microcompact_keep_recent+ } else {+ 0+ };+ let autocompact_enabled = context_config.enabled && context_config.autocompact_enabled;+ let compaction = context_config.compaction_settings();- let artifact_store = crate::artifacts::artifact_wiring::build_artifact_store(++ let artifact_store = crate::agent::harness::tool_result_artifacts::build_artifact_store(+ &self.workspace_dir,+ &self.event_session_id,+ );++ // `[components] juice = false`: truncation only, no compaction/summary.+ let juice_on =+ (self.runtime_config.as_ref()).is_none_or(|c| crate::inference::tokenjuice::enabled(c));+ let context_mw = TurnContextMiddleware {+ tool_result_budget_bytes,+ payload_summarizer: self.payload_summarizer.clone().filter(|_| juice_on),- // Rooted outside the project; see `artifact_wiring` (#6408, #6483).++ // Rooted outside the project; see `tool_result_artifacts` (#6408, #6483).+ artifact_store: Some(artifact_store),+ tokenjuice_compaction_enabled: tokenjuice_compaction_enabled && juice_on,+ tokenjuice_compression: self.tokenjuice_compression,+ runtime_config: self.runtime_config.clone(),+ microcompact_keep_recent,+ autocompact_enabled,+ compaction,+ transcript_snapshot: None,+ };+ let driver = Arc::new(OpenHumanSessionDriver::new(+ self.turn_model_source.clone(),+ self.tool_dispatcher.clone(),+ self.model_name.clone(),+ self.temperature,+ self.config.max_tool_iterations,+ self.model_vision,+ self.run_queue.clone(),+ self.workspace_descriptor.clone(),+ self.resolved_definition()+ .map(|definition| definition.sandbox_mode)+ .unwrap_or(tinyagents_definition::SandboxMode::None),+ self.hosted_base.clone(),+ self.agent_definition_id.clone(),+ ));+ // Thread-bound roots resume their deterministic transcript; other+ // turns keep the per-run stem path. Reuse one locator for the initial+ // binding and each resume because the runtime compares locator identity.+ let injected_locator = self.session_history_locator.clone();+ let resume_target = injected_locator+ .as_ref()+ .map(|locator| match self.session.clone() {+ Some(session) => TranscriptTarget::for_session(+ Arc::clone(locator),+ session,+ self.runtime_transcript_meta(),+ ),+ None => TranscriptTarget::new(+ Arc::clone(locator),+ self.injected_transcript_stem(),+ self.runtime_transcript_meta(),+ )+ .with_resume_agent(self.agent_definition_name.clone()),+ });+ {+ let mut state = self+ .runtime_state+ .lock()+ .unwrap_or_else(|poisoned| poisoned.into_inner());+ state.context_middleware = Some(context_mw.clone());+ state.required_output = self+ .config+ .required_output+ .as_ref()+ .map(crate::agent::tinyagents::config::required_output_from);+ state.prelude = Some(self.create_turn_prelude(false));+ }+ let hooks = Arc::new(OpenHumanSessionHooks::new(+ {+ let resume_target = resume_target.clone();+ let state = self.runtime_state.clone();+ move |_, options, _| {+ let resume_target = resume_target.clone();+ begin_turn_resume(+ &mut state+ .lock()+ .unwrap_or_else(|poisoned| poisoned.into_inner()),+ &mut options.resume,+ );+ Box::pin(async move {+ Ok(ResumePreparation {+ transcript: resume_target,+ })+ })+ }+ },+ {+ let state = self.runtime_state.clone();+ move |request, options, view| {+ let state = state.clone();+ let request_base_len = view.history.len()+ + usize::from(view.history.last() != Some(&request.input));+ Box::pin(async move {+ let transcript_snapshot =+ crate::agent::tinyagents::middleware::turn_context::TranscriptSnapshotSink::default();+ transcript_snapshot+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .request_base_len = request_base_len;+ let (prelude, pending_post_commit) = {+ let mut state = state+ .lock()+ .unwrap_or_else(|poisoned| poisoned.into_inner());+ state.active_terminal_sidecar =+ Some(options.run_context.data.session_sidecar.clone());+ (state.prelude.clone(), state.pending_post_commit.take())+ };+ let prelude = prelude.ok_or({+ tinyagents_runtime::RuntimeError::MissingDependency(+ "OpenHumanTurnPrelude",+ )+ })?;+ // The previous turn's goal accounting was deferred past+ // its completion; settle it before this turn reads the goal.+ post_commit::await_pending(pending_post_commit).await;+ let new_session = !view.resumed && view.history.is_empty();+ prelude+ .refresh_turn_boundary(new_session)+ .await+ .map_err(|error| {+ tinyagents_runtime::RuntimeError::Driver(error.to_string())+ })?;+ let context_window = prelude+ .turn_model_source+ .effective_context_window(&prelude.model_name)+ .await+ .unwrap_or_default();+ options+ .run_context+ .data+ .session_sidecar+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .context_window = context_window;+ let original_user_message = user_text_with_markers(&request.input);+ prelude.begin_user_effects(request, &options.run_context.data);+ let turn = state+ .lock()+ .unwrap_or_else(|poisoned| poisoned.into_inner())+ .take_turn_inputs();+ let origin = options.run_context.data.origin.clone();+ let (enriched, memory_turn) = futures::join!(+ prelude.enrich_request(+ &original_user_message,+ &turn,+ &mut options.run_context.data,+ ),+ // Boxed: the hook's future (config load, engine+ // calls) would otherwise be inlined into this+ // already-large hook future.+ Box::pin(prelude.memory_pre_turn(+ view.history,+ view.committed_turns,+ view.history.last().filter(|last| **last == request.input),+ origin,+ )),+ );+ options.run_context.data.memory_turn = memory_turn;+ request.input = user_message_from_text(&enriched);+ let mut preparation = prelude+ .prepare_turn(new_session, &view, &transcript_snapshot, request)+ .await?;+ if turn.overrides.suppress_tools {+ // One-off tool-less turn: must not become the+ // thread's recorded tool list.+ preparation.tools = Some(ToolSnapshot::default().exact());+ }+ let (+ mut current_tools,+ mut current_synthesized_tools,+ policy_session,+ policy_channel,+ ) = prelude.current_tool_source();+ if turn.overrides.suppress_tools {+ current_tools = Arc::new(Vec::new());+ current_synthesized_tools = Arc::new(Vec::new());+ }+ let mut middleware = state+ .lock()+ .unwrap_or_else(|poisoned| poisoned.into_inner())+ .context_middleware+ .clone()+ .ok_or({+ tinyagents_runtime::RuntimeError::MissingDependency(+ "TurnContextMiddleware",+ )+ })?;+ middleware.transcript_snapshot = Some(transcript_snapshot);+ options.run_context.data.context_middleware = Some(middleware);+ options.run_context.data.current_tools = Some(current_tools);+ if !turn.overrides.suppress_tools {+ options.run_context.data.deferred_tool_names =+ Arc::new(prelude.current_deferred_tool_names());+ }+ options.run_context.data.current_synthesized_tools =+ Some(current_synthesized_tools);+ options.run_context.data.tool_rules =+ prelude.turn_tool_rules(&policy_channel, &options.run_context.data);+ options.run_context.data.tool_policy =+ Some(crate::agent::tinyagents::ToolPolicyEnforcement {+ policy: prelude.tool_policy.clone(),+ session: policy_session,+ channel: policy_channel,+ agent_definition_id: prelude.agent_definition_id.clone(),+ });+ options.run_context.data.required_output = state+ .lock()+ .unwrap_or_else(|poisoned| poisoned.into_inner())+ .required_output+ .clone();+ Ok(preparation)+ })+ }+ },+ |outcome, _| {+ Box::pin(async move {+ if outcome+ .output+ .as_deref()+ .is_none_or(|output| output.trim().is_empty())+ {+ return Err(tinyagents_runtime::RuntimeError::Driver(+ "driver returned an empty final response after repair".into(),+ ));+ }+ Ok(())+ })+ },+ |_| Box::pin(async { Ok(()) }),+ {+ let state = self.runtime_state.clone();+ move |terminal| {+ let state = state.clone();+ Box::pin(async move {+ let sidecar = post_commit::take_terminal_sidecar(&state, terminal.clone());+ if let Some(sidecar) = sidecar {+ post_commit::finalize_deferred_terminal(&sidecar, &terminal).await;+ }+ Ok(())+ })+ }+ },+ ));+ // Bind the hook's native target early so both thread and latest-agent+ // resumes can read recorded declarations before host admission.+ let mut builder = SessionBuilder::new(driver)+ .codec(Arc::new(OpenHumanTranscriptCodec))+ .hooks(hooks)+ .post_commit_sink(Arc::new(post_commit::OpenHumanPostCommitSink {+ state: self.runtime_state.clone(),+ hooks: self.post_turn_hooks.clone(),+ identity: post_commit::TurnIdentityOwned {+ session_id: self.event_session_id.clone(),+ agent_id: self.agent_definition_id.clone(),+ channel: self.event_channel.clone(),+ },+ }))+ .retain_recorded_tools(!self.host_only && !self.host_env.fresh_tool_snapshot);+ let meta = self.runtime_transcript_meta();+ builder = if let Some(locator) = injected_locator {+ match self.session.clone() {+ Some(session) => builder.session(locator, session, meta),+ None => builder+ .transcript(locator, self.injected_transcript_stem(), meta)+ .resume_agent(self.agent_definition_name.clone()),+ }+ } else if self.thread_id.is_some() && self.session_parent_prefix.is_none() {+ builder.identity_resolver(+ self.runtime_session_key(),+ meta,+ Arc::new(self.session_identity_resolver()),+ )+ } else {+ builder+ .transcript(+ self.subagent_transcript_locator(),+ self.injected_transcript_stem(),+ meta,+ )+ .resume_agent(self.agent_definition_name.clone())+ };+ self.runtime_session = Some(+ builder+ .build()+ .map_err(|error| anyhow::anyhow!(error.to_string()))?,+ );+ Ok(())+ }+}