use std::collections::{HashMap, VecDeque};
use crate::approval::ApprovalRouter;
use crate::msp::ApprovalRequestParams;
#[derive(Default)]
pub(super) struct PendingApprovals {
tracked: HashMap<String, TrackedApproval>,
queue: VecDeque<String>,
}
pub(super) struct TrackedApproval {
pub(super) request: ApprovalRequestParams,
routed_stage: usize,
pub(super) answered: Option<usize>,
queued: Option<QueuedStage>,
}
struct QueuedStage {
request: ApprovalRequestParams,
router: ApprovalRouter,
}
impl TrackedApproval {
pub(super) fn routed_stage(&self) -> usize {
self.routed_stage
}
}
impl PendingApprovals {
pub(super) fn len(&self) -> usize {
self.tracked.len()
}
pub(super) fn get(&self, approval_id: &str) -> Option<&TrackedApproval> {
self.tracked.get(approval_id)
}
pub(super) fn get_mut(&mut self, approval_id: &str) -> Option<&mut TrackedApproval> {
self.tracked.get_mut(approval_id)
}
pub(super) fn route_stage(&mut self, request: ApprovalRequestParams, router: ApprovalRouter) {
let stage = request.current_requirement_id.source_index;
let tracked = self
.tracked
.entry(request.approval_id.clone())
.or_insert_with(|| TrackedApproval {
request: request.clone(),
routed_stage: stage,
answered: None,
queued: None,
});
tracked.request = request.clone();
tracked.routed_stage = stage;
let approval_id = request.approval_id.clone();
if tracked
.queued
.replace(QueuedStage { request, router })
.is_some()
{
self.queue.retain(|queued| *queued != approval_id);
}
self.queue.push_back(approval_id);
}
pub(super) fn remove(
&mut self,
approval_id: &str,
) -> Option<(TrackedApproval, Option<ApprovalRequestParams>)> {
let mut tracked = self.tracked.remove(approval_id)?;
let queued = tracked.queued.take().map(|queued| queued.request);
if queued.is_some() {
self.queue.retain(|queued| queued != approval_id);
}
Some((tracked, queued))
}
pub(super) fn clear(&mut self) {
self.tracked.clear();
self.queue.clear();
}
pub(super) fn take_queued(&mut self) -> Option<(ApprovalRequestParams, ApprovalRouter)> {
let approval_id = self.queue.pop_front()?;
let queued = self.tracked.get_mut(&approval_id)?.queued.take()?;
Some((queued.request, queued.router))
}
}
#[cfg(test)]
mod tests {
use super::{ApprovalRequestParams, ApprovalRouter, PendingApprovals, TrackedApproval};
fn request(approval_id: &str, stage: usize) -> Result<ApprovalRequestParams, String> {
serde_json::from_value(serde_json::json!({
"sessionId": "session-1",
"approvalId": approval_id,
"turnId": "turn-1",
"taskId": "task-1",
"itemId": "item-1",
"toolCallId": "call-1",
"toolName": "shell",
"rawArgs": "{}",
"viewCursor": "cursor-1",
"sourceRange": {
"stream": {"kind": "run", "id": "turn-1"},
"first": {"id": "event-1", "sequence": 1},
"last": {"id": "event-1", "sequence": 1}
},
"subject": {"kind": "shell", "command": "pwd"},
"currentRequirementId": {"approvalId": approval_id, "sourceIndex": stage},
"availableChoices": [],
"protectedWrite": false,
"judgeEscalated": false
}))
.map_err(|error| error.to_string())
}
#[test]
fn the_queue_holds_each_tracked_approval_once() -> Result<(), String> {
let mut pending = PendingApprovals::default();
pending.route_stage(request("approval-1", 0)?, ApprovalRouter::new());
pending.route_stage(request("approval-2", 0)?, ApprovalRouter::new());
pending.route_stage(request("approval-1", 1)?, ApprovalRouter::new());
assert_eq!(
pending.get("approval-1").map(TrackedApproval::routed_stage),
Some(1)
);
if let Some(tracked) = pending.get_mut("approval-1") {
tracked.request = request("approval-1", 2)?;
}
assert_eq!(pending.queue.len(), 2);
let taken: Vec<(String, usize)> = std::iter::from_fn(|| pending.take_queued())
.map(|(request, _)| {
(
request.approval_id,
request.current_requirement_id.source_index,
)
})
.collect();
assert_eq!(
taken,
[("approval-2".to_owned(), 0), ("approval-1".to_owned(), 1)]
);
pending.route_stage(request("approval-2", 1)?, ApprovalRouter::new());
let left = pending.remove("approval-2").and_then(|(_, queued)| queued);
assert_eq!(
left.map(|request| request.current_requirement_id.source_index),
Some(1)
);
assert!(pending.queue.is_empty());
assert!(pending.take_queued().is_none());
pending.route_stage(request("approval-1", 2)?, ApprovalRouter::new());
assert_eq!(pending.queue.len(), 1);
pending.clear();
assert!(pending.queue.is_empty());
assert_eq!(pending.len(), 0);
Ok(())
}
}