mirror of
https://github.com/openai/codex.git
synced 2026-11-18 22:20:48 +00:00
Default loop alarms to idle recurrence
This commit is contained in:
@@ -48,6 +48,16 @@ impl AlarmTrigger {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn is_idle_recurring(&self) -> bool {
|
||||
matches!(
|
||||
self,
|
||||
Self::Delay {
|
||||
seconds: 0,
|
||||
repeat: Some(true),
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn display(&self) -> String {
|
||||
match self {
|
||||
Self::Delay { seconds, repeat } => {
|
||||
@@ -115,7 +125,7 @@ fn timing_for_new_trigger_with_timezone(
|
||||
AlarmTrigger::Delay { seconds, repeat } => {
|
||||
let repeat = repeat.unwrap_or(false);
|
||||
if repeat && *seconds == 0 {
|
||||
return Err("delay.repeat requires seconds to be greater than 0".to_string());
|
||||
return Ok(timing(normalized, /*pending_run*/ true, None, now));
|
||||
}
|
||||
let next_run_at = checked_add_seconds(created_at, *seconds)?;
|
||||
let pending_run = next_run_at <= now;
|
||||
@@ -170,7 +180,7 @@ fn timing_for_restored_trigger_with_timezone(
|
||||
AlarmTrigger::Delay { seconds, repeat } => {
|
||||
let repeat = repeat.unwrap_or(false);
|
||||
if repeat && *seconds == 0 {
|
||||
return Err("delay.repeat requires seconds to be greater than 0".to_string());
|
||||
return Ok(timing(normalized, /*pending_run*/ true, None, now));
|
||||
}
|
||||
let next_run_at = persisted_next_run_at
|
||||
.or_else(|| next_delay_run_at(created_at, *seconds))
|
||||
@@ -221,6 +231,9 @@ fn next_run_after_due_with_timezone(
|
||||
match trigger {
|
||||
AlarmTrigger::Delay { seconds, repeat } => {
|
||||
if repeat.unwrap_or(false) {
|
||||
if *seconds == 0 {
|
||||
return Ok(None);
|
||||
}
|
||||
next_delay_recurring_run_at_from_timestamp(created_at, *seconds, now)
|
||||
} else {
|
||||
Ok(None)
|
||||
@@ -239,12 +252,7 @@ fn normalize_trigger(
|
||||
timezone: Tz,
|
||||
) -> Result<AlarmTrigger, String> {
|
||||
match trigger {
|
||||
AlarmTrigger::Delay { seconds, repeat } => {
|
||||
if repeat.unwrap_or(false) && seconds == 0 {
|
||||
return Err("delay.repeat requires seconds to be greater than 0".to_string());
|
||||
}
|
||||
Ok(AlarmTrigger::Delay { seconds, repeat })
|
||||
}
|
||||
AlarmTrigger::Delay { seconds, repeat } => Ok(AlarmTrigger::Delay { seconds, repeat }),
|
||||
AlarmTrigger::Schedule { dtstart, rrule } => {
|
||||
let dtstart = normalize_optional_string(dtstart);
|
||||
let rrule = normalize_optional_string(rrule);
|
||||
@@ -480,19 +488,41 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delay_repeat_rejects_zero_seconds() {
|
||||
fn delay_repeat_zero_is_idle_recurring() {
|
||||
let timing = timing_for_new_trigger_with_timezone(
|
||||
AlarmTrigger::Delay {
|
||||
seconds: 0,
|
||||
repeat: Some(true),
|
||||
},
|
||||
utc(TS_100),
|
||||
utc(TS_100),
|
||||
Tz::UTC,
|
||||
)
|
||||
.expect("zero repeat should be a valid idle-recurring trigger");
|
||||
assert_eq!(
|
||||
timing_for_new_trigger_with_timezone(
|
||||
AlarmTrigger::Delay {
|
||||
timing,
|
||||
TriggerTiming {
|
||||
trigger: AlarmTrigger::Delay {
|
||||
seconds: 0,
|
||||
repeat: Some(true),
|
||||
},
|
||||
utc(TS_100),
|
||||
pending_run: true,
|
||||
next_run_at: None,
|
||||
timer_delay: None,
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
next_run_after_due_with_timezone(
|
||||
&AlarmTrigger::Delay {
|
||||
seconds: 0,
|
||||
repeat: Some(true),
|
||||
},
|
||||
/*created_at*/ 100,
|
||||
utc(TS_100),
|
||||
Tz::UTC,
|
||||
)
|
||||
.expect_err("zero repeat should be invalid"),
|
||||
"delay.repeat requires seconds to be greater than 0"
|
||||
.expect("zero repeat should remain timer-free"),
|
||||
None
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@@ -291,6 +291,12 @@ impl AlarmsState {
|
||||
.values()
|
||||
.filter(|runtime| runtime.pending_run)
|
||||
.filter_map(|runtime| {
|
||||
if runtime.alarm.trigger.is_idle_recurring() {
|
||||
if can_after_turn {
|
||||
return Some((runtime, AlarmDelivery::AfterTurn));
|
||||
}
|
||||
return None;
|
||||
}
|
||||
let actual_delivery = match runtime.alarm.delivery {
|
||||
AlarmDelivery::AfterTurn if can_after_turn => AlarmDelivery::AfterTurn,
|
||||
AlarmDelivery::AfterTurn => return None,
|
||||
@@ -326,11 +332,12 @@ impl AlarmsState {
|
||||
}
|
||||
} else {
|
||||
alarm.last_run_at = Some(now.timestamp());
|
||||
let pending_run = alarm.trigger.is_idle_recurring();
|
||||
self.alarms.insert(
|
||||
alarm.id.clone(),
|
||||
AlarmRuntime {
|
||||
alarm: alarm.clone(),
|
||||
pending_run: false,
|
||||
pending_run,
|
||||
timer_cancel,
|
||||
},
|
||||
);
|
||||
@@ -486,6 +493,7 @@ mod tests {
|
||||
use super::CreateAlarm;
|
||||
use super::MAX_ACTIVE_ALARMS_PER_THREAD;
|
||||
use super::PersistedAlarm;
|
||||
use super::ThreadAlarm;
|
||||
use super::alarm_prompt_input_item;
|
||||
use super::alarm_sidecar_path_for_rollout;
|
||||
use super::load_alarm_sidecar;
|
||||
@@ -588,6 +596,73 @@ mod tests {
|
||||
assert_eq!(second.context.current_alarm_id, "alarm-2");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn idle_recurring_alarm_remains_pending_after_claim() {
|
||||
let now = Utc.timestamp_opt(100, 0).single().expect("valid timestamp");
|
||||
let mut alarms = AlarmsState::default();
|
||||
let (alarm, timer_spec) = alarms
|
||||
.create_alarm(
|
||||
CreateAlarm {
|
||||
id: "alarm-1".to_string(),
|
||||
trigger: delay(ZERO_SECONDS, Some(true)),
|
||||
prompt: "keep going".to_string(),
|
||||
delivery: AlarmDelivery::AfterTurn,
|
||||
now,
|
||||
},
|
||||
/*timer_cancel*/ None,
|
||||
)
|
||||
.expect("alarm should be created");
|
||||
assert_eq!(timer_spec, None);
|
||||
|
||||
let claimed = alarms
|
||||
.claim_next_alarm(
|
||||
now, /*can_after_turn*/ true, /*can_steer_current_turn*/ true,
|
||||
)
|
||||
.expect("alarm should be claimed");
|
||||
assert!(!claimed.deleted_one_shot_alarm);
|
||||
assert_eq!(
|
||||
alarms.persisted_alarms(),
|
||||
vec![PersistedAlarm {
|
||||
alarm: ThreadAlarm {
|
||||
last_run_at: Some(100),
|
||||
..alarm
|
||||
},
|
||||
pending_run: true,
|
||||
}]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn idle_recurring_alarm_waits_for_idle_even_if_delivery_requests_steer() {
|
||||
let now = Utc.timestamp_opt(100, 0).single().expect("valid timestamp");
|
||||
let mut alarms = AlarmsState::default();
|
||||
alarms
|
||||
.create_alarm(
|
||||
CreateAlarm {
|
||||
id: "alarm-1".to_string(),
|
||||
trigger: delay(ZERO_SECONDS, Some(true)),
|
||||
prompt: "keep going".to_string(),
|
||||
delivery: AlarmDelivery::SteerCurrentTurn,
|
||||
now,
|
||||
},
|
||||
/*timer_cancel*/ None,
|
||||
)
|
||||
.expect("alarm should be created");
|
||||
|
||||
assert_eq!(
|
||||
alarms.claim_next_alarm(
|
||||
now, /*can_after_turn*/ false, /*can_steer_current_turn*/ true,
|
||||
),
|
||||
None
|
||||
);
|
||||
let claimed = alarms
|
||||
.claim_next_alarm(
|
||||
now, /*can_after_turn*/ true, /*can_steer_current_turn*/ false,
|
||||
)
|
||||
.expect("alarm should be claimed when idle");
|
||||
assert_eq!(claimed.context.delivery, AlarmDelivery::AfterTurn);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn create_alarm_rejects_more_than_maximum_active_alarms() {
|
||||
let now = Utc.timestamp_opt(100, 0).single().expect("valid timestamp");
|
||||
|
||||
Reference in New Issue
Block a user