apoc 0.9.1

Agentic process control for LLMs
Documentation
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;

use tokio_util::sync::CancellationToken;

use crate::model::{ExecutionStartInput, IsolationStatus, IsolationWarmupInput, ProviderError};
use crate::registry::EventSink;

pub type EngineFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;

pub trait EngineControl: Send + Sync {
    fn activate(&self) -> EngineFuture<'_, Result<(), ProviderError>> {
        Box::pin(async { Ok(()) })
    }
    fn input<'a>(&'a self, data: Vec<u8>) -> EngineFuture<'a, Result<(), ProviderError>>;
    fn signal<'a>(&'a self, signal: String) -> EngineFuture<'a, Result<(), ProviderError>>;
    fn cancel<'a>(&'a self) -> EngineFuture<'a, Result<(), ProviderError>>;
}

pub trait VmEngine: Send + Sync {
    fn status(&self) -> Result<IsolationStatus, ProviderError>;
    fn warmup<'a>(
        &'a self,
        request: IsolationWarmupInput,
    ) -> EngineFuture<'a, Result<IsolationStatus, ProviderError>>;
    fn drain(&self) -> EngineFuture<'_, Result<IsolationStatus, ProviderError>>;
    fn launch<'a>(
        &'a self,
        request: ExecutionStartInput,
        events: EventSink,
        cancellation: CancellationToken,
    ) -> EngineFuture<'a, Result<Arc<dyn EngineControl>, ProviderError>>;
}

#[cfg_attr(target_os = "macos", allow(dead_code))]
#[derive(Default)]
pub struct UnavailableEngine;

impl VmEngine for UnavailableEngine {
    fn status(&self) -> Result<IsolationStatus, ProviderError> {
        Ok(IsolationStatus::uninitialized())
    }

    fn warmup<'a>(
        &'a self,
        _request: IsolationWarmupInput,
    ) -> EngineFuture<'a, Result<IsolationStatus, ProviderError>> {
        Box::pin(async {
            Err(ProviderError::new(
                "NATIVE_VZ_UNAVAILABLE",
                "The native Rust VZ engine is not initialized",
            ))
        })
    }

    fn drain(&self) -> EngineFuture<'_, Result<IsolationStatus, ProviderError>> {
        Box::pin(async {
            let mut status = IsolationStatus::uninitialized();
            status.drained = Some(true);
            Ok(status)
        })
    }

    fn launch<'a>(
        &'a self,
        _request: ExecutionStartInput,
        _events: EventSink,
        _cancellation: CancellationToken,
    ) -> EngineFuture<'a, Result<Arc<dyn EngineControl>, ProviderError>> {
        Box::pin(async {
            Err(ProviderError::new(
                "NATIVE_VZ_UNAVAILABLE",
                "The native Rust VZ engine is not initialized",
            ))
        })
    }
}