Skip to content

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

refactor(session_host): extract runtime session state and ensure logic

Steven Enamakel76bdde021667
diff --git a/crates/openhuman-core/src/agent/session_host/runtime_session.rs b/crates/openhuman-core/src/agent/session_host/runtime_session.rs
index 8f7be5eb24..986a4905ac 100644
--- a/crates/openhuman-core/src/agent/session_host/runtime_session.rs
+++ b/crates/openhuman-core/src/agent/session_host/runtime_session.rs
@@ -161,44 +161,13 @@ struct OpenHumanTurnToolSurface {
/// Per-session product observations formerly scattered across the legacy
/// `core_turn` loop. Generic history, raw transcript and prefix state are not here.
-#[derive(Default)]
-struct OpenHumanTurnPreludeMutable {
- last_memory_context: Option<String>,
- announced_integrations: std::collections::HashSet<String>,
- pending_integration_announcement: Vec<String>,
- announced_mcp_servers: std::collections::HashSet<String>,
- pending_mcp_announcement: Vec<String>,
- /// Current catalogs and frozen names retained by the module tool adapter.
- #[cfg(feature = "mcp")]
- mcp_tools: prelude_integrations::McpToolCatalog,
- announced_skills: std::collections::HashSet<String>,
- pending_skill_announcement: Vec<String>,
- pending_skill_retraction: Vec<String>,
- connected_integrations: Vec<crate::integrations::ConnectedIntegration>,
- connected_integrations_initialized: bool,
- connected_integrations_authoritative: bool,
- /// A cold hydration seeded the announced sets; later ones diff instead.
- integration_announcements_seeded: bool,
- /// Integration action declarations this thread was already sent, restored by
- /// the tinyagents session on resume. Rebuilt into deferred executors whenever
- /// the live integrations list does not supply them (see `recorded_tools`).
- recorded_integration_actions: Vec<tinytools::ToolSpec>,
- /// TinyJuice REPL declarations restored by a resumed thread. These are
- /// rebuilt independently of the current setting that creates new handles.
- recorded_repl_tools: Vec<tinytools::ToolSpec>,
- /// Distinguishes a new session from a resumed session whose recorded tool
- /// snapshot simply had no TinyJuice declarations.
- recorded_tool_snapshot_adopted: bool,
- workflows: Vec<tinyskills::Skill>,
- composio_events: Option<tinybus::events::EventReceiver<crate::core::events::DomainEvent>>,
- skill_events: Option<tinybus::events::EventReceiver<crate::core::events::DomainEvent>>,
- /// The user-authored text of the in-flight turn, held until commit so the
- /// committed turn can be handed to memory.
- pending_user_text: Option<String>,
- /// The in-flight turn's memory identity and index, from pre-turn to
- /// commit (`memory::lifecycle::session_hooks`).
- pending_memory_turn: Option<session_hooks::PendingMemoryTurn>,
-}
+#[path = "runtime_session/announcement_state.rs"]
+mod announcement_state;
+use announcement_state::OpenHumanTurnPreludeMutable;
+
+
+#[path = "runtime_session/ensure.rs"]
+mod ensure;
impl OpenHumanSessionHost {
pub(super) fn update_runtime_prelude_progress(
@@ -259,309 +228,6 @@ impl OpenHumanSessionHost {
self.turn_with_origin(user_message, None).await
}
- 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(
- &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).
- 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(())
- }
/// Publish a caller-driven visibility/policy mutation into the live hook
/// state. The runtime keeps generic snapshots immutable per request; this
diff --git a/crates/openhuman-core/src/agent/session_host/runtime_session/announcement_state.rs b/crates/openhuman-core/src/agent/session_host/runtime_session/announcement_state.rs
new file mode 100644
index 0000000000..f8777437fd
--- /dev/null
+++ b/crates/openhuman-core/src/agent/session_host/runtime_session/announcement_state.rs
@@ -0,0 +1,40 @@
+use super::*;
+
+#[derive(Default)]
+pub(super) struct OpenHumanTurnPreludeMutable {
+ pub(super) last_memory_context: Option<String>,
+ pub(super) announced_integrations: std::collections::HashSet<String>,
+ pub(super) pending_integration_announcement: Vec<String>,
+ pub(super) announced_mcp_servers: std::collections::HashSet<String>,
+ pub(super) pending_mcp_announcement: Vec<String>,
+ /// Current catalogs and frozen names retained by the module tool adapter.
+ #[cfg(feature = "mcp")]
+ pub(super) mcp_tools: prelude_integrations::McpToolCatalog,
+ pub(super) announced_skills: std::collections::HashSet<String>,
+ pub(super) pending_skill_announcement: Vec<String>,
+ pub(super) pending_skill_retraction: Vec<String>,
+ pub(super) connected_integrations: Vec<crate::integrations::ConnectedIntegration>,
+ pub(super) connected_integrations_initialized: bool,
+ pub(super) connected_integrations_authoritative: bool,
+ /// A cold hydration seeded the announced sets; later ones diff instead.
+ pub(super) integration_announcements_seeded: bool,
+ /// Integration action declarations this thread was already sent, restored by
+ /// the tinyagents session on resume. Rebuilt into deferred executors whenever
+ /// the live integrations list does not supply them (see `recorded_tools`).
+ pub(super) recorded_integration_actions: Vec<tinytools::ToolSpec>,
+ /// TinyJuice REPL declarations restored by a resumed thread. These are
+ /// rebuilt independently of the current setting that creates new handles.
+ pub(super) recorded_repl_tools: Vec<tinytools::ToolSpec>,
+ /// Distinguishes a new session from a resumed session whose recorded tool
+ /// snapshot simply had no TinyJuice declarations.
+ pub(super) recorded_tool_snapshot_adopted: bool,
+ pub(super) workflows: Vec<tinyskills::Skill>,
+ pub(super) composio_events: Option<tinybus::events::EventReceiver<crate::core::events::DomainEvent>>,
+ pub(super) skill_events: Option<tinybus::events::EventReceiver<crate::core::events::DomainEvent>>,
+ /// The user-authored text of the in-flight turn, held until commit so the
+ /// committed turn can be handed to memory.
+ pub(super) pending_user_text: Option<String>,
+ /// The in-flight turn's memory identity and index, from pre-turn to
+ /// commit (`memory::lifecycle::session_hooks`).
+ pub(super) pending_memory_turn: Option<session_hooks::PendingMemoryTurn>,
+}
diff --git a/crates/openhuman-core/src/agent/session_host/runtime_session/ensure.rs b/crates/openhuman-core/src/agent/session_host/runtime_session/ensure.rs
new file mode 100644
index 0000000000..4d336a2ae7
--- /dev/null
+++ b/crates/openhuman-core/src/agent/session_host/runtime_session/ensure.rs
@@ -0,0 +1,308 @@
+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(
+ &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).
+ 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(())
+ }
+
+}