mirror of
https://github.com/pchuan98/codex.git
synced 2026-07-01 00:31:56 +08:00
rka-oai
dac588f413
## Stack Depends on #28494. ## Description This PR propagates shared rollout-budget exhaustion through the existing `CodexErr::TurnAborted` task result. Each thread records its model usage against the same ledger. Once the ledger is exhausted, that usage update and all later usage updates return `TurnAborted`. The task wrapper emits the normal aborted-turn event and lifecycle instead of completing the turn. This is intentionally a soft boundary: there is no cross-thread `Op::Interrupt` fanout. An in-flight thread can finish its current response before it observes the exhausted ledger, but every thread aborts at its next usage-accounting boundary. ## Tests The integration coverage verifies that: - the response that exhausts the budget aborts its turn; - a later response also aborts because the shared ledger remains exhausted; and - sub-agent usage draws from the same shared ledger; and - local and remote-v2 compaction abort without retrying or emitting a generic error. Local checks: - `just test -p codex-core exhausted_budget_aborts_current_and_later_turns` - `just test -p codex-core subagent_usage_draws_from_the_shared_budget` - `just test -p codex-core abort_regular_task_emits_marker_before_turn_aborted` - `just test -p codex-core compaction_budget_exhaustion_aborts_without_error_or_retry` - `just fix -p codex-core` - `just fmt` - `git diff --check` The full workspace test suite was not run locally.
78 lines
2.5 KiB
Rust
78 lines
2.5 KiB
Rust
use std::sync::Arc;
|
|
|
|
use super::SessionTask;
|
|
use super::SessionTaskContext;
|
|
use super::SessionTaskResult;
|
|
use super::emit_compact_metric;
|
|
use crate::session::TurnInput;
|
|
use crate::session::turn_context::TurnContext;
|
|
use crate::state::TaskKind;
|
|
use codex_protocol::error::CodexErr;
|
|
use codex_protocol::user_input::UserInput;
|
|
use tokio_util::sync::CancellationToken;
|
|
|
|
#[derive(Clone, Copy, Default)]
|
|
pub(crate) struct CompactTask;
|
|
|
|
impl SessionTask for CompactTask {
|
|
fn kind(&self) -> TaskKind {
|
|
TaskKind::Compact
|
|
}
|
|
|
|
fn span_name(&self) -> &'static str {
|
|
"session_task.compact"
|
|
}
|
|
|
|
async fn run(
|
|
self: Arc<Self>,
|
|
session: Arc<SessionTaskContext>,
|
|
ctx: Arc<TurnContext>,
|
|
_input: Vec<TurnInput>,
|
|
_cancellation_token: CancellationToken,
|
|
) -> SessionTaskResult {
|
|
let session = session.clone_session();
|
|
let result = if crate::compact::should_use_remote_compact_task(ctx.provider.info()) {
|
|
if ctx
|
|
.config
|
|
.features
|
|
.enabled(codex_features::Feature::RemoteCompactionV2)
|
|
{
|
|
emit_compact_metric(
|
|
&session.services.session_telemetry,
|
|
"remote_v2",
|
|
/*manual*/ true,
|
|
);
|
|
crate::compact_remote_v2::run_remote_compact_task(session.clone(), ctx).await
|
|
} else {
|
|
emit_compact_metric(
|
|
&session.services.session_telemetry,
|
|
"remote",
|
|
/*manual*/ true,
|
|
);
|
|
crate::compact_remote::run_remote_compact_task(session.clone(), ctx).await
|
|
}
|
|
} else {
|
|
emit_compact_metric(
|
|
&session.services.session_telemetry,
|
|
"local",
|
|
/*manual*/ true,
|
|
);
|
|
let input = vec![UserInput::Text {
|
|
text: ctx
|
|
.config
|
|
.compact_prompt
|
|
.as_deref()
|
|
.unwrap_or(crate::compact::SUMMARIZATION_PROMPT)
|
|
.to_string(),
|
|
// Compaction prompt is synthesized; no UI element ranges to preserve.
|
|
text_elements: Vec::new(),
|
|
}];
|
|
crate::compact::run_compact_task(session.clone(), ctx, input).await
|
|
};
|
|
if let Err(err @ CodexErr::TurnAborted) = result {
|
|
return Err(err);
|
|
}
|
|
Ok(None)
|
|
}
|
|
}
|