Skip to main content

mojentic/realtime/
openai_gateway.rs

1//! OpenAI Realtime API gateway.
2
3use crate::realtime::config::RealtimeVoiceConfig;
4use crate::realtime::gateway::{RealtimeGatewaySession, RealtimeVoiceGateway};
5use crate::realtime::schemas::parse_server_event;
6use crate::realtime::transport::{RealtimeTransport, TransportError, WebSocketTransport};
7use async_trait::async_trait;
8use serde_json::Value;
9use uuid::Uuid;
10
11const DEFAULT_URL: &str = "wss://api.openai.com/v1/realtime";
12
13#[derive(Debug, Clone, Default)]
14pub struct OpenAIRealtimeGatewayOptions {
15    pub api_key: Option<String>,
16    pub base_url: Option<String>,
17}
18
19pub struct OpenAIRealtimeGateway {
20    api_key: String,
21    base_url: String,
22}
23
24impl OpenAIRealtimeGateway {
25    pub fn new(options: OpenAIRealtimeGatewayOptions) -> Result<Self, &'static str> {
26        let api_key = options
27            .api_key
28            .or_else(|| std::env::var("OPENAI_API_KEY").ok())
29            .ok_or("OpenAIRealtimeGateway requires api_key or OPENAI_API_KEY env var")?;
30        Ok(Self {
31            api_key,
32            base_url: options.base_url.unwrap_or_else(|| DEFAULT_URL.to_string()),
33        })
34    }
35}
36
37#[async_trait]
38impl RealtimeVoiceGateway for OpenAIRealtimeGateway {
39    async fn open(
40        &self,
41        model: &str,
42        _config: &RealtimeVoiceConfig,
43        correlation_id: Option<&str>,
44    ) -> Result<Box<dyn RealtimeGatewaySession>, TransportError> {
45        use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
46        let url =
47            format!("{}?model={}", self.base_url, utf8_percent_encode(model, NON_ALPHANUMERIC));
48
49        let mut headers = vec![
50            ("authorization".to_string(), format!("Bearer {}", self.api_key)),
51            ("openai-beta".to_string(), "realtime=v1".to_string()),
52        ];
53        if let Some(cid) = correlation_id {
54            headers.push(("x-correlation-id".to_string(), cid.to_string()));
55        }
56
57        let transport = WebSocketTransport::connect(&url, &headers).await?;
58
59        Ok(Box::new(OpenAISession {
60            session_id: Uuid::new_v4().to_string(),
61            transport: Box::new(transport),
62            closed: false,
63        }))
64    }
65}
66
67struct OpenAISession {
68    session_id: String,
69    transport: Box<dyn RealtimeTransport>,
70    closed: bool,
71}
72
73#[async_trait]
74impl RealtimeGatewaySession for OpenAISession {
75    fn session_id(&self) -> &str {
76        &self.session_id
77    }
78
79    async fn send_event(&mut self, event: &Value) -> Result<(), TransportError> {
80        if self.closed {
81            return Err(TransportError("session closed".to_string()));
82        }
83        let payload = serde_json::to_string(event)
84            .map_err(|e| TransportError(format!("encode error: {e}")))?;
85        self.transport.send(&payload).await
86    }
87
88    async fn next_event(&mut self) -> Option<Value> {
89        let frame = self.transport.next_frame().await?;
90        match frame {
91            Ok(text) => match serde_json::from_str::<Value>(&text) {
92                Ok(raw) => Some(parse_server_event(raw)),
93                Err(err) => Some(serde_json::json!({
94                    "type": "error",
95                    "error": { "type": "parse_error", "message": err.to_string() }
96                })),
97            },
98            Err(err) => Some(serde_json::json!({
99                "type": "error",
100                "error": { "type": "transport_error", "message": err.to_string() }
101            })),
102        }
103    }
104
105    async fn close(&mut self) -> Result<(), TransportError> {
106        if self.closed {
107            return Ok(());
108        }
109        self.closed = true;
110        self.transport.close().await
111    }
112
113    fn is_closed(&self) -> bool {
114        self.closed
115    }
116}