use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
use tokio::sync::Semaphore;
use tokio_stream::StreamExt;
use crate::agent::{Agent, AgentEvent};
use crate::protocol::{Effort, Initialize, PermissionMode};
use crate::session::{Result, Session, SessionError, SessionOptions};
#[derive(Debug, Clone)]
pub struct PoolConfig {
pub max_sessions: usize,
pub options: SessionOptions,
}
impl Default for PoolConfig {
fn default() -> Self {
Self { max_sessions: 4, options: SessionOptions::default() }
}
}
#[derive(Debug, Clone, Default, PartialEq)]
pub struct Checkout {
pub model: Option<String>,
pub effort: Option<Effort>,
pub permission_mode: Option<PermissionMode>,
}
impl Checkout {
fn options(&self, base: &SessionOptions) -> SessionOptions {
SessionOptions {
model: self.model.clone().or_else(|| base.model.clone()),
effort: self.effort.or(base.effort),
permission_mode: self.permission_mode.or(base.permission_mode),
..base.clone()
}
}
}
struct Idle {
session: Session,
used: bool,
}
struct PoolInner {
idle: Mutex<Vec<Idle>>,
semaphore: Arc<Semaphore>,
config: PoolConfig,
}
#[derive(Clone)]
pub struct SessionPool(Arc<PoolInner>);
impl SessionPool {
#[must_use]
pub fn new(config: PoolConfig) -> Self {
let max = config.max_sessions;
SessionPool(Arc::new(PoolInner {
idle: Mutex::new(Vec::with_capacity(max)),
semaphore: Arc::new(Semaphore::new(max)),
config,
}))
}
pub async fn warm(&self, n: usize) -> usize {
let room = self.0.semaphore.available_permits().saturating_sub(self.idle().len());
let count = n.min(room);
let Ok(permits) = u32::try_from(count) else { return 0 };
let Ok(_permits) = Arc::clone(&self.0.semaphore).try_acquire_many_owned(permits) else {
return 0;
};
let tasks: Vec<_> = (0..count)
.map(|_| {
let opts = self.0.config.options.clone();
tokio::spawn(async move { Session::spawn(opts, Initialize::default()).await })
})
.collect();
let mut warmed = 0;
for t in tasks {
match t.await {
Ok(Ok(session)) => {
self.idle().push(Idle { session, used: false });
warmed += 1;
}
Ok(Err(e)) => tracing::warn!(error = %e, "pool warm-up spawn failed"),
Err(e) => tracing::warn!(error = %e, "pool warm-up task failed"),
}
}
warmed
}
pub async fn acquire(&self) -> Result<PooledSession> {
self.acquire_with(Checkout::default()).await
}
pub async fn acquire_with(&self, checkout: Checkout) -> Result<PooledSession> {
let permit = Arc::clone(&self.0.semaphore)
.acquire_owned()
.await
.map_err(|_| SessionError::Closed)?;
let options = checkout.options(&self.0.config.options);
loop {
let next = self.idle().pop();
let Some(Idle { session, used }) = next else { break };
if !session.is_alive() {
continue;
}
let prepared = match (used, checkout == Checkout::default()) {
(false, true) => Ok(()),
(false, false) => apply(&session, &options).await,
(true, _) => reset(&session, &options).await,
};
if let Err(e) = prepared {
tracing::warn!(error = %e, "pooled session reset failed; replacing it");
session.close().await;
continue;
}
return Ok(PooledSession { session, pool: self.clone(), _permit: permit });
}
let session = Session::spawn(options, Initialize::default()).await?;
Ok(PooledSession { session, pool: self.clone(), _permit: permit })
}
fn idle(&self) -> MutexGuard<'_, Vec<Idle>> {
self.0.idle.lock().unwrap_or_else(PoisonError::into_inner)
}
}
const RESET_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
async fn reset(session: &Session, options: &SessionOptions) -> std::result::Result<(), String> {
let run = async {
let mut stream = Agent::new(session.clone()).prompt("/clear").await.map_err(|e| e.to_string())?;
loop {
match stream.next().await {
Some(AgentEvent::Done(_)) => break,
Some(AgentEvent::Error(e)) => return Err(e.to_string()),
Some(_) => {}
None => return Err("stream ended without a result".to_string()),
}
}
apply(session, options).await
};
tokio::time::timeout(RESET_TIMEOUT, run).await.unwrap_or_else(|_| Err("reset timed out".into()))
}
async fn apply(session: &Session, options: &SessionOptions) -> std::result::Result<(), String> {
session.set_model(options.model.as_deref()).await.map_err(|e| e.to_string())?;
session.set_effort(options.effort).await.map_err(|e| e.to_string())?;
let mode = options.permission_mode.unwrap_or(PermissionMode::Default);
session.set_permission_mode(mode).await.map_err(|e| e.to_string())
}
pub struct PooledSession {
pub session: Session,
pool: SessionPool,
_permit: tokio::sync::OwnedSemaphorePermit,
}
impl std::ops::Deref for PooledSession {
type Target = Session;
fn deref(&self) -> &Self::Target {
&self.session
}
}
impl Drop for PooledSession {
fn drop(&mut self) {
if self.session.is_alive() && !self.session.is_busy() {
self.pool.idle().push(Idle { session: self.session.clone(), used: true });
}
}
}