diff --git a/codex-rs/core/src/compact_remote_v2.rs b/codex-rs/core/src/compact_remote_v2.rs index bff7edc029..0a20d0155c 100644 --- a/codex-rs/core/src/compact_remote_v2.rs +++ b/codex-rs/core/src/compact_remote_v2.rs @@ -1521,21 +1521,23 @@ mod tests { ); } - #[test_case::test_case(false, false, false; "foreground bills a complete response even without a summary")] - #[test_case::test_case(true, false, false; "background bills a complete response even without a summary")] - #[test_case::test_case(false, true, false; "turn interrupt discards a queued complete response")] - #[test_case::test_case(true, true, false; "session shutdown bills a queued complete response even without a summary")] - #[test_case::test_case(false, false, true; "a malformed sibling is still reported when valid spending exhausts the account")] + #[test_case::test_case(false, false, false, None; "foreground bills a complete response even without a summary")] + #[test_case::test_case(true, false, false, None; "background bills a complete response even without a summary")] + #[test_case::test_case(false, true, false, None; "turn interrupt discards a queued complete response")] + #[test_case::test_case(true, true, false, None; "session shutdown bills a queued complete response even without a summary")] + #[test_case::test_case(false, false, true, None; "a malformed sibling is still reported when valid spending exhausts the account")] #[tokio::test] async fn collect_queued_complete_response( background: bool, interrupted: bool, bad_sibling: bool, + host_total: Option, ) { - let (mut sess, turn, _) = crate::session::tests::make_session_and_context_with_rx().await; + let (mut sess, turn, _events) = + crate::session::tests::make_session_and_context_with_rx().await; let accounting = Arc::new(UsageRecorder { reports: Mutex::new(Vec::new()), - decision: if bad_sibling { + decision: if bad_sibling || host_total.is_some() { UsageAccountingDecision::Exhausted } else { UsageAccountingDecision::Continue diff --git a/codex-rs/core/src/session/rollout_budget.rs b/codex-rs/core/src/session/rollout_budget.rs index a63307b735..127ae038c4 100644 --- a/codex-rs/core/src/session/rollout_budget.rs +++ b/codex-rs/core/src/session/rollout_budget.rs @@ -9,7 +9,6 @@ use crate::context::ContextualUserFragment; use codex_protocol::error::CodexErr; use codex_protocol::error::CodexErrorDetails; use codex_protocol::error::Result as CodexResult; -use codex_protocol::protocol::TokenUsage; pub(super) async fn maybe_record_reminder( sess: &Session, @@ -120,14 +119,7 @@ impl Session { usage: &SamplingUsage, ) -> CodexResult<()> { let result = match usage.charge.posting { - ChargePosting::Unposted => { - self.record_numeric_usage( - turn_id, - usage.provider.as_ref(), - usage.charge.hooks.charge, - ) - .await - } + ChargePosting::Unposted => self.record_numeric_usage(turn_id, usage).await, ChargePosting::Posted => Ok(()), ChargePosting::PostedTurnExhausted => Err(CodexErr::SessionBudgetExceeded), }; @@ -145,13 +137,9 @@ impl Session { result } - async fn record_numeric_usage( - &self, - turn_id: &str, - usage: Option<&TokenUsage>, - hook_charge: codex_hooks::HookCharge, - ) -> CodexResult<()> { - let hook_units = match hook_charge { + async fn record_numeric_usage(&self, turn_id: &str, report: &SamplingUsage) -> CodexResult<()> { + let usage = report.provider.as_ref(); + let hook_units = match report.charge.hooks.charge { codex_hooks::HookCharge::Units(units) => units, codex_hooks::HookCharge::Overflow => { if let Some(account) = self.native_rollout_budget() @@ -167,52 +155,57 @@ impl Session { if usage.is_none() && hook_units == 0.0 { return Ok(()); } - let stop_new_work = match &self.agent_runtime { + match &self.agent_runtime { AgentRuntimeServices::Controller => match self .services .agent_control .record_usage(usage.cloned(), hook_units) .await { - Ok(()) => false, + Ok(()) => Ok(()), // A legacy controller can report a posted bill and a stop through this error. // A native account has already chosen its own deadline action. Err(error) if matches!(error.details(), CodexErrorDetails::SessionBudgetExceeded) => { - self.native_rollout_budget().is_none() + if self.native_rollout_budget().is_none() { + self.work_budget().stop_new_work(); + } + Ok(()) } - Err(error) => return Err(CodexErr::UsageAccountingFailed(error.to_string())), + Err(error) => Err(CodexErr::UsageAccountingFailed(error.to_string())), }, AgentRuntimeServices::Host(services) => { let Some(accounting) = &services.usage_accounting else { return Ok(()); }; + let usage_report = AgentUsageReport { + thread_id: self.thread_id(), + turn_id: turn_id.to_owned(), + usage: usage.cloned(), + additional_budget_units: hook_units, + }; + let host_error = |error| { + CodexErr::UsageAccountingFailed(format!( + "Host usage accounting failed: {error}" + )) + }; let decision = accounting - .report_usage(AgentUsageReport { - thread_id: self.thread_id(), - turn_id: turn_id.to_owned(), - usage: usage.cloned(), - additional_budget_units: hook_units, - }) + .report_usage(usage_report) .await - .map_err(|error| { - CodexErr::UsageAccountingFailed(format!( - "Host usage accounting failed: {error}" - )) - })?; + .map_err(host_error)?; + if decision == UsageAccountingDecision::Exhausted { + self.work_budget().stop_new_work(); + } match decision { - UsageAccountingDecision::Continue => false, - UsageAccountingDecision::Exhausted => true, + UsageAccountingDecision::Continue | UsageAccountingDecision::Exhausted => { + Ok(()) + } UsageAccountingDecision::ExhaustedForTurn => { - return Err(CodexErr::SessionBudgetExceeded); + Err(CodexErr::SessionBudgetExceeded) } } } - }; - if stop_new_work { - self.work_budget().stop_new_work(); } - Ok(()) } }