vona-core 0.1.1

Core traits, event types, session driver, skill registry and runtime policy surface for real-time speech-to-speech runtimes
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use crate::session::SessionConfig;
use crate::types::{AudioInputFrame, AudioOutputFrame, ControlEvent, ExternalContextEvent};
use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use thiserror::Error;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct BackendCapabilities {
    pub supports_full_duplex: bool,
    pub supports_control_stream: bool,
    pub supports_context_injection: bool,
    pub supports_pause_resume: bool,
    pub supports_style_conditioning: bool,
    pub supports_word_timestamps: bool,
}

impl Default for BackendCapabilities {
    fn default() -> Self {
        Self {
            supports_full_duplex: true,
            supports_control_stream: true,
            supports_context_injection: false,
            supports_pause_resume: true,
            supports_style_conditioning: false,
            supports_word_timestamps: false,
        }
    }
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BackendStep {
    pub output_audio: Vec<AudioOutputFrame>,
    pub control_events: Vec<ControlEvent>,
    pub transcript: Option<String>,
    pub finished: bool,
    pub debug_payload: Option<Value>,
}

#[derive(Debug, Error)]
pub enum BackendError {
    #[error("backend session start failed: {0}")]
    Start(String),
    #[error("backend step failed: {0}")]
    Step(String),
    #[error("backend context injection failed: {0}")]
    Inject(String),
    #[error("backend end session failed: {0}")]
    End(String),
}

#[async_trait]
pub trait SpeechToSpeechBackend: Send + Sync {
    type Session: Send + Sync;

    fn capabilities(&self) -> BackendCapabilities;

    async fn start_session(&self, config: SessionConfig) -> Result<Self::Session, BackendError>;

    async fn step(
        &self,
        session: &mut Self::Session,
        input: AudioInputFrame,
    ) -> Result<BackendStep, BackendError>;

    async fn inject_event(
        &self,
        session: &mut Self::Session,
        event: ExternalContextEvent,
    ) -> Result<(), BackendError>;

    async fn end_session(&self, session: Self::Session) -> Result<(), BackendError>;
}