mirror of
https://github.com/zyycn/codex-proxy-rs.git
synced 2026-11-21 08:01:41 +00:00
feat: add codex websocket responses transport
Co-authored-by: Codex <noreply@openai.com>
This commit is contained in:
+22
-1
@@ -10,7 +10,10 @@ use crate::{
|
||||
sse::SseError,
|
||||
types::CodexResponsesRequest,
|
||||
usage::{extract_sse_usage, TokenUsage},
|
||||
websocket::{ensure_http_sse_supported, WebSocketSupportError},
|
||||
websocket::{
|
||||
create_response_via_websocket, ensure_http_sse_supported, transport_for_request,
|
||||
CodexTransport, CodexWebSocketError, WebSocketSupportError,
|
||||
},
|
||||
},
|
||||
fingerprint::model::Fingerprint,
|
||||
};
|
||||
@@ -25,6 +28,8 @@ pub enum CodexClientError {
|
||||
InvalidHeaderValue(#[from] reqwest::header::InvalidHeaderValue),
|
||||
#[error("unsupported transport: {0}")]
|
||||
UnsupportedTransport(#[from] WebSocketSupportError),
|
||||
#[error("websocket transport error: {0}")]
|
||||
WebSocket(#[from] CodexWebSocketError),
|
||||
#[error("invalid upstream SSE response: {0}")]
|
||||
InvalidSse(#[from] SseError),
|
||||
#[error("upstream returned status {status}: {body}")]
|
||||
@@ -83,6 +88,22 @@ impl CodexBackendClient {
|
||||
request: &CodexResponsesRequest,
|
||||
context: CodexRequestContext<'_>,
|
||||
) -> CodexClientResult<CodexBackendResponse> {
|
||||
if transport_for_request(request) == CodexTransport::WebSocketRequired {
|
||||
let body = create_response_via_websocket(
|
||||
&self.base_url,
|
||||
request,
|
||||
self.request_headers(context)?,
|
||||
)
|
||||
.await?;
|
||||
let usage = extract_sse_usage(&body)?;
|
||||
return Ok(CodexBackendResponse {
|
||||
body,
|
||||
usage,
|
||||
turn_state: None,
|
||||
set_cookie_headers: Vec::new(),
|
||||
});
|
||||
}
|
||||
|
||||
let response = self.send_response_request(request, context).await?;
|
||||
let status = response.status();
|
||||
let turn_state = turn_state(&response);
|
||||
|
||||
+149
-1
@@ -1,6 +1,15 @@
|
||||
use thiserror::Error;
|
||||
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
|
||||
use tokio_tungstenite::{
|
||||
connect_async,
|
||||
tungstenite::{http::Request as WsRequest, Message},
|
||||
};
|
||||
|
||||
use crate::codex::types::CodexResponsesRequest;
|
||||
use futures::{SinkExt, StreamExt};
|
||||
use reqwest::header::HeaderMap;
|
||||
use serde_json::{json, Value};
|
||||
|
||||
use crate::codex::{sse::encode_sse_event, types::CodexResponsesRequest};
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum CodexTransport {
|
||||
@@ -16,6 +25,16 @@ pub enum WebSocketSupportError {
|
||||
ExplicitWebSocketRequired,
|
||||
}
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum CodexWebSocketError {
|
||||
#[error("invalid WebSocket request: {0}")]
|
||||
InvalidRequest(#[from] tokio_tungstenite::tungstenite::http::Error),
|
||||
#[error("websocket transport error: {0}")]
|
||||
Transport(#[from] tokio_tungstenite::tungstenite::Error),
|
||||
#[error("websocket response ended before any events")]
|
||||
EmptyResponse,
|
||||
}
|
||||
|
||||
pub fn transport_for_request(request: &CodexResponsesRequest) -> CodexTransport {
|
||||
if request.previous_response_id.is_some() || request.use_websocket {
|
||||
CodexTransport::WebSocketRequired
|
||||
@@ -35,3 +54,132 @@ pub fn ensure_http_sse_supported(
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn create_response_via_websocket(
|
||||
base_url: &str,
|
||||
request: &CodexResponsesRequest,
|
||||
headers: HeaderMap,
|
||||
) -> Result<String, CodexWebSocketError> {
|
||||
let ws_request = build_ws_request(base_url, headers)?;
|
||||
let (mut websocket, _) = connect_async(ws_request).await?;
|
||||
websocket
|
||||
.send(Message::Text(
|
||||
websocket_request_body(request).to_string().into(),
|
||||
))
|
||||
.await?;
|
||||
|
||||
let mut body = String::new();
|
||||
while let Some(message) = websocket.next().await {
|
||||
let message = message?;
|
||||
let Some(raw) = websocket_message_text(message) else {
|
||||
continue;
|
||||
};
|
||||
let event = websocket_event_type(&raw);
|
||||
body.push_str(&encode_sse_event(
|
||||
event.as_deref().unwrap_or_default(),
|
||||
&raw,
|
||||
));
|
||||
if event.as_deref().is_some_and(is_terminal_websocket_event) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if body.is_empty() {
|
||||
return Err(CodexWebSocketError::EmptyResponse);
|
||||
}
|
||||
Ok(body)
|
||||
}
|
||||
|
||||
fn build_ws_request(
|
||||
base_url: &str,
|
||||
headers: HeaderMap,
|
||||
) -> Result<WsRequest<()>, CodexWebSocketError> {
|
||||
let mut request = websocket_url(base_url).into_client_request()?;
|
||||
for (name, value) in &headers {
|
||||
let Ok(name) =
|
||||
tokio_tungstenite::tungstenite::http::HeaderName::from_bytes(name.as_str().as_bytes())
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
let Ok(value) =
|
||||
tokio_tungstenite::tungstenite::http::HeaderValue::from_bytes(value.as_bytes())
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
request.headers_mut().insert(name, value);
|
||||
}
|
||||
Ok(request)
|
||||
}
|
||||
|
||||
fn websocket_url(base_url: &str) -> String {
|
||||
let url = format!("{}/codex/responses", base_url.trim_end_matches('/'));
|
||||
if let Some(rest) = url.strip_prefix("https://") {
|
||||
format!("wss://{rest}")
|
||||
} else if let Some(rest) = url.strip_prefix("http://") {
|
||||
format!("ws://{rest}")
|
||||
} else {
|
||||
url
|
||||
}
|
||||
}
|
||||
|
||||
fn websocket_request_body(request: &CodexResponsesRequest) -> Value {
|
||||
let mut body = json!({
|
||||
"type": "response.create",
|
||||
"model": request.model,
|
||||
"instructions": request.instructions,
|
||||
"input": request.input,
|
||||
"stream": true,
|
||||
"store": false,
|
||||
"tool_choice": request.tool_choice.clone().unwrap_or_else(|| json!("auto")),
|
||||
"parallel_tool_calls": request.parallel_tool_calls.unwrap_or(true),
|
||||
});
|
||||
if let Some(previous_response_id) = &request.previous_response_id {
|
||||
body["previous_response_id"] = Value::String(previous_response_id.clone());
|
||||
}
|
||||
if let Some(reasoning) = &request.reasoning {
|
||||
body["reasoning"] = reasoning.clone();
|
||||
}
|
||||
if let Some(tools) = request.tools.as_ref().filter(|tools| !tools.is_empty()) {
|
||||
body["tools"] = Value::Array(tools.clone());
|
||||
}
|
||||
if let Some(text) = &request.text {
|
||||
body["text"] = text.clone();
|
||||
}
|
||||
if let Some(service_tier) = &request.service_tier {
|
||||
body["service_tier"] = Value::String(service_tier.clone());
|
||||
}
|
||||
if let Some(prompt_cache_key) = &request.prompt_cache_key {
|
||||
body["prompt_cache_key"] = Value::String(prompt_cache_key.clone());
|
||||
}
|
||||
if let Some(include) = request
|
||||
.include
|
||||
.as_ref()
|
||||
.filter(|include| !include.is_empty())
|
||||
{
|
||||
body["include"] = Value::Array(include.iter().cloned().map(Value::String).collect());
|
||||
}
|
||||
if let Some(client_metadata) = &request.client_metadata {
|
||||
body["client_metadata"] = client_metadata.clone();
|
||||
}
|
||||
body
|
||||
}
|
||||
|
||||
fn websocket_message_text(message: Message) -> Option<String> {
|
||||
match message {
|
||||
Message::Text(text) => Some(text.to_string()),
|
||||
Message::Binary(bytes) => String::from_utf8(bytes.to_vec()).ok(),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn websocket_event_type(raw: &str) -> Option<String> {
|
||||
serde_json::from_str::<Value>(raw).ok().and_then(|value| {
|
||||
value
|
||||
.get("type")
|
||||
.and_then(Value::as_str)
|
||||
.map(str::to_string)
|
||||
})
|
||||
}
|
||||
|
||||
fn is_terminal_websocket_event(event: &str) -> bool {
|
||||
event == "response.completed" || event == "response.failed" || event == "error"
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user