mojentic/realtime/
openai_gateway.rs1use 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}