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
refactor(session_host): move driver execute into its own module
Steven Enamakela6dbefa11b42
diff --git a/crates/openhuman-core/src/agent/session_host/driver.rs b/crates/openhuman-core/src/agent/session_host/driver.rsindex aef725b1a4..7f40717292 100644--- a/crates/openhuman-core/src/agent/session_host/driver.rs+++ b/crates/openhuman-core/src/agent/session_host/driver.rs@@ -77,454 +77,8 @@ impl OpenHumanSessionDriver {}}-#[async_trait]-impl SessionDriver<OpenHumanRunContext> for OpenHumanSessionDriver {- async fn execute(- &self,- mut request: DriverRequest<OpenHumanRunContext>,- ) -> Result<DriverOutcome, DriverFailure> {- // Use the policy and context prepared for this exact request.- let tool_policy = request- .run_context- .data- .tool_policy- .clone()- .ok_or_else(|| {- driver_failure("session turn is missing its request-scoped tool policy")- })?;- let mut context_mw = request- .run_context- .data- .context_middleware- .clone()- .ok_or_else(|| driver_failure("session turn is missing its request-scoped context"))?;- let hosted_base = self.hosted_base.clone().ok_or_else(|| {- driver_failure(- "hosted root invocation is unavailable because the session has no hosted authority",- )- })?;- let security = crate::agent::tinyagents::host::OpenHumanSecurityGate::new(- hosted_base.security_policy.clone(),- Vec::new(),- )- .with_input_screening(!request.run_context.data.untrusted_input_turn)- .with_approval(request.run_context.data.approval.clone())- .with_dispatch(request.run_context.data.dispatch_ctx());- let (_, block_reason) = security- .screen_new_user_row(&mut request.history)- .await- .map_err(|error| driver_failure(error.to_string()))?;- if let Some(reason) = block_reason {- return Err(DriverFailure {- error: RuntimeError::Driver(reason),- partial: None,- outcome: None,- });- }- // Snapshot the request boundary before assembling the graph so errors- // persist only provider-accepted rounds.- let snapshot = context_mw- .transcript_snapshot- .get_or_insert_with(|| {- Arc::new(std::sync::Mutex::new(- crate::agent::tinyagents::middleware::turn_context::TranscriptSnapshot {- request_base_len: request.history.len(),- ..Default::default()- },- ))- })- .clone();- if let Ok(mut snapshot_state) = snapshot.lock() {- snapshot_state- .pricing_model- .get_or_insert_with(|| self.model_name.clone());- }- let sidecar = request.run_context.data.session_sidecar.clone();- let started = Instant::now();- let user_message = tinyagents_harness::summarization::last_user_message(&request.history)- .map(crate::agent::message_convert::user_text_with_markers)- .unwrap_or_default();- let context_window = self- .turn_model_source- .effective_context_window(&self.model_name)- .await;- let turn_models = self- .turn_model_source- .build(- &self.model_name,- self.temperature,- context_window,- request.run_context.data.thread_id.as_deref(),- )- .map_err(driver_error)?;-- let mut messages: Vec<TranscriptMessage> = request- .history- .iter()- .filter_map(tinyagents_runtime::transcript::message_to_native_transcript)- .collect();- if crate::agent::multimodal::has_image_placeholders(&messages) {- messages = crate::agent::multimodal::rehydrate_image_placeholders(&messages).await;- }-- // Harness `ToolSnapshot` remains the model declaration and final- // allowlist. The actual executable instances must be supplied by the- // request hook as well: falling back to a long-lived driver's tool- // registry would let revoked or hidden tools execute under stale- // authority.- let tools = request- .run_context- .data- .current_tools- .clone()- .ok_or_else(|| driver_failure("session turn is missing request-scoped tools"))?;- let synthesized_tools = request- .run_context- .data- .current_synthesized_tools- .clone()- .ok_or_else(|| {- driver_failure("session turn is missing request-scoped synthesized tools")- })?;- let visible_tool_names: HashSet<String> = request- .tools- .specs()- .iter()- .map(|spec| spec.name.clone())- .collect();- ensure_snapshot_tools_are_executable(- &visible_tool_names,- &tools,- &synthesized_tools,- &request.run_context.data.recorded_tool_names,- )?;- // Text dialects need the positional registry to recover P-Format and code-style calls.- let run_context = request.run_context.data.clone().with_tool_dialect(- tinyagents_harness::dialect::dispatcher_for_format(self.dispatcher.tool_call_format()),- );- let cancellation = request.run_context.cancellation.clone();- // Boxing avoids worker-stack overflow in debug builds.- let turn = Box::pin(async move {- let hosted_base = hosted_base.clone();- let mut run_context = run_context;- run_context.workspace = self.workspace.clone().or(run_context.workspace);- run_context.sandbox_mode = Some(self.sandbox_mode);- let provider_id = turn_models.provider_id().to_string();- TurnSpec {- run_context,- turn_models,- provider_id,- model: &self.model_name,- history: messages,- // Durable and synthesized tools follow the declared-snapshot order.- tool_sets: vec![tools, synthesized_tools],- // `Some(empty)` is deny-all; `None` re-exposes the driver registry.- allowed: Some(visible_tool_names),- max_iterations: self.max_iterations,- subagent_scope: None,- context_window,- run_queue: self.run_queue.clone(),- message_run_queue: None,- early_exit_tools: &["ask_user_clarification"],- pause_at_cap: true,- max_output_tokens: Some(crate::inference::provider::AGENT_TURN_MAX_OUTPUT_TOKENS),- context_mw,- tool_policy: Some(tool_policy),- deterministic_cacheable: false,- defer_turn_completed_to_caller: true,- }- .run_hosted(hosted_base, self.agent_id.clone())- .await- });- // A Stop hands provider-accepted rounds back so the runtime retains them (#7715).- let result = tokio::select! {- biased;- _ = cancellation.cancelled() => {- return Err(driver_cancelled_with_snapshot(- &snapshot,- &sidecar,- started.elapsed(),- std::mem::take(&mut request.history),- ));- }- result = turn => result,- };- let mut outcome = match result {- Ok(outcome) => outcome,- Err(error) => {- return Err(driver_error_with_snapshot(- error,- &snapshot,- &sidecar,- started.elapsed(),- ));- }- };- let supplemental_trace = SupplementalTrace::install_for_turn(&sidecar, &mut outcome);-- if outcome.text.trim().is_empty() && outcome.tool_outcomes.is_empty() {- return Err(driver_error(- tinyagents_harness::agent_error::AgentError::EmptyProviderResponse {- iteration: outcome.model_calls,- },- ));- }- // A late cap pause still marks an empty exhausted loop as capped.- outcome.hit_cap |= outcome.text.trim().is_empty()- && (outcome.model_calls >= self.max_iterations- || outcome.tool_calls >= self.max_iterations- || outcome.tool_outcomes.len() >= self.max_iterations);- // Older hosted-harness fallbacks leave the raw counters unavailable.- // They only occur when the loop exhausted a tool round without a model- // conclusion, so normalize them to the same resumable cap state.- let exhausted_fallback = outcome- .text- .starts_with("I finished this turn without writing up a result.");- outcome.hit_cap |= exhausted_fallback;- // This fallback is not model-authored; replace it with the resumable checkpoint.- if exhausted_fallback {- outcome.wrap_up_injected = false;- }-- // Keep the close and any required-output repair inside the turn deadline.- let close_by = request.run_context.data.turn_deadline.map(|deadline| {- let now = Instant::now();- now + deadline.close_budget(now)- });- // A Stop during close or repair also returns accepted rounds (#7776).- let accepted_history = request.history.clone();- let stopped = || {- driver_cancelled_with_snapshot(- &snapshot,- &sidecar,- started.elapsed(),- accepted_history.clone(),- )- };- let close = tokio::select! {- biased;- _ = cancellation.cancelled() => return Err(stopped()),- close = grounded_close::close_if_needed(- &self.turn_model_source,- &self.model_name,- self.temperature,- request.run_context.data.thread_id.as_deref(),- self.dispatcher.as_ref(),- &request.history,- &user_message,- &outcome,- close_by.map(|at| at.saturating_duration_since(Instant::now())),- supplemental_trace.as_ref(),- ) => close,- };- let mut output = close- .as_ref()- .map(|close| close.output.clone())- .unwrap_or_else(|| outcome.text.clone());- // A tools-only loop may reach the close path after the hosted runtime- // has already dropped its cap metadata. Its generic final-summary- // fallback is not a completed answer; preserve resumability by making- // the durable reply an explicit checkpoint.- if outcome.text.trim().is_empty()- && output.starts_with("I finished this turn without writing up a result.")- {- let results = super::product_copy::close_results(&outcome.tool_outcomes);- let rendered = super::product_copy::render_close_results(&results, 4_000);- output = tinyagents_harness::close::checkpoint_with_copy(- &super::product_copy::OPENHUMAN_CLOSE_COPY,- self.max_iterations,- &rendered,- !results.is_empty(),- );- }- let mut history = request.history;- let conversation = crate::agent::message_convert::provider_messages_from_conversation(- self.dispatcher.as_ref(),- &outcome.conversation,- );- let mut appended = crate::agent::message_convert::history_to_messages(&conversation);- if close.is_some() {- // A blank or breaker-halt terminal row is not the durable answer.- // Retain every completed tool round and replace only that final- // assistant row with the verified/deterministic grounded close.- if appended- .last()- .is_some_and(|message| matches!(message, Message::Assistant(_)))- {- appended.pop();- }- appended.push(Message::assistant(output.clone()));- }- history.extend(appended);-- let required_output = request.run_context.data.required_output.clone();- let classified_halt = outcome- .breaker_halt- .as_deref()- .is_some_and(|reason| reason.starts_with("Stopping after "));- let time_left = close_by.map(|at| at.saturating_duration_since(Instant::now()));- let mut repair_usage = grounded_close::RepairUsage::for_model(&self.model_name);- let required_repair = match required_output.as_ref() {- Some(contract) if classified_halt || time_left.is_some_and(|left| left.is_zero()) => {- append_synthesized_block(&mut output, &mut history, contract);- None- }- Some(contract) => {- let repaired = {- let repair = grounded_close::repair_required_output(- &self.turn_model_source,- &self.model_name,- self.temperature,- request.run_context.data.thread_id.as_deref(),- self.dispatcher.as_ref(),- contract,- &history,- &output,- close.is_none() && request.run_context.data.progress.is_some(),- request.run_context.data.progress.as_ref(),- outcome.model_calls.saturating_add(1) as u32,- &mut repair_usage,- supplemental_trace.as_ref(),- );- tokio::pin!(repair);- tokio::select! {- biased;- _ = cancellation.cancelled() => return Err(stopped()),- repaired = async {- match time_left {- // Bound to what is left so the turn still commits;- // on expiry fall back to the deterministic block.- Some(left) => tokio::time::timeout(left, &mut repair).await.ok(),- None => Some((&mut repair).await),- }- } => repaired,- }- };- match repaired {- Some(repaired) => repaired,- None => {- append_synthesized_block(&mut output, &mut history, contract);- None- }- }- }- None => None,- };- if let Some(repaired) = required_repair {- output = repaired;- if history- .last()- .is_some_and(|message| matches!(message, Message::Assistant(_)))- {- history.pop();- }- history.push(Message::assistant(output.clone()));- }-- // This is deliberately an out-of-band observation rather than a- // second history or transcript. The runtime only reads it from- // `after_commit`, so a failed/cancelled turn cannot publish its usage- // or tool outcomes as if they had become durable.- {- // Always billed: a repair that timed out after its call answered- // still recorded that call here.- let repair_usage = Some(&repair_usage);- let mut observed = sidecar- .lock()- .unwrap_or_else(|poisoned| poisoned.into_inner());- observed.model_calls = outcome.model_calls- + close- .as_ref()- .map(|close| close.usage.model_calls)- .unwrap_or_default()- + repair_usage- .map(|usage| usage.model_calls)- .unwrap_or_default();- observed.tool_calls = outcome.tool_calls;- observed.input_tokens = outcome.input_tokens- + close- .as_ref()- .map(|close| close.usage.input_tokens)- .unwrap_or_default()- + repair_usage- .map(|usage| usage.input_tokens)- .unwrap_or_default();- observed.output_tokens = outcome.output_tokens- + close- .as_ref()- .map(|close| close.usage.output_tokens)- .unwrap_or_default()- + repair_usage- .map(|usage| usage.output_tokens)- .unwrap_or_default();- observed.cached_input_tokens = outcome.cached_input_tokens- + close- .as_ref()- .map(|close| close.usage.cached_input_tokens)- .unwrap_or_default()- + repair_usage- .map(|usage| usage.cached_input_tokens)- .unwrap_or_default();- let mut cost = outcome.cost;- if let Some(close) = close.as_ref() {- cost.merge(close.usage.cost);- }- if let Some(repair) = repair_usage {- cost.merge(repair.cost);- }- observed.cost = cost;- let loop_last_call = snapshot- .lock()- .ok()- .map(|guard| (guard.last_call_input_tokens, guard.last_call_output_tokens));- (- observed.last_call_input_tokens,- observed.last_call_output_tokens,- ) = grounded_close::final_call_tokens(- loop_last_call,- close.as_ref().map(|close| &close.usage),- repair_usage,- );- observed.duration = Some(started.elapsed());- observed.driver_finished_at = Some(std::time::Instant::now());- observed.tool_outcomes = outcome.tool_outcomes.clone();- observed.hit_cap = outcome.hit_cap;- observed.wrap_up_injected = outcome.wrap_up_injected;- // Preserve the harness stop reason and the wind-down sidecar marker.- observed.stop = crate::agent::session_host::stop_policy::classify_stop_with_cause(- outcome.breaker_halt.as_deref(),- outcome.failure_cause.clone(),- observed.wind_down,- outcome.hit_cap,- );- if let Some(stop) = &observed.stop {- tracing::debug!(- model = %self.model_name,- "[session-driver] turn stopped early; recording on the sidecar {}",- stop.status_message()- );- }- observed.resolved_route = outcome.resolved_route.clone();- };- // The turn compacted its context: persist the compacted history, so the- // next turn starts from the checkpoint. The runtime session seals the- // current generation and opens the next (the history no longer extends- // it), so the full conversation stays on disk.- let history = match &outcome.compaction {- Some(carry) => carry.apply(history),- None => history,- };- Ok(DriverOutcome {- history,- output: Some(output),- partial: None,- interrupted: outcome.early_exit_tool.is_some() || outcome.hit_cap,- // `None` lets the runtime derive the outcome from `interrupted`.- outcome: None,- tool_outcomes: outcome.tool_outcomes.clone(),- })- }-}+#[path = "driver/execute.rs"]+mod execute;#[cfg(test)]#[path = "driver_tests.rs"]diff --git a/crates/openhuman-core/src/agent/session_host/driver/execute.rs b/crates/openhuman-core/src/agent/session_host/driver/execute.rsnew file mode 100644index 0000000000..7cfae5119a--- /dev/null+++ b/crates/openhuman-core/src/agent/session_host/driver/execute.rs@@ -0,0 +1,451 @@+use super::*;++#[async_trait]+impl SessionDriver<OpenHumanRunContext> for OpenHumanSessionDriver {+ async fn execute(+ &self,+ mut request: DriverRequest<OpenHumanRunContext>,+ ) -> Result<DriverOutcome, DriverFailure> {+ // Use the policy and context prepared for this exact request.+ let tool_policy = request+ .run_context+ .data+ .tool_policy+ .clone()+ .ok_or_else(|| {+ driver_failure("session turn is missing its request-scoped tool policy")+ })?;+ let mut context_mw = request+ .run_context+ .data+ .context_middleware+ .clone()+ .ok_or_else(|| driver_failure("session turn is missing its request-scoped context"))?;+ let hosted_base = self.hosted_base.clone().ok_or_else(|| {+ driver_failure(+ "hosted root invocation is unavailable because the session has no hosted authority",+ )+ })?;+ let security = crate::agent::tinyagents::host::OpenHumanSecurityGate::new(+ hosted_base.security_policy.clone(),+ Vec::new(),+ )+ .with_input_screening(!request.run_context.data.untrusted_input_turn)+ .with_approval(request.run_context.data.approval.clone())+ .with_dispatch(request.run_context.data.dispatch_ctx());+ let (_, block_reason) = security+ .screen_new_user_row(&mut request.history)+ .await+ .map_err(|error| driver_failure(error.to_string()))?;+ if let Some(reason) = block_reason {+ return Err(DriverFailure {+ error: RuntimeError::Driver(reason),+ partial: None,+ outcome: None,+ });+ }+ // Snapshot the request boundary before assembling the graph so errors+ // persist only provider-accepted rounds.+ let snapshot = context_mw+ .transcript_snapshot+ .get_or_insert_with(|| {+ Arc::new(std::sync::Mutex::new(+ crate::agent::tinyagents::middleware::turn_context::TranscriptSnapshot {+ request_base_len: request.history.len(),+ ..Default::default()+ },+ ))+ })+ .clone();+ if let Ok(mut snapshot_state) = snapshot.lock() {+ snapshot_state+ .pricing_model+ .get_or_insert_with(|| self.model_name.clone());+ }+ let sidecar = request.run_context.data.session_sidecar.clone();+ let started = Instant::now();+ let user_message = tinyagents_harness::summarization::last_user_message(&request.history)+ .map(crate::agent::message_convert::user_text_with_markers)+ .unwrap_or_default();+ let context_window = self+ .turn_model_source+ .effective_context_window(&self.model_name)+ .await;+ let turn_models = self+ .turn_model_source+ .build(+ &self.model_name,+ self.temperature,+ context_window,+ request.run_context.data.thread_id.as_deref(),+ )+ .map_err(driver_error)?;++ let mut messages: Vec<TranscriptMessage> = request+ .history+ .iter()+ .filter_map(tinyagents_runtime::transcript::message_to_native_transcript)+ .collect();+ if crate::agent::multimodal::has_image_placeholders(&messages) {+ messages = crate::agent::multimodal::rehydrate_image_placeholders(&messages).await;+ }++ // Harness `ToolSnapshot` remains the model declaration and final+ // allowlist. The actual executable instances must be supplied by the+ // request hook as well: falling back to a long-lived driver's tool+ // registry would let revoked or hidden tools execute under stale+ // authority.+ let tools = request+ .run_context+ .data+ .current_tools+ .clone()+ .ok_or_else(|| driver_failure("session turn is missing request-scoped tools"))?;+ let synthesized_tools = request+ .run_context+ .data+ .current_synthesized_tools+ .clone()+ .ok_or_else(|| {+ driver_failure("session turn is missing request-scoped synthesized tools")+ })?;+ let visible_tool_names: HashSet<String> = request+ .tools+ .specs()+ .iter()+ .map(|spec| spec.name.clone())+ .collect();+ ensure_snapshot_tools_are_executable(+ &visible_tool_names,+ &tools,+ &synthesized_tools,+ &request.run_context.data.recorded_tool_names,+ )?;+ // Text dialects need the positional registry to recover P-Format and code-style calls.+ let run_context = request.run_context.data.clone().with_tool_dialect(+ tinyagents_harness::dialect::dispatcher_for_format(self.dispatcher.tool_call_format()),+ );+ let cancellation = request.run_context.cancellation.clone();+ // Boxing avoids worker-stack overflow in debug builds.+ let turn = Box::pin(async move {+ let hosted_base = hosted_base.clone();+ let mut run_context = run_context;+ run_context.workspace = self.workspace.clone().or(run_context.workspace);+ run_context.sandbox_mode = Some(self.sandbox_mode);+ let provider_id = turn_models.provider_id().to_string();+ TurnSpec {+ run_context,+ turn_models,+ provider_id,+ model: &self.model_name,+ history: messages,+ // Durable and synthesized tools follow the declared-snapshot order.+ tool_sets: vec![tools, synthesized_tools],+ // `Some(empty)` is deny-all; `None` re-exposes the driver registry.+ allowed: Some(visible_tool_names),+ max_iterations: self.max_iterations,+ subagent_scope: None,+ context_window,+ run_queue: self.run_queue.clone(),+ message_run_queue: None,+ early_exit_tools: &["ask_user_clarification"],+ pause_at_cap: true,+ max_output_tokens: Some(crate::inference::provider::AGENT_TURN_MAX_OUTPUT_TOKENS),+ context_mw,+ tool_policy: Some(tool_policy),+ deterministic_cacheable: false,+ defer_turn_completed_to_caller: true,+ }+ .run_hosted(hosted_base, self.agent_id.clone())+ .await+ });+ // A Stop hands provider-accepted rounds back so the runtime retains them (#7715).+ let result = tokio::select! {+ biased;+ _ = cancellation.cancelled() => {+ return Err(driver_cancelled_with_snapshot(+ &snapshot,+ &sidecar,+ started.elapsed(),+ std::mem::take(&mut request.history),+ ));+ }+ result = turn => result,+ };+ let mut outcome = match result {+ Ok(outcome) => outcome,+ Err(error) => {+ return Err(driver_error_with_snapshot(+ error,+ &snapshot,+ &sidecar,+ started.elapsed(),+ ));+ }+ };+ let supplemental_trace = SupplementalTrace::install_for_turn(&sidecar, &mut outcome);++ if outcome.text.trim().is_empty() && outcome.tool_outcomes.is_empty() {+ return Err(driver_error(+ tinyagents_harness::agent_error::AgentError::EmptyProviderResponse {+ iteration: outcome.model_calls,+ },+ ));+ }+ // A late cap pause still marks an empty exhausted loop as capped.+ outcome.hit_cap |= outcome.text.trim().is_empty()+ && (outcome.model_calls >= self.max_iterations+ || outcome.tool_calls >= self.max_iterations+ || outcome.tool_outcomes.len() >= self.max_iterations);+ // Older hosted-harness fallbacks leave the raw counters unavailable.+ // They only occur when the loop exhausted a tool round without a model+ // conclusion, so normalize them to the same resumable cap state.+ let exhausted_fallback = outcome+ .text+ .starts_with("I finished this turn without writing up a result.");+ outcome.hit_cap |= exhausted_fallback;+ // This fallback is not model-authored; replace it with the resumable checkpoint.+ if exhausted_fallback {+ outcome.wrap_up_injected = false;+ }++ // Keep the close and any required-output repair inside the turn deadline.+ let close_by = request.run_context.data.turn_deadline.map(|deadline| {+ let now = Instant::now();+ now + deadline.close_budget(now)+ });+ // A Stop during close or repair also returns accepted rounds (#7776).+ let accepted_history = request.history.clone();+ let stopped = || {+ driver_cancelled_with_snapshot(+ &snapshot,+ &sidecar,+ started.elapsed(),+ accepted_history.clone(),+ )+ };+ let close = tokio::select! {+ biased;+ _ = cancellation.cancelled() => return Err(stopped()),+ close = grounded_close::close_if_needed(+ &self.turn_model_source,+ &self.model_name,+ self.temperature,+ request.run_context.data.thread_id.as_deref(),+ self.dispatcher.as_ref(),+ &request.history,+ &user_message,+ &outcome,+ close_by.map(|at| at.saturating_duration_since(Instant::now())),+ supplemental_trace.as_ref(),+ ) => close,+ };+ let mut output = close+ .as_ref()+ .map(|close| close.output.clone())+ .unwrap_or_else(|| outcome.text.clone());+ // A tools-only loop may reach the close path after the hosted runtime+ // has already dropped its cap metadata. Its generic final-summary+ // fallback is not a completed answer; preserve resumability by making+ // the durable reply an explicit checkpoint.+ if outcome.text.trim().is_empty()+ && output.starts_with("I finished this turn without writing up a result.")+ {+ let results = super::product_copy::close_results(&outcome.tool_outcomes);+ let rendered = super::product_copy::render_close_results(&results, 4_000);+ output = tinyagents_harness::close::checkpoint_with_copy(+ &super::product_copy::OPENHUMAN_CLOSE_COPY,+ self.max_iterations,+ &rendered,+ !results.is_empty(),+ );+ }+ let mut history = request.history;+ let conversation = crate::agent::message_convert::provider_messages_from_conversation(+ self.dispatcher.as_ref(),+ &outcome.conversation,+ );+ let mut appended = crate::agent::message_convert::history_to_messages(&conversation);+ if close.is_some() {+ // A blank or breaker-halt terminal row is not the durable answer.+ // Retain every completed tool round and replace only that final+ // assistant row with the verified/deterministic grounded close.+ if appended+ .last()+ .is_some_and(|message| matches!(message, Message::Assistant(_)))+ {+ appended.pop();+ }+ appended.push(Message::assistant(output.clone()));+ }+ history.extend(appended);++ let required_output = request.run_context.data.required_output.clone();+ let classified_halt = outcome+ .breaker_halt+ .as_deref()+ .is_some_and(|reason| reason.starts_with("Stopping after "));+ let time_left = close_by.map(|at| at.saturating_duration_since(Instant::now()));+ let mut repair_usage = grounded_close::RepairUsage::for_model(&self.model_name);+ let required_repair = match required_output.as_ref() {+ Some(contract) if classified_halt || time_left.is_some_and(|left| left.is_zero()) => {+ append_synthesized_block(&mut output, &mut history, contract);+ None+ }+ Some(contract) => {+ let repaired = {+ let repair = grounded_close::repair_required_output(+ &self.turn_model_source,+ &self.model_name,+ self.temperature,+ request.run_context.data.thread_id.as_deref(),+ self.dispatcher.as_ref(),+ contract,+ &history,+ &output,+ close.is_none() && request.run_context.data.progress.is_some(),+ request.run_context.data.progress.as_ref(),+ outcome.model_calls.saturating_add(1) as u32,+ &mut repair_usage,+ supplemental_trace.as_ref(),+ );+ tokio::pin!(repair);+ tokio::select! {+ biased;+ _ = cancellation.cancelled() => return Err(stopped()),+ repaired = async {+ match time_left {+ // Bound to what is left so the turn still commits;+ // on expiry fall back to the deterministic block.+ Some(left) => tokio::time::timeout(left, &mut repair).await.ok(),+ None => Some((&mut repair).await),+ }+ } => repaired,+ }+ };+ match repaired {+ Some(repaired) => repaired,+ None => {+ append_synthesized_block(&mut output, &mut history, contract);+ None+ }+ }+ }+ None => None,+ };+ if let Some(repaired) = required_repair {+ output = repaired;+ if history+ .last()+ .is_some_and(|message| matches!(message, Message::Assistant(_)))+ {+ history.pop();+ }+ history.push(Message::assistant(output.clone()));+ }++ // This is deliberately an out-of-band observation rather than a+ // second history or transcript. The runtime only reads it from+ // `after_commit`, so a failed/cancelled turn cannot publish its usage+ // or tool outcomes as if they had become durable.+ {+ // Always billed: a repair that timed out after its call answered+ // still recorded that call here.+ let repair_usage = Some(&repair_usage);+ let mut observed = sidecar+ .lock()+ .unwrap_or_else(|poisoned| poisoned.into_inner());+ observed.model_calls = outcome.model_calls+ + close+ .as_ref()+ .map(|close| close.usage.model_calls)+ .unwrap_or_default()+ + repair_usage+ .map(|usage| usage.model_calls)+ .unwrap_or_default();+ observed.tool_calls = outcome.tool_calls;+ observed.input_tokens = outcome.input_tokens+ + close+ .as_ref()+ .map(|close| close.usage.input_tokens)+ .unwrap_or_default()+ + repair_usage+ .map(|usage| usage.input_tokens)+ .unwrap_or_default();+ observed.output_tokens = outcome.output_tokens+ + close+ .as_ref()+ .map(|close| close.usage.output_tokens)+ .unwrap_or_default()+ + repair_usage+ .map(|usage| usage.output_tokens)+ .unwrap_or_default();+ observed.cached_input_tokens = outcome.cached_input_tokens+ + close+ .as_ref()+ .map(|close| close.usage.cached_input_tokens)+ .unwrap_or_default()+ + repair_usage+ .map(|usage| usage.cached_input_tokens)+ .unwrap_or_default();+ let mut cost = outcome.cost;+ if let Some(close) = close.as_ref() {+ cost.merge(close.usage.cost);+ }+ if let Some(repair) = repair_usage {+ cost.merge(repair.cost);+ }+ observed.cost = cost;+ let loop_last_call = snapshot+ .lock()+ .ok()+ .map(|guard| (guard.last_call_input_tokens, guard.last_call_output_tokens));+ (+ observed.last_call_input_tokens,+ observed.last_call_output_tokens,+ ) = grounded_close::final_call_tokens(+ loop_last_call,+ close.as_ref().map(|close| &close.usage),+ repair_usage,+ );+ observed.duration = Some(started.elapsed());+ observed.driver_finished_at = Some(std::time::Instant::now());+ observed.tool_outcomes = outcome.tool_outcomes.clone();+ observed.hit_cap = outcome.hit_cap;+ observed.wrap_up_injected = outcome.wrap_up_injected;+ // Preserve the harness stop reason and the wind-down sidecar marker.+ observed.stop = crate::agent::session_host::stop_policy::classify_stop_with_cause(+ outcome.breaker_halt.as_deref(),+ outcome.failure_cause.clone(),+ observed.wind_down,+ outcome.hit_cap,+ );+ if let Some(stop) = &observed.stop {+ tracing::debug!(+ model = %self.model_name,+ "[session-driver] turn stopped early; recording on the sidecar {}",+ stop.status_message()+ );+ }+ observed.resolved_route = outcome.resolved_route.clone();+ };+ // The turn compacted its context: persist the compacted history, so the+ // next turn starts from the checkpoint. The runtime session seals the+ // current generation and opens the next (the history no longer extends+ // it), so the full conversation stays on disk.+ let history = match &outcome.compaction {+ Some(carry) => carry.apply(history),+ None => history,+ };+ Ok(DriverOutcome {+ history,+ output: Some(output),+ partial: None,+ interrupted: outcome.early_exit_tool.is_some() || outcome.hit_cap,+ // `None` lets the runtime derive the outcome from `interrupted`.+ outcome: None,+ tool_outcomes: outcome.tool_outcomes.clone(),+ })+ }+}+