Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

6.1 KB
Raw Blame
//! Warm lifecycle is independent of list visibility. Conversation reservations
//! are excluded defensively, including contexts reserved before runtime startup.
use super::*;

#[cfg(test)]
mod test;
use crate::domain::warm::{WarmClaim, WarmMissReason, WarmSessionLifecycle};
use std::{future::Future, pin::Pin};

impl<B: BotFacts + 'static> WarmSessionLifecycle for PgAgentSessionRepo<B> {
    fn claim<'a>(
        &'a self,
        id: AgentSessionId,
        owner: &'a Owner,
        bot: BotId,
        model: &'a str,
        instructions: Option<&'a str>,
        origin: &'a trigger_context::TriggerOrigin,
    ) -> Pin<Box<dyn Future<Output = Result<WarmClaim>> + Send + 'a>> {
        Box::pin(async move {
            let user = session_owner_user(owner)?;
            let mut transaction = self.pool.begin().await.context("begin warm claim")?;
            // One statement: the snapshot that explains a miss is the one the claim ran against.
            let row = sqlx::query!(
                r#"
                WITH candidate AS (
                    SELECT
                        true AS found,
                        for_warming AND visibility = 'hidden' AND thread_id IS NULL AND NOT EXISTS (
                            SELECT 1 FROM agent_conversation_sessions c WHERE c.session_id = agent_session.id
                        ) AS warm,
                        owner_id = $2 AS owner_matches,
                        bot_id = $3 AS bot_matches,
                        model = $4 AS model_matches,
                        instructions IS NOT DISTINCT FROM $5 AS instructions_match,
                        COALESCE(status != 'disconnected'
                            AND NOT (status = 'event' AND status_event_name = 'disconnected'), false) AS live,
                        created_at > NOW() - INTERVAL '10 minutes' AS fresh
                    FROM agent_session WHERE id = $1
                ), claimed AS (
                    UPDATE agent_session SET visibility = 'listed', for_warming = false
                    WHERE id = $1 AND owner_id = $2 AND bot_id = $3 AND model = $4
                      AND instructions IS NOT DISTINCT FROM $5
                      AND for_warming AND visibility = 'hidden' AND thread_id IS NULL
                      AND NOT EXISTS (SELECT 1 FROM agent_conversation_sessions c WHERE c.session_id = agent_session.id)
                      AND status != 'disconnected'
                      AND NOT (status = 'event' AND status_event_name = 'disconnected')
                      AND created_at > NOW() - INTERVAL '10 minutes'
                    RETURNING id
                )
                SELECT
                    EXISTS (SELECT 1 FROM claimed) AS "claimed!",
                    candidate.found AS "found?",
                    candidate.warm AS "warm?",
                    candidate.owner_matches AS "owner_matches?",
                    candidate.bot_matches AS "bot_matches?",
                    candidate.model_matches AS "model_matches?",
                    candidate.instructions_match AS "instructions_match?",
                    candidate.live AS "live?",
                    candidate.fresh AS "fresh?"
                FROM (SELECT 1) AS one LEFT JOIN candidate ON true
            "#,
                id.as_uuid(),
                user.as_ref(),
                bot.as_uuid(),
                model,
                instructions
            )
            .fetch_one(&mut *transaction)
            .await
            .context("claim warm session")?;
            let checks = [
                (row.warm, WarmMissReason::NotWarm),
                (row.owner_matches, WarmMissReason::OwnerMismatch),
                (row.bot_matches, WarmMissReason::BotMismatch),
                (row.model_matches, WarmMissReason::ModelMismatch),
                (row.instructions_match, WarmMissReason::InstructionsMismatch),
                (row.live, WarmMissReason::Disconnected),
                (row.fresh, WarmMissReason::Expired),
            ];
            let claim = if row.claimed {
                WarmClaim::Claimed
            } else if row.found.is_none() {
                WarmClaim::Missed(WarmMissReason::NotFound)
            } else {
                WarmClaim::Missed(
                    checks
                        .into_iter()
                        .find_map(|(held, reason)| (held != Some(true)).then_some(reason))
                        .unwrap_or(WarmMissReason::LostRace),
                )
            };
            if claim == WarmClaim::Claimed {
                upsert_user_history(&mut transaction, user.as_ref(), &id.as_uuid())
                    .await
                    .context("record claimed warm session history")?;
                // A warm row has no cause until someone claims it.
                source::link_source(&mut transaction, id, origin).await?;
            }
            transaction.commit().await.context("commit warm claim")?;
            Ok(claim)
        })
    }
    fn expire(&self) -> Pin<Box<dyn Future<Output = Result<Vec<AgentSessionId>>> + Send + '_>> {
        Box::pin(async move {
            // Mark under row locks before deleting: a concurrent claim cannot win
            // after this operation, and a crash leaves a retryable expired row.
            let rows = sqlx::query!(
                r#"
                UPDATE agent_session SET status = 'disconnected'
                WHERE id IN (
                    SELECT id FROM agent_session
                    WHERE for_warming AND visibility = 'hidden' AND thread_id IS NULL
                      AND NOT EXISTS (SELECT 1 FROM agent_conversation_sessions c WHERE c.session_id = agent_session.id)
                      AND created_at <= NOW() - INTERVAL '10 minutes'
                    ORDER BY created_at LIMIT 64 FOR UPDATE SKIP LOCKED
                ) RETURNING id
            "#
            )
            .fetch_all(&self.pool)
            .await
            .context("expire warm sessions")?;
            let mut expired = Vec::new();
            for row in rows {
                let id = AgentSessionId::new_from_uuid(row.id);
                expired.push(id);
            }
            Ok(expired)
        })
    }
}