tea-kernel 0.1.0

Headless model-tool agent state machine for tea-rs
Documentation
use tea_protocol::{
    AgentEvent, EventEnvelope, ProtocolMetadata, RunId, SessionId, SessionSequence, TurnId,
};

use crate::{
    KernelClock, KernelError, KernelErrorCode, KernelEventSink, KernelIdSource, RunLimits,
};

pub(crate) struct EventEmitter<'a> {
    ids: &'a dyn KernelIdSource,
    clock: &'a dyn KernelClock,
    sink: &'a dyn KernelEventSink,
    session_id: SessionId,
    sequence: SessionSequence,
    emitted: u64,
    limits: RunLimits,
}

impl<'a> EventEmitter<'a> {
    pub(crate) fn new(
        ids: &'a dyn KernelIdSource,
        clock: &'a dyn KernelClock,
        sink: &'a dyn KernelEventSink,
        session_id: SessionId,
        durable_tail: SessionSequence,
        limits: RunLimits,
    ) -> Self {
        Self {
            ids,
            clock,
            sink,
            session_id,
            sequence: match sink.last_sequence(session_id) {
                Some(cursor) if cursor > durable_tail => cursor,
                Some(_) | None => durable_tail,
            },
            emitted: 0,
            limits,
        }
    }

    pub(crate) async fn emit(
        &mut self,
        run_id: Option<RunId>,
        turn_id: Option<TurnId>,
        event: AgentEvent,
    ) -> Result<(), KernelError> {
        if self.emitted >= self.limits.max_events() {
            return Err(KernelError::new(
                KernelErrorCode::LimitExceeded,
                "run event limit was reached",
            ));
        }
        self.sequence = self.sequence.checked_next().ok_or_else(|| {
            KernelError::new(
                KernelErrorCode::LimitExceeded,
                "event sequence cannot advance",
            )
        })?;
        let envelope = EventEnvelope::new(
            self.ids.next_event_id()?,
            self.session_id,
            run_id,
            turn_id,
            self.sequence,
            self.clock.now()?,
            ProtocolMetadata::default(),
            event,
        )
        .map_err(|error| KernelError::new(KernelErrorCode::InvalidState, error.to_string()))?;
        self.sink.emit(envelope).await.map_err(|error| {
            KernelError::new(KernelErrorCode::EventSinkFailure, error.to_string())
        })?;
        self.emitted += 1;
        Ok(())
    }
}