core: start idle turns without reservations

This commit is contained in:
pakrym-oai
2026-05-26 19:08:46 -07:00
parent 0d37db4b2b
commit cacb192556
6 changed files with 145 additions and 171 deletions
+11 -50
View File
@@ -10,8 +10,6 @@ use crate::context::GoalContext;
use crate::session::TurnInput;
use crate::session::session::Session;
use crate::session::turn_context::TurnContext;
use crate::state::ActiveTurn;
use crate::state::TurnState;
use crate::tasks::RegularTask;
use crate::tools::handlers::goal_spec::UPDATE_GOAL_TOOL_NAME;
use anyhow::Context;
@@ -898,16 +896,6 @@ impl Session {
}
}
async fn clear_reserved_goal_continuation_turn(&self, turn_state: &Arc<Mutex<TurnState>>) {
let mut active_turn_guard = self.active_turn.lock().await;
if let Some(active_turn) = active_turn_guard.as_ref()
&& active_turn.task.is_none()
&& Arc::ptr_eq(&active_turn.turn_state, turn_state)
{
*active_turn_guard = None;
}
}
async fn finish_thread_goal_turn(
self: &Arc<Self>,
turn_context: &TurnContext,
@@ -1281,14 +1269,6 @@ impl Session {
return;
};
let turn_state = {
let mut active_turn = self.active_turn.lock().await;
if active_turn.is_some() {
return;
}
let active_turn = active_turn.get_or_insert_with(ActiveTurn::default);
Arc::clone(&active_turn.turn_state)
};
let goal_is_current = match self.state_db_for_thread_goals().await {
Ok(Some(state_db)) => match state_db
.thread_goals()
@@ -1322,39 +1302,20 @@ impl Session {
}
};
if !goal_is_current {
self.clear_reserved_goal_continuation_turn(&turn_state)
.await;
return;
}
self.input_queue
.extend_pending_input_for_turn_state(
turn_state.as_ref(),
candidate
.items
.into_iter()
.map(TurnInput::ResponseInputItem)
.collect(),
)
.await;
let turn_context = self
.new_default_turn_with_sub_id(uuid::Uuid::new_v4().to_string())
.await;
self.maybe_emit_unknown_model_warning_for_turn(turn_context.as_ref())
.await;
let still_reserved = {
let active_turn = self.active_turn.lock().await;
active_turn.as_ref().is_some_and(|active_turn| {
active_turn.task.is_none() && Arc::ptr_eq(&active_turn.turn_state, &turn_state)
})
};
if !still_reserved {
self.clear_reserved_goal_continuation_turn(&turn_state)
.await;
return;
}
self.start_task(turn_context, Vec::new(), RegularTask::new())
.await;
let turn_context = self.new_default_turn().await;
self.try_start_turn_if_idle(
turn_context,
candidate
.items
.into_iter()
.map(TurnInput::ResponseInputItem)
.collect(),
RegularTask::new(),
)
.await;
}
async fn goal_continuation_candidate_if_active(
+5 -7
View File
@@ -260,7 +260,7 @@ pub(super) async fn user_input_or_turn_inner(
if !items.is_empty() {
task_input.push(TurnInput::UserInput(items));
}
sess.spawn_task(
sess.replace_turn(
Arc::clone(&current_context),
task_input,
crate::tasks::RegularTask::new(),
@@ -308,7 +308,6 @@ async fn mirror_user_text_to_realtime(sess: &Arc<Session>, items: &[UserInput])
/// decide whether an idle session should start a regular turn.
pub async fn inter_agent_communication(
sess: &Arc<Session>,
sub_id: String,
communication: InterAgentCommunication,
) {
let trigger_turn = communication.trigger_turn;
@@ -316,8 +315,7 @@ pub async fn inter_agent_communication(
.enqueue_mailbox_communication(communication)
.await;
if trigger_turn {
sess.maybe_start_turn_for_pending_work_with_sub_id(sub_id)
.await;
sess.maybe_start_turn_for_pending_work().await;
}
}
@@ -340,7 +338,7 @@ pub async fn run_user_shell_command(sess: &Arc<Session>, sub_id: String, command
}
let turn_context = sess.new_default_turn_with_sub_id(sub_id).await;
sess.spawn_task(
sess.replace_turn(
Arc::clone(&turn_context),
Vec::new(),
UserShellCommandTask::new(command),
@@ -474,7 +472,7 @@ pub async fn reload_user_config(sess: &Arc<Session>) {
pub async fn compact(sess: &Arc<Session>, sub_id: String) {
let turn_context = sess.new_default_turn_with_sub_id(sub_id).await;
sess.spawn_task(Arc::clone(&turn_context), Vec::new(), CompactTask)
sess.replace_turn(Arc::clone(&turn_context), Vec::new(), CompactTask)
.await;
}
@@ -779,7 +777,7 @@ pub(super) async fn submission_loop(
false
}
Op::InterAgentCommunication { communication } => {
inter_agent_communication(&sess, sub.id.clone(), communication).await;
inter_agent_communication(&sess, communication).await;
false
}
Op::ExecApproval {
+2 -2
View File
@@ -144,10 +144,10 @@ pub(super) async fn spawn_review_thread(
}])];
let tc = Arc::new(review_turn_context);
tc.turn_metadata_state.spawn_git_enrichment_task();
// TODO(ccunningham): Review turns currently rely on `spawn_task` for TurnComplete but do not
// TODO(ccunningham): Review turns currently rely on `replace_turn` for TurnComplete but do not
// emit a parent TurnStarted. Consider giving review a full parent turn lifecycle
// (TurnStarted + TurnComplete) for consistency with other standalone tasks.
sess.spawn_task(tc.clone(), input, ReviewTask::new()).await;
sess.replace_turn(tc.clone(), input, ReviewTask).await;
// Announce entering review mode so UIs can switch modes.
let review_request = ReviewRequest {
+3
View File
@@ -31,6 +31,8 @@ pub(crate) struct Session {
pub(super) features: ManagedFeatures,
pub(super) pending_mcp_server_refresh_config: Mutex<Option<McpServerRefreshConfig>>,
pub(crate) conversation: Arc<RealtimeConversationManager>,
/// Serializes turn admission policy without representing idle work as an active turn.
pub(crate) turn_admission_lock: Mutex<()>,
pub(crate) active_turn: Mutex<Option<ActiveTurn>>,
pub(crate) input_queue: InputQueue,
pub(crate) goal_runtime: GoalRuntimeState,
@@ -1055,6 +1057,7 @@ impl Session {
features: config.features.clone(),
pending_mcp_server_refresh_config: Mutex::new(None),
conversation: Arc::new(RealtimeConversationManager::new()),
turn_admission_lock: Mutex::new(()),
active_turn: Mutex::new(None),
input_queue: InputQueue::new(),
goal_runtime: GoalRuntimeState::new(),
+31 -29
View File
@@ -299,7 +299,7 @@ async fn regular_turn_emits_turn_started_with_trace_id_without_waiting_for_start
),
)
.await;
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
crate::tasks::RegularTask::new(),
@@ -380,7 +380,7 @@ async fn interrupting_regular_turn_waiting_on_startup_prewarm_emits_turn_aborted
),
)
.await;
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
crate::tasks::RegularTask::new(),
@@ -2018,7 +2018,7 @@ async fn turn_start_lifecycle_exposes_turn_metadata_and_token_baseline() {
};
let sess = Arc::new(session);
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::new(turn_context),
Vec::new(),
NeverEndingTask {
@@ -4640,6 +4640,7 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {
features: config.features.clone(),
pending_mcp_server_refresh_config: Mutex::new(None),
conversation: Arc::new(RealtimeConversationManager::new()),
turn_admission_lock: Mutex::new(()),
active_turn: Mutex::new(None),
input_queue: super::input_queue::InputQueue::new(),
goal_runtime: crate::goals::GoalRuntimeState::new(),
@@ -5732,7 +5733,7 @@ async fn duplicate_turn_environment_returns_error_without_mutating_session() {
}
#[tokio::test]
async fn spawn_task_turn_span_inherits_dispatch_trace_context() {
async fn try_start_turn_if_idle_turn_span_inherits_dispatch_trace_context() {
struct TraceCaptureTask {
captured_trace: Arc<std::sync::Mutex<Option<W3cTraceContext>>>,
}
@@ -5790,7 +5791,7 @@ async fn spawn_task_turn_span_inherits_dispatch_trace_context() {
let captured_trace = Arc::new(std::sync::Mutex::new(None));
async {
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
vec![TurnInput::UserInput(vec![UserInput::Text {
text: "hello".to_string(),
@@ -5976,7 +5977,7 @@ async fn submission_loop_channel_close_aborts_active_turn_before_thread_stop_lif
let session = Arc::new(session);
session
.spawn_task(
.try_start_turn_if_idle(
Arc::new(turn_context),
Vec::new(),
NeverEndingTask {
@@ -6475,6 +6476,7 @@ where
features: config.features.clone(),
pending_mcp_server_refresh_config: Mutex::new(None),
conversation: Arc::new(RealtimeConversationManager::new()),
turn_admission_lock: Mutex::new(()),
active_turn: Mutex::new(None),
input_queue: super::input_queue::InputQueue::new(),
goal_runtime: crate::goals::GoalRuntimeState::new(),
@@ -6600,7 +6602,7 @@ async fn refresh_mcp_servers_is_deferred_until_next_turn() {
}
#[tokio::test]
async fn spawn_task_does_not_update_previous_turn_settings_for_non_run_turn_tasks() {
async fn try_start_turn_if_idle_does_not_update_previous_turn_settings_for_non_run_turn_tasks() {
let (sess, tc, _rx) = make_session_and_context_with_rx().await;
sess.set_previous_turn_settings(/*previous_turn_settings*/ None)
.await;
@@ -6609,7 +6611,7 @@ async fn spawn_task_does_not_update_previous_turn_settings_for_non_run_turn_task
text_elements: Vec::new(),
}])];
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
input,
NeverEndingTask {
@@ -7877,7 +7879,7 @@ async fn guardian_auto_review_interrupts_after_three_consecutive_denials() {
text: "trigger guardian denials".to_string(),
text_elements: Vec::new(),
}])];
sess.spawn_task(Arc::clone(&tc), input, GuardianDeniedApprovalTask)
sess.try_start_turn_if_idle(Arc::clone(&tc), input, GuardianDeniedApprovalTask)
.await;
let mut observed = Vec::new();
@@ -7908,7 +7910,7 @@ async fn guardian_helper_review_interrupts_after_three_consecutive_denials() {
text: "keep turn active for helper reviews".to_string(),
text_elements: Vec::new(),
}])];
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
input,
NeverEndingTask {
@@ -7968,7 +7970,7 @@ async fn abort_regular_task_emits_turn_aborted_only() {
text: "hello".to_string(),
text_elements: Vec::new(),
}])];
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
input,
NeverEndingTask {
@@ -8001,7 +8003,7 @@ async fn abort_gracefully_emits_turn_aborted_only() {
text: "hello".to_string(),
text_elements: Vec::new(),
}])];
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
input,
NeverEndingTask {
@@ -8034,7 +8036,7 @@ async fn task_finish_emits_turn_item_lifecycle_for_leftover_pending_user_input()
text: "hello".to_string(),
text_elements: Vec::new(),
}])];
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
input,
NeverEndingTask {
@@ -8171,7 +8173,7 @@ async fn steer_input_enforces_expected_turn_id() {
text: "hello".to_string(),
text_elements: Vec::new(),
}])];
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
input,
NeverEndingTask {
@@ -8218,7 +8220,7 @@ async fn steer_input_rejects_non_regular_turns() {
text_elements: Vec::new(),
}])];
let turn_context = sess.new_default_turn_with_sub_id("turn".to_string()).await;
sess.spawn_task(
sess.try_start_turn_if_idle(
turn_context,
input,
NeverEndingTask {
@@ -8255,7 +8257,7 @@ async fn steer_input_returns_active_turn_id() {
text: "hello".to_string(),
text_elements: Vec::new(),
}])];
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
input,
NeverEndingTask {
@@ -8298,7 +8300,7 @@ async fn queued_response_items_for_next_turn_move_into_next_active_turn() {
.queue_response_items_for_next_turn(vec![queued_item.clone()])
.await;
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
NeverEndingTask {
@@ -8385,7 +8387,7 @@ async fn interrupt_accounts_active_goal_without_pausing() -> anyhow::Result<()>
)
.await?;
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
NeverEndingTask {
@@ -8764,7 +8766,7 @@ async fn budget_limited_accounting_steers_active_turn_without_aborting() -> anyh
token_usage: TokenUsage::default(),
})
.await?;
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
NeverEndingTask {
@@ -8871,7 +8873,7 @@ async fn usage_limit_runtime_stops_active_goal_and_prevents_idle_continuation()
token_usage: TokenUsage::default(),
})
.await?;
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
NeverEndingTask {
@@ -8916,7 +8918,7 @@ async fn external_goal_mutation_accounts_active_turn_before_status_change() -> a
},
)
.await?;
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
NeverEndingTask {
@@ -8978,7 +8980,7 @@ async fn external_goal_mutation_accounts_active_turn_before_status_change() -> a
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn external_objective_change_steers_active_turn() -> anyhow::Result<()> {
let (sess, tc, _rx, _codex_home) = make_goal_session_and_context_with_rx().await;
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
NeverEndingTask {
@@ -9044,7 +9046,7 @@ async fn external_objective_change_steers_active_turn() -> anyhow::Result<()> {
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn external_active_goal_set_marks_current_turn_for_accounting() -> anyhow::Result<()> {
let (sess, tc, _rx, _codex_home) = make_goal_session_and_context_with_rx().await;
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
NeverEndingTask {
@@ -9215,7 +9217,7 @@ async fn queue_only_mailbox_mail_waits_for_next_turn_after_answer_boundary() {
"late queue-only update".to_string(),
/*trigger_turn*/ false,
);
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
NeverEndingTask {
@@ -9254,7 +9256,7 @@ async fn queue_only_mailbox_mail_waits_for_next_turn_after_answer_boundary() {
#[tokio::test]
async fn trigger_turn_mailbox_mail_waits_for_next_turn_after_answer_boundary() {
let (sess, tc, _rx) = make_session_and_context_with_rx().await;
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
NeverEndingTask {
@@ -9297,7 +9299,7 @@ async fn steered_input_reopens_mailbox_delivery_for_current_turn() {
"queued child update".to_string(),
/*trigger_turn*/ false,
);
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
NeverEndingTask {
@@ -9347,7 +9349,7 @@ async fn stale_defer_mailbox_delivery_does_not_override_steered_input() {
"queued child update".to_string(),
/*trigger_turn*/ false,
);
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
NeverEndingTask {
@@ -9401,7 +9403,7 @@ async fn tool_calls_reopen_mailbox_delivery_for_current_turn() {
"queued child update".to_string(),
/*trigger_turn*/ false,
);
sess.spawn_task(
sess.try_start_turn_if_idle(
Arc::clone(&tc),
Vec::new(),
NeverEndingTask {
@@ -9454,7 +9456,7 @@ async fn abort_review_task_emits_exited_then_aborted_and_records_history() {
text: "start review".to_string(),
text_elements: Vec::new(),
}])];
sess.spawn_task(Arc::clone(&tc), input, ReviewTask::new())
sess.try_start_turn_if_idle(Arc::clone(&tc), input, ReviewTask::new())
.await;
sess.abort_all_tasks(TurnAbortReason::Interrupted).await;
+93 -83
View File
@@ -33,6 +33,7 @@ use crate::session::turn_context::TurnContext;
use crate::state::ActiveTurn;
use crate::state::RunningTask;
use crate::state::TaskKind;
use crate::state::TurnState;
use codex_analytics::TurnTokenUsageFact;
use codex_login::AuthManager;
use codex_models_manager::manager::SharedModelsManager;
@@ -299,26 +300,30 @@ where
}
impl Session {
pub async fn spawn_task<T: SessionTask>(
pub(crate) async fn replace_turn(
self: &Arc<Self>,
turn_context: Arc<TurnContext>,
input: Vec<TurnInput>,
task: T,
task: impl SessionTask,
) {
let _admission = self.turn_admission_lock.lock().await;
self.abort_all_tasks(TurnAbortReason::Replaced).await;
self.clear_connector_selection().await;
self.start_task(turn_context, input, task).await;
let mut active = self.active_turn.lock().await;
debug_assert!(active.is_none());
*active = Some(self.start_turn(turn_context, input, task));
}
pub(crate) async fn start_task<T: SessionTask>(
self: &Arc<Self>,
async fn run_turn(
self: Arc<Self>,
turn_context: Arc<TurnContext>,
input: Vec<TurnInput>,
task: T,
turn_state: Arc<tokio::sync::Mutex<TurnState>>,
task_for_run: Arc<dyn AnySessionTask>,
session_ctx: Arc<SessionTaskContext>,
task_input: Vec<TurnInput>,
task_cancellation_token: CancellationToken,
done_clone: Arc<Notify>,
) {
let task: Arc<dyn AnySessionTask> = Arc::new(task);
let task_kind = task.kind();
let span_name = task.span_name();
let started_at = Instant::now();
let turn_started_at_unix_ms = turn_context
.turn_timing_state
@@ -329,9 +334,6 @@ impl Session {
.set_turn_started_at_unix_ms(turn_started_at_unix_ms);
let token_usage_at_turn_start = self.total_token_usage().await.unwrap_or_default();
let cancellation_token = CancellationToken::new();
let done = Arc::new(Notify::new());
self.services
.guardian_rejection_circuit_breaker
.lock()
@@ -352,12 +354,6 @@ impl Session {
.take_queued_response_items_for_next_turn()
.await;
let mailbox_items = self.input_queue.get_pending_input(&self.active_turn).await;
let turn_state = {
let mut active = self.active_turn.lock().await;
let turn = active.get_or_insert_with(ActiveTurn::default);
debug_assert!(turn.task.is_none());
Arc::clone(&turn.turn_state)
};
turn_state.lock().await.token_usage_at_turn_start = token_usage_at_turn_start.clone();
let mut pending_items = queued_response_items
.into_iter()
@@ -369,17 +365,60 @@ impl Session {
.await;
self.emit_turn_start_lifecycle(turn_context.as_ref(), &token_usage_at_turn_start)
.await;
if task_cancellation_token.is_cancelled() {
done_clone.notify_waiters();
return;
}
let ctx = turn_context;
let ctx_for_finish = Arc::clone(&ctx);
let last_agent_message = task_for_run
.run(
Arc::clone(&session_ctx),
ctx,
task_input,
task_cancellation_token.child_token(),
)
.await;
let sess = session_ctx.clone_session();
if let Err(err) = sess.flush_rollout().await {
warn!("failed to flush rollout before completing turn: {err}");
sess.send_event(
ctx_for_finish.as_ref(),
EventMsg::Warning(WarningEvent {
message: format!(
"Failed to save the conversation transcript; Codex will continue retrying. Error: {err}"
),
}),
)
.await;
}
if !task_cancellation_token.is_cancelled() {
// Emit completion uniformly from spawn site so all tasks share the same lifecycle.
sess.on_task_finished(Arc::clone(&ctx_for_finish), last_agent_message)
.await;
}
done_clone.notify_waiters();
}
fn start_turn(
self: &Arc<Self>,
turn_context: Arc<TurnContext>,
input: Vec<TurnInput>,
task: impl SessionTask,
) -> ActiveTurn {
let task: Arc<dyn AnySessionTask> = Arc::new(task);
let task_kind = task.kind();
let span_name = task.span_name();
let cancellation_token = CancellationToken::new();
let done = Arc::new(Notify::new());
let turn_state = Arc::new(tokio::sync::Mutex::new(TurnState::default()));
let turn_extension_data = Arc::clone(&turn_context.extension_data);
let mut active = self.active_turn.lock().await;
let turn = active.get_or_insert_with(ActiveTurn::default);
debug_assert!(turn.task.is_none());
let done_clone = Arc::clone(&done);
let session_ctx = Arc::new(SessionTaskContext::new(
Arc::clone(self),
Arc::clone(&turn_extension_data),
));
let ctx = Arc::clone(&turn_context);
let task_for_run = Arc::clone(&task);
let task_input = input;
let task_cancellation_token = cancellation_token.child_token();
@@ -401,37 +440,17 @@ impl Session {
codex.turn.token_usage.total_tokens = field::Empty,
);
let handle = tokio::spawn(
async move {
let ctx_for_finish = Arc::clone(&ctx);
let last_agent_message = task_for_run
.run(
Arc::clone(&session_ctx),
ctx,
task_input,
task_cancellation_token.child_token(),
)
.await;
let sess = session_ctx.clone_session();
if let Err(err) = sess.flush_rollout().await {
warn!("failed to flush rollout before completing turn: {err}");
sess.send_event(
ctx_for_finish.as_ref(),
EventMsg::Warning(WarningEvent {
message: format!(
"Failed to save the conversation transcript; Codex will continue retrying. Error: {err}"
),
}),
)
.await;
}
if !task_cancellation_token.is_cancelled() {
// Emit completion uniformly from spawn site so all tasks share the same lifecycle.
sess.on_task_finished(Arc::clone(&ctx_for_finish), last_agent_message)
.await;
}
done_clone.notify_waiters();
}
.instrument(task_span),
Arc::clone(self)
.run_turn(
Arc::clone(&turn_context),
Arc::clone(&turn_state),
task_for_run,
session_ctx,
task_input,
task_cancellation_token,
done_clone,
)
.instrument(task_span),
);
let timer = turn_context
.session_telemetry
@@ -447,30 +466,31 @@ impl Session {
turn_extension_data,
_timer: timer,
};
turn.task = Some(running_task);
ActiveTurn {
task: Some(running_task),
turn_state,
}
}
/// Starts a regular turn when the session is idle and pending work is waiting.
///
/// Pending work currently includes queued next-turn items and mailbox mail marked with
/// `trigger_turn`.
///
/// This helper generates a fresh sub-id for the synthetic turn before delegating to the
/// explicit-sub-id variant.
pub(crate) async fn maybe_start_turn_for_pending_work(self: &Arc<Self>) {
self.maybe_start_turn_for_pending_work_with_sub_id(uuid::Uuid::new_v4().to_string())
.await;
pub(crate) async fn try_start_turn_if_idle(
self: &Arc<Self>,
turn_context: Arc<TurnContext>,
input: Vec<TurnInput>,
task: impl SessionTask,
) {
let _admission = self.turn_admission_lock.lock().await;
let mut active = self.active_turn.lock().await;
if active.is_some() {
return;
}
*active = Some(self.start_turn(turn_context, input, task));
}
/// Starts a regular turn with the provided sub-id when pending work should wake an idle
/// session.
/// Starts a regular turn when pending work should wake an idle session.
///
/// The turn is created only when there are queued next-turn items or mailbox mail marked with
/// `trigger_turn`, and only if the session is currently idle.
pub(crate) async fn maybe_start_turn_for_pending_work_with_sub_id(
self: &Arc<Self>,
sub_id: String,
) {
pub(crate) async fn maybe_start_turn_for_pending_work(self: &Arc<Self>) {
if !self
.input_queue
.has_queued_response_items_for_next_turn()
@@ -480,18 +500,8 @@ impl Session {
return;
}
{
let mut active_turn = self.active_turn.lock().await;
if active_turn.is_some() {
return;
}
*active_turn = Some(ActiveTurn::default());
}
let turn_context = self.new_default_turn_with_sub_id(sub_id).await;
self.maybe_emit_unknown_model_warning_for_turn(turn_context.as_ref())
.await;
self.start_task(turn_context, Vec::new(), RegularTask::new())
let turn_context = self.new_default_turn().await;
self.try_start_turn_if_idle(turn_context, Vec::new(), RegularTask::new())
.await;
}