use std::collections::HashMap;
use std::sync::{Arc, Mutex, Weak};
use std::time::{Duration, Instant};
use bytes::Bytes;
use cpa_core::config::Config;
use cpa_core::credential::Credential;
use cpa_core::exec::{
ExecError, ExecRequest, ExecResponse, ExecSession, ExecStream, FailureScope, ResponseBody, SessionLease,
};
use futures_util::stream::{SplitSink, SplitStream};
use futures_util::{SinkExt, StreamExt};
use gjson::Kind;
use http::HeaderMap;
use tokio::sync::{OwnedMutexGuard, mpsc, watch};
use tokio_tungstenite::WebSocketStream;
use tokio_tungstenite::tungstenite::Message;
use tokio_tungstenite::tungstenite::protocol::{Role, WebSocketConfig};
use deflate::Inflate;
pub(crate) type WebSocket = WebSocketStream<Inflate<wreq::Upgraded>>;
use crate::codex::CodexExecutor;
use crate::codex_json::{set_raw, set_str};
use crate::codex_quota::{self, QuotaSignals};
use crate::codex_request::{self as request, Call, Settings, View};
use crate::codex_response::{self as response, OutputItems};
use crate::proxy::Proxy;
pub(crate) const IDLE_TIMEOUT: Duration = Duration::from_secs(300);
const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(30);
#[derive(Debug, Clone, Copy)]
pub(crate) struct WriteLimit {
pub(crate) floor: Duration,
pub(crate) rate: usize,
}
pub(crate) const WRITE_LIMIT: WriteLimit = WriteLimit {
floor: Duration::from_secs(10),
rate: 128 << 10,
};
impl WriteLimit {
fn deadline(self, len: usize) -> Duration {
self.floor
.max(Duration::from_secs(len.div_ceil(self.rate.max(1)) as u64))
}
}
const TURN_BUFFER: usize = 4096;
const MAX_HANDSHAKE_BODY: usize = 64 * 1024;
const MAX_UPSTREAM_MESSAGE: usize = 64 * 1024 * 1024;
#[derive(Debug, Clone)]
pub(crate) struct Target {
pub(crate) credential: String,
pub(crate) url: String,
pub(crate) proxy: Proxy,
setting: String,
global: String,
inherited: bool,
}
impl Target {
pub(crate) fn new(credential: &Credential, url: String, cfg: &Config) -> Self {
let own = Proxy::own_url(credential);
let global = Proxy::global_url(cfg);
let setting = own.map_or_else(|| global.clone(), str::to_owned);
Self {
credential: credential.id.clone(),
url,
proxy: Proxy::parse(&setting),
setting,
global,
inherited: own.is_none(),
}
}
pub(crate) fn same(&self, want: &Target) -> bool {
self.credential == want.credential && self.url == want.url && self.setting == want.setting
}
pub(crate) fn serves(&self, want: &Target) -> bool {
let setting = if want.inherited { &self.global } else { &want.setting };
self.credential == want.credential && self.url == want.url && self.setting == *setting
}
}
pub(crate) enum Read {
Text(String),
Failed(ExecError),
}
#[derive(Default)]
pub(crate) struct Link {
active: Option<mpsc::Sender<Read>>,
pub(crate) lost: Option<ExecError>,
terminal: std::collections::HashSet<String>,
}
fn terminal_response_id(payload: &str) -> Option<String> {
let kind = gjson::get(payload, "type");
if !matches!(
kind.str(),
"response.completed" | "response.done" | "response.incomplete" | "response.failed"
) {
return None;
}
let id = gjson::get(payload, "response.id");
(id.kind() == Kind::String && !id.str().is_empty()).then(|| id.str().to_owned())
}
pub const NO_ACTIVE_UPSTREAM: &str = "no active upstream websocket for response.interrupt";
#[derive(Debug, PartialEq, Eq)]
pub enum InterruptError {
NoActive,
Rejected(String),
}
impl std::fmt::Display for InterruptError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::NoActive => f.write_str(NO_ACTIVE_UPSTREAM),
Self::Rejected(text) => f.write_str(text),
}
}
}
pub(crate) struct Upstream {
pub(crate) target: Target,
pub(crate) sink: tokio::sync::Mutex<SplitSink<WebSocket, Message>>,
pub(crate) link: Mutex<Link>,
pub(crate) reader: Mutex<Option<tokio::task::AbortHandle>>,
multi_agent: std::sync::atomic::AtomicBool,
lease: Mutex<(bool, Option<SessionLease>)>,
write: WriteLimit,
}
impl Upstream {
pub(crate) fn new(target: Target, sink: SplitSink<WebSocket, Message>, write: WriteLimit) -> Arc<Self> {
Arc::new(Self {
target,
write,
sink: tokio::sync::Mutex::new(sink),
link: Mutex::default(),
reader: Mutex::default(),
multi_agent: Default::default(),
lease: Mutex::default(),
})
}
fn restores(&self, optimized: bool, conflict: bool) -> bool {
!conflict && (optimized || self.multi_agent.load(std::sync::atomic::Ordering::Acquire))
}
fn note_multi_agent(&self, optimized: bool, conflict: bool) {
if optimized || conflict {
self.multi_agent
.store(optimized && !conflict, std::sync::atomic::Ordering::Release);
}
}
pub(crate) fn activate(&self) -> mpsc::Receiver<Read> {
let (tx, rx) = mpsc::channel(TURN_BUFFER);
let mut link = self.link.lock().expect("link");
match &link.lost {
Some(error) => {
let _ = tx.try_send(Read::Failed(turn_error(error)));
}
None => link.active = Some(tx),
}
rx
}
pub(crate) fn deactivate(&self) {
self.link.lock().expect("link").active.take();
}
pub(crate) async fn send(&self, frame: String) -> Result<(), ExecError> {
let len = frame.len();
self.write_message(Message::text(frame), len).await
}
pub(crate) async fn send_raw(&self, payload: Bytes) -> Result<(), ExecError> {
use tokio_tungstenite::tungstenite::protocol::frame::{
Frame,
coding::{Data, OpCode},
};
let len = payload.len();
self.write_message(
Message::Frame(Frame::message(payload, OpCode::Data(Data::Text), true)),
len,
)
.await
}
async fn write_message(&self, message: Message, len: usize) -> Result<(), ExecError> {
let deadline = self.write.deadline(len);
let sent = tokio::time::timeout(deadline, async { self.sink.lock().await.send(message).await }).await;
match sent {
Ok(Ok(())) => Ok(()),
Ok(Err(_)) => Err(write_error(
self.link.lock().expect("link").lost.as_ref(),
"codex websockets executor: write failed",
)),
Err(_) => Err(write_error(
self.link.lock().expect("link").lost.as_ref(),
"codex websockets executor: write timed out",
)),
}
}
pub(crate) fn bind(
self: &Arc<Self>,
session: &Arc<Session>,
lease: Option<&SessionLease>,
) -> Result<(), ExecError> {
let Some(lease) = lease else { return Ok(()) };
if self
.lease
.lock()
.expect("lease")
.1
.as_ref()
.is_some_and(|l| l.same(lease))
{
return Ok(());
}
let (weak_session, weak_conn) = (Arc::downgrade(session), Arc::downgrade(self));
let close = Box::new(move || {
if let (Some(session), Some(conn)) = (weak_session.upgrade(), weak_conn.upgrade()) {
session.invalidate(
&conn,
&transport("codex websockets executor: execution lifecycle ended"),
false,
);
}
});
let unbound = || transport("codex websockets executor: websocket connection closed during lifecycle bind");
if !lease.0.retain(close) {
session.invalidate(self, &unbound(), false);
return Err(unbound());
}
let previous = {
let mut slot = self.lease.lock().expect("lease");
if slot.0 {
drop(slot);
lease.0.end();
return Err(unbound());
}
slot.1.replace(lease.clone())
};
if let Some(previous) = previous {
previous.0.end();
}
Ok(())
}
pub(crate) fn shutdown(self: &Arc<Self>) {
if let Some(reader) = self.reader.lock().expect("reader handle").take() {
reader.abort();
}
self.deactivate();
let lease = {
let mut slot = self.lease.lock().expect("lease");
slot.0 = true;
slot.1.take()
};
if let Some(lease) = lease {
lease.0.end();
}
let this = self.clone();
tokio::spawn(async move {
let _ = tokio::time::timeout(Duration::from_secs(1), async {
let mut sink = this.sink.lock().await;
let _ = sink.send(Message::Close(None)).await;
let _ = sink.close().await;
})
.await;
});
}
}
pub(crate) struct Session {
pub(crate) turn: Arc<tokio::sync::Mutex<()>>,
pub(crate) conn: Mutex<Option<Arc<Upstream>>>,
closed: watch::Sender<Option<ExecError>>,
steering: Mutex<Option<Arc<SteeringInput>>>,
credential: Mutex<String>,
}
impl Session {
pub(crate) fn publish(&self, conn: Arc<Upstream>) {
let mut slot = self.conn.lock().expect("session conn");
conn.target
.credential
.clone_into(&mut self.credential.lock().expect("session credential"));
*slot = Some(conn);
}
pub(crate) fn current(&self) -> Option<Arc<Upstream>> {
self.conn.lock().expect("session conn").clone()
}
fn steering(&self) -> Option<Arc<SteeringInput>> {
self.steering.lock().expect("session steering").clone()
}
pub(crate) fn invalidate(&self, conn: &Arc<Upstream>, error: &ExecError, notify: bool) {
{
let mut current = self.conn.lock().expect("session conn");
if !current.as_ref().is_some_and(|c| Arc::ptr_eq(c, conn)) {
return;
}
*current = None;
}
if notify {
self.closed.send_if_modified(|slot| {
let first = slot.is_none();
if first {
*slot = Some(error.clone());
}
first
});
}
conn.shutdown();
}
}
pub(crate) struct Pool {
sessions: Mutex<HashMap<String, Arc<Session>>>,
pub(crate) idle: Duration,
pub(crate) write: WriteLimit,
}
impl Default for Pool {
fn default() -> Self {
Self {
sessions: Mutex::default(),
idle: IDLE_TIMEOUT,
write: WRITE_LIMIT,
}
}
}
impl Pool {
#[cfg(test)]
pub fn with_idle(idle: Duration) -> Self {
Self {
idle,
..Self::default()
}
}
#[cfg(test)]
pub(crate) fn with_write(write: WriteLimit) -> Self {
Self {
write,
..Self::default()
}
}
pub(crate) fn session(&self, id: &str) -> Arc<Session> {
self.sessions
.lock()
.expect("sessions")
.entry(id.to_owned())
.or_insert_with(|| {
Arc::new(Session {
turn: Arc::default(),
conn: Mutex::default(),
closed: watch::channel(None).0,
steering: Mutex::default(),
credential: Mutex::default(),
})
})
.clone()
}
fn get(&self, id: &str) -> Option<Arc<Session>> {
self.sessions.lock().expect("sessions").get(id).cloned()
}
pub fn attach_steering(&self, id: &str, input: SteeringInput) {
*self.session(id).steering.lock().expect("session steering") = Some(Arc::new(input));
}
pub fn close(&self, id: &str) {
let session = self.sessions.lock().expect("sessions").remove(id);
if let Some(conn) = session.and_then(|s| s.conn.lock().expect("session conn").take()) {
conn.shutdown();
}
}
pub(crate) fn close_credential(&self, credential: &str) {
self.close_credential_with(credential, |_| {});
}
pub(crate) fn close_credential_with(&self, credential: &str, mut detached: impl FnMut(&str)) {
let sessions: Vec<_> = {
let sessions = self.sessions.lock().expect("sessions");
sessions.iter().map(|(id, s)| (id.clone(), s.clone())).collect()
};
let matching: Vec<_> = sessions
.into_iter()
.filter(|(_, s)| *s.credential.lock().expect("session credential") == credential)
.collect();
let mut closing = Vec::new();
{
let mut sessions = self.sessions.lock().expect("sessions");
for (id, session) in matching {
if !sessions.get(&id).is_some_and(|s| Arc::ptr_eq(s, &session)) {
continue;
}
sessions.remove(&id);
detached(&id);
closing.push(session);
}
}
for session in closing {
if let Some(conn) = session.conn.lock().expect("session conn").take() {
conn.shutdown();
}
}
}
pub fn loss(&self, id: &str) -> Option<ExecError> {
let session = self.get(id)?;
session.closed.borrow().clone()
}
pub async fn interrupt(
&self,
id: &str,
payload: &[u8],
enabled: impl FnOnce(&str) -> bool,
) -> Result<(), InterruptError> {
let session = Some(id.trim())
.filter(|id| !id.is_empty())
.and_then(|id| self.get(id))
.ok_or(InterruptError::NoActive)?;
let conn = session.current().ok_or(InterruptError::NoActive)?;
let auth_enabled = enabled(&conn.target.credential);
let response_id = cpa_common::json::get(payload, "response_id").bytes();
{
let current = session.conn.lock().expect("session conn");
if !current.as_ref().is_some_and(|c| Arc::ptr_eq(c, &conn)) {
return Err(InterruptError::NoActive);
}
let link = conn.link.lock().expect("link");
if let Some(lost) = &link.lost {
return Err(InterruptError::Rejected(
String::from_utf8_lossy(&lost.body).into_owned(),
));
}
if std::str::from_utf8(&response_id).is_ok_and(|id| link.terminal.contains(id)) {
return Ok(());
}
if link.active.is_none() {
return Err(InterruptError::NoActive);
}
}
if !auth_enabled {
return Err(InterruptError::Rejected(
"websocket credential is no longer enabled".into(),
));
}
if let Err(error) = conn.send_raw(Bytes::copy_from_slice(payload)).await {
session.invalidate(&conn, &error, true);
return Err(InterruptError::Rejected(
String::from_utf8_lossy(&error.body).into_owned(),
));
}
Ok(())
}
pub fn closed(&self, id: &str) -> impl std::future::Future<Output = ExecError> + Send + 'static {
let mut rx = self.session(id).closed.subscribe();
async move {
loop {
if let Some(error) = rx.borrow_and_update().clone() {
return error;
}
if rx.changed().await.is_err() {
return std::future::pending().await;
}
}
}
}
#[cfg(test)]
pub fn len(&self) -> usize {
self.sessions.lock().expect("sessions").len()
}
}
fn transport(message: &str) -> ExecError {
ExecError::local(502, FailureScope::Transport, message)
}
fn close_error_text(code: u16, text: &str) -> String {
let name = match code {
1000 => " (normal)",
1001 => " (going away)",
1002 => " (protocol error)",
1003 => " (unsupported data)",
1005 => " (no status)",
1006 => " (abnormal closure)",
1007 => " (invalid payload data)",
1008 => " (policy violation)",
1009 => " (message too big)",
1010 => " (mandatory extension missing)",
1011 => " (internal server error)",
1015 => " (TLS handshake error)",
_ => "",
};
let mut out = format!("websocket: close {code}{name}");
if !text.is_empty() {
out.push_str(": ");
out.push_str(text);
}
out
}
fn closed_too_big(reason: &str) -> ExecError {
let message = if reason.is_empty() { "message too big" } else { reason };
ExecError::local(
413,
FailureScope::Request,
serde_json::json!({
"error": {"message": message, "type": "invalid_request_error", "code": "message_too_big"},
"close_reason": reason,
})
.to_string(),
)
}
fn message_too_big() -> ExecError {
ExecError::local(
413,
FailureScope::Request,
r#"{"error":{"message":"upstream websocket message too big","type":"invalid_request_error","code":"message_too_big"}}"#,
)
}
const UNEXPECTED_BINARY: &str = "codex websockets executor: unexpected binary message";
pub(crate) fn write_error(lost: Option<&ExecError>, message: &str) -> ExecError {
lost.filter(|e| e.status == 413)
.map_or_else(|| transport(message), turn_error)
}
fn turn_error(lost: &ExecError) -> ExecError {
if lost.status == 413 {
message_too_big()
} else {
lost.clone()
}
}
fn ws_url(http_url: &str) -> Result<String, ExecError> {
let raw = http_url.trim();
let mut parsed = crate::xai_url::parse(raw).map_err(|e| crate::xai_url::url_error(raw, &e))?;
parsed.scheme = match parsed.scheme.as_str() {
"http" => "ws".to_owned(),
"https" => "wss".to_owned(),
other => {
return Err(crate::xai_url::statusless(format!(
"codex websockets executor: unsupported responses websocket URL scheme {}",
cpa_common::gostr::quote(other)
)));
}
};
if parsed.host.trim().is_empty() {
return Err(crate::xai_url::statusless(
"codex websockets executor: responses websocket URL host is empty",
));
}
Ok(crate::xai_url::string(&parsed))
}
pub(crate) fn turn_body(
view: &View<'_>,
req: &ExecRequest,
settings: &Settings,
finalize: &request::Finalizer,
body: String,
) -> String {
let mut body = request::sanitize_input_ids(body);
if view.siwc {
body = request::siwc_request_body(body, req, Call::Websocket);
}
finalize.apply(req, settings, body)
}
fn request_frame(body: String) -> String {
set_str(&body, "type", "response.create")
}
fn ws_error_body(payload: &str) -> Option<(u16, String)> {
if gjson::get(payload, "type").str().trim() != "error" {
return None;
}
let mut status = gjson::get(payload, "status").i64();
if status == 0 {
status = gjson::get(payload, "status_code").i64();
}
let Ok(status) = u16::try_from(status) else {
return None;
};
if status == 0 {
return None;
}
let mut out = set_raw("{}", "status", &status.to_string());
let body = gjson::get(payload, "body");
let error = gjson::get(payload, "error");
if body.exists() {
out = set_raw(&out, "body", body.json());
}
if body.exists() && body.get("error").exists() {
out = set_raw(&out, "error", body.get("error").json());
} else if error.exists() {
out = set_raw(&out, "error", error.json());
} else {
out = set_str(&out, "error.type", "server_error");
out = set_str(&out, "error.message", response::go_status_text(status));
}
Some((status, out))
}
#[derive(Clone, Default)]
pub(super) struct Replay {
cache: Arc<crate::codex_replay::Cache>,
scope: crate::codex_replay::Scope,
}
impl Replay {
async fn apply(cache: &Arc<crate::codex_replay::Cache>, req: &ExecRequest, body: String) -> (String, Self) {
let (body, scope) = crate::codex_replay::apply(cache, req, body).await;
let replay = Self {
cache: cache.clone(),
scope,
};
(body, replay)
}
fn clear(&self, payload: &str, cooling: bool) {
if let Some((status, body)) = ws_error_body(payload) {
crate::codex_replay::clear_on_invalid_signature(&self.cache, &self.scope, status, body.as_bytes());
} else if let Some((error, body)) = response::terminal_failure(payload, cooling) {
crate::codex_replay::clear_on_invalid_signature(&self.cache, &self.scope, error.status, body.as_bytes());
}
}
fn completed(&self, payload: &str) {
crate::codex_replay::cache_completed(&self.cache, &self.scope, payload.as_bytes());
}
}
pub(crate) fn ws_error(payload: &str, model_level_cooling: bool) -> Option<ExecError> {
let (status, out) = ws_error_body(payload)?;
let mut headers = HeaderMap::new();
let raw_headers = gjson::get(payload, "headers");
if raw_headers.kind() == Kind::Object {
raw_headers.each(|k, v| {
let value = match v.kind() {
Kind::String => v.str().trim().to_owned(),
Kind::Number | Kind::True | Kind::False => v.json().trim().to_owned(),
_ => String::new(),
};
if let (Ok(name), Ok(value)) = (
http::HeaderName::try_from(k.str().trim()),
http::HeaderValue::from_str(&value),
) && !value.is_empty()
{
headers.insert(name, value);
}
true
});
}
let connection_limit = [
"error.code",
"error.type",
"body.error.code",
"body.error.type",
"code",
"error",
]
.iter()
.any(|p| gjson::get(payload, p).str().trim() == "websocket_connection_limit_reached");
let addon = (!headers.is_empty()).then(|| Box::new(headers.clone()));
let mut error = response::status_error_raw(status, &out, headers, model_level_cooling);
error.addon = addon;
if error.retry_after.is_none() && connection_limit {
error.retry_after = Some(Duration::ZERO);
}
Some(error)
}
enum Frame {
Skip,
Event {
out: Bytes,
raw_len: usize,
bufferable: bool,
terminal: bool,
},
Failed {
error: ExecError,
overload: bool,
read: bool,
status_frame: bool,
},
}
struct Turn {
rx: mpsc::Receiver<Read>,
conn: Arc<Upstream>,
session: Arc<Session>,
_turn: Option<OwnedMutexGuard<()>>,
observing: Option<crate::ws_observation::Observation>,
items: OutputItems,
saw_delta: bool,
native: bool,
cooling: bool,
quota: Arc<QuotaSignals>,
credential: String,
observed: HeaderMap,
restore: bool,
usage: cpa_core::exec::UsageSink,
model: String,
replay: Replay,
wire: crate::codex_capture::Wire,
bootstrapping: bool,
}
impl Drop for Turn {
fn drop(&mut self) {
let conn = self.conn.clone();
crate::ws_observation::release_after(self.observing.take(), self._turn.take(), move || conn.deactivate());
}
}
impl Turn {
async fn frame(&mut self) -> Frame {
let frame = self.read().await;
if let Frame::Failed { error, read: true, .. } = &frame {
let binary = error.body.as_ref() == UNEXPECTED_BINARY.as_bytes();
self.wire
.ws_exec_error(if binary { "unexpected_binary" } else { "read" }, error);
}
frame
}
async fn read(&mut self) -> Frame {
let text = match self.rx.recv().await {
Some(Read::Text(text)) => text,
Some(Read::Failed(error)) => {
return Frame::Failed {
error,
overload: false,
read: true,
status_frame: false,
};
}
None => {
return Frame::Failed {
error: self.loss().map_or_else(
|| transport("codex websockets executor: session read channel closed"),
|l| turn_error(&l),
),
overload: false,
read: true,
status_frame: false,
};
}
};
let payload = text.trim();
if payload.is_empty() {
return Frame::Skip;
}
self.observe(payload);
crate::ws_observation::observe(&mut self.observing, self.wire.ws_response_observation(payload)).await;
let raw_len = payload.len();
let payload = response::restore(payload, self.restore);
let payload = payload.as_ref();
if let Some(error) = ws_error(payload, self.cooling) {
self.replay.clear(payload, self.cooling);
self.wire.ws_exec_error("upstream_error", &error);
return Frame::Failed {
error,
overload: false,
read: false,
status_frame: true,
};
}
if let Some((error, body)) = response::terminal_failure(payload, self.cooling) {
self.replay.clear(payload, self.cooling);
self.wire.ws_exec_error("upstream_error", &error);
return Frame::Failed {
error,
overload: response::is_overload(&body),
read: false,
status_frame: false,
};
}
let kind = gjson::get(payload, "type");
let kind = kind.str().to_owned();
if response::meaningful_delta(payload) {
self.saw_delta = true;
}
if response::empty_incomplete(payload, self.items.len(), self.saw_delta) {
let error = response::request_scoped(502, response::EMPTY_INCOMPLETE_MESSAGE);
if self.bootstrapping {
self.wire.ws_exec_error("upstream_error", &error);
} else {
self.wire.exec_error(&error);
}
return Frame::Failed {
error,
overload: false,
read: false,
status_frame: false,
};
}
let bufferable = response::bufferable(payload);
let mut out = payload.to_owned();
let terminal = matches!(
kind.as_str(),
"response.completed" | "response.done" | "response.incomplete"
);
if kind == "response.output_item.done" {
self.items.collect(payload);
}
if terminal {
out = response::normalize_completion(out);
if !self.native {
out = self.items.patch(out);
}
if kind != "response.incomplete" {
self.replay.completed(&out);
}
}
Frame::Event {
raw_len,
out: Bytes::from(response::ensure_usage_details(out)),
bufferable,
terminal,
}
}
fn observe(&mut self, payload: &str) {
if let Some(headers) = codex_quota::event_headers(payload) {
codex_quota::merge(&mut self.observed, &headers);
self.quota.observe(&self.credential, &self.model, &self.observed);
}
if self.usage.enabled() {
self.usage
.response_line(cpa_core::format::Format::Codex, payload.as_bytes());
}
}
fn invalidate(&self, error: &ExecError, notify: bool) {
self.session.invalidate(&self.conn, error, notify);
}
fn loss(&self) -> Option<ExecError> {
self.session.closed.borrow().clone()
}
}
fn rest(turn: Turn) -> ExecStream {
futures_util::stream::unfold(Some(turn), |turn| async move {
let mut turn = turn?;
loop {
match turn.frame().await {
Frame::Skip => continue,
Frame::Event { out, terminal, .. } => {
return Some((Ok(out), (!terminal).then_some(turn)));
}
Frame::Failed { error, read, .. } => {
if !read {
turn.invalidate(&error, true);
}
return Some((Err(error), None));
}
}
}
})
.boxed()
}
async fn bootstrap(mut turn: Turn, timeout: Option<Duration>, started: Instant) -> Result<ExecStream, ExecError> {
turn.bootstrapping = true;
let mut held: Vec<Result<Bytes, ExecError>> = Vec::new();
let (mut frames, mut bytes) = (0usize, 0usize);
loop {
let frame = turn.frame().await;
frames += 1;
let timed_out = timeout.is_some_and(|t| started.elapsed() >= t);
let window_open = frames <= response::BOOTSTRAP_MAX_FRAMES && !timed_out;
match frame {
Frame::Skip if window_open => continue,
Frame::Skip => break,
Frame::Failed { error, read: true, .. } => return Err(error),
Frame::Failed {
error,
status_frame: true,
..
} => {
turn.invalidate(&error, true);
if !timed_out {
return Err(error);
}
held.push(Err(error));
return Ok(futures_util::stream::iter(held).boxed());
}
Frame::Failed { error, overload, .. } => {
if overload && !timed_out {
turn.invalidate(&error, false);
let body = String::from_utf8_lossy(&error.body).into_owned();
return Err(response::bootstrap_overload(&body));
}
turn.invalidate(&error, true);
held.push(Err(error));
return Ok(futures_util::stream::iter(held).boxed());
}
Frame::Event {
out,
raw_len,
bufferable,
terminal,
} => {
let size = raw_len + out.len();
if window_open && bufferable && !terminal && bytes + size <= response::BOOTSTRAP_MAX_BYTES {
bytes += size;
held.push(Ok(out));
continue;
}
held.push(Ok(out));
if terminal {
return Ok(futures_util::stream::iter(held).boxed());
}
break;
}
}
}
turn.bootstrapping = false;
Ok(futures_util::stream::iter(held).chain(rest(turn)).boxed())
}
impl CodexExecutor {
async fn ensure(
&self,
session: &Arc<Session>,
target: &Target,
headers: &HeaderMap,
model: &str,
model_level_cooling: bool,
wire: Option<&crate::codex_capture::Wire>,
) -> Result<(Arc<Upstream>, Option<HeaderMap>), ExecError> {
if let Some(current) = session.current() {
if current.target.serves(target) {
return Ok((current, None));
}
let mut slot = session.conn.lock().expect("session conn");
if slot.as_ref().is_some_and(|c| Arc::ptr_eq(c, ¤t)) {
*slot = None;
}
drop(slot);
current.shutdown();
}
let (socket, handshake) = self.dial(target, headers, model, model_level_cooling, wire).await?;
let (sink, stream) = socket.split();
let conn = Upstream::new(target.clone(), sink, self.ws.write);
let mut reader = conn.reader.lock().expect("reader handle");
session.publish(conn.clone());
let task = tokio::spawn(read_loop(stream, Arc::downgrade(session), conn.clone(), self.ws.idle));
*reader = Some(task.abort_handle());
drop(reader);
Ok((conn, Some(handshake)))
}
async fn dial(
&self,
target: &Target,
request: &HeaderMap,
model: &str,
model_level_cooling: bool,
wire: Option<&crate::codex_capture::Wire>,
) -> Result<(WebSocket, HeaderMap), ExecError> {
let mut headers = request.clone();
let key = offer_compression(&mut headers);
let builder = self
.transport
.standard(&target.proxy)
.websocket(&target.url)
.headers(headers)
.accept_key(key.clone());
let mut rejected = false;
let attempt = async {
let mut res = builder
.send()
.await
.map_err(|_| transport("codex websockets executor: dial failed"))?;
let status = res.status().as_u16();
let handshake = res.headers().clone();
if status != 101 {
let inner = std::mem::replace(&mut *res, wreq::Response::from(http::Response::new(Vec::<u8>::new())));
let mut body = Vec::new();
let mut stream = inner.bytes_stream();
while let Some(Ok(chunk)) = stream.next().await {
body.extend_from_slice(&chunk[..chunk.len().min(MAX_HANDSHAKE_BODY - body.len())]);
if body.len() >= MAX_HANDSHAKE_BODY {
break;
}
}
self.quota_observe(&target.credential, model, &handshake);
rejected = true;
if let Some(wire) = wire {
wire.upgrade_rejection(&target.url, request, status, &handshake, &body);
}
if status == 426 {
let text = String::from_utf8_lossy(&body).into_owned();
return Err(response::status_error_raw(status, &text, handshake, false));
}
return Err(response::status_error(status, &body, handshake, model_level_cooling));
}
let socket = upgrade(&mut res, &key, &handshake).await.map_err(|e| match e {
UpgradeError::Handshake => transport("codex websockets executor: websocket handshake failed"),
UpgradeError::Compression => {
transport("codex websockets executor: websocket: invalid compression negotiation")
}
})?;
Ok((socket, handshake))
};
let dialed = tokio::time::timeout(HANDSHAKE_TIMEOUT, attempt)
.await
.unwrap_or_else(|_| Err(transport("codex websockets executor: handshake timed out")));
if let (Err(error), Some(wire)) = (&dialed, wire)
&& !rejected
{
wire.ws_exec_error("dial", error);
}
dialed
}
fn quota_observe(&self, credential: &str, model: &str, headers: &HeaderMap) {
self.quota().observe(credential, model, headers);
}
pub(crate) async fn stream_ws(
&self,
view: &View<'_>,
settings: &Settings,
req: ExecRequest,
exec_session: &ExecSession,
cfg: &Config,
) -> Result<ExecResponse, ExecError> {
let model = request::base_model(&req.model).to_owned();
let request::Shaped {
body,
optimized,
conflict,
finalize,
} = request::shape(&req, view, settings, Call::Websocket)?;
let (body, replay) = Replay::apply(&self.replay, &req, body).await;
let (body, cache) = request::prompt_cache(&req, body, Some(&exec_session.id), true);
let body = turn_body(view, &req, settings, &finalize, body);
crate::codex::report_request(&req, cpa_core::format::Format::Codex, &body);
let native = request::is_native(&req);
let headers = request::ws_headers(view, settings, &req.headers, &body, &model, cache.as_deref(), native);
let target = Target::new(view.credential, ws_url(&format!("{}/responses", view.base_url))?, cfg);
let session = self.ws.session(&exec_session.id);
let steering = settings
.response_steering
.then(|| session.steering())
.flatten()
.map(|input| {
let initial =
duplex::Prepared::new(&body, &req.original_body, optimized, conflict, native, replay.clone());
(input, initial)
});
let guard = session.turn.clone().lock_owned().await;
let frame = request_frame(body);
let wire = crate::codex_capture::Wire::new(req.capture(), view.credential)
.with_websocket(req.websocket_emitter("codex", view.credential));
wire.ws_request(&target.url, &headers, frame.as_bytes());
let (mut conn, mut handshake) = if exec_session.continuation {
match session.current().filter(|c| c.target.serves(&target)) {
Some(conn) => (conn, None),
None => return Err(ExecError::replay_required()),
}
} else {
self.ensure(
&session,
&target,
&headers,
&model,
settings.model_level_cooling,
Some(&wire),
)
.await?
};
conn.bind(&session, exec_session.lease.as_ref())?;
if let Some(handshake) = &handshake {
wire.ws_handshake(101, handshake);
}
let started = Instant::now();
let mut rx = conn.activate();
let mut restore = conn.restores(optimized, conflict);
if let Err(error) = conn.send(frame.clone()).await {
wire.ws_exec_error("send", &error);
let retry = error.scope != FailureScope::Request;
if exec_session.continuation {
session.invalidate(&conn, &error, false);
return Err(if retry { ExecError::replay_required() } else { error });
}
session.invalidate(&conn, &error, true);
if !retry {
return Err(error);
}
let (fresh, fresh_handshake) = match self
.ensure(&session, &target, &headers, &model, settings.model_level_cooling, None)
.await
{
Ok(fresh) => fresh,
Err(error) => {
wire.ws_exec_error("dial_retry", &error);
return Err(error);
}
};
fresh.bind(&session, exec_session.lease.as_ref())?;
rx = fresh.activate();
restore = fresh.restores(optimized, conflict);
wire.ws_request(&target.url, &headers, frame.as_bytes());
if let Some(handshake) = &fresh_handshake {
wire.ws_handshake(101, handshake);
}
if let Err(error) = fresh.send(frame).await {
wire.ws_exec_error("send_retry", &error);
session.invalidate(&fresh, &error, true);
return Err(error);
}
conn = fresh;
handshake = fresh_handshake;
}
conn.note_multi_agent(optimized, conflict);
let observed = handshake.clone().unwrap_or_default();
if !observed.is_empty() {
self.quota_observe(&view.credential.id, &model, &observed);
}
let turn = Turn {
rx,
conn,
session,
_turn: Some(guard),
observing: None,
items: OutputItems::default(),
saw_delta: false,
native,
cooling: settings.model_level_cooling,
quota: self.quota_handle(),
credential: view.credential.id.clone(),
observed,
restore,
usage: req.usage.clone(),
model: model.clone(),
replay,
wire,
bootstrapping: false,
};
if let Some((input, initial)) = steering {
let stream = duplex::Duplex::start(turn, input, initial, req, view, settings, &exec_session.id).await;
return Ok(ExecResponse {
status: 200,
headers: handshake.unwrap_or_default(),
body: ResponseBody::Stream(stream),
});
}
let writes = turn.replay.scope.writes.clone();
let stream = if settings.bootstrap_buffering {
match bootstrap(turn, settings.bootstrap_timeout, started).await {
Ok(stream) => stream,
Err(error) => {
writes.settle().await;
return Err(error);
}
}
} else {
rest(turn)
};
Ok(ExecResponse {
status: 200,
headers: handshake.unwrap_or_default(),
body: ResponseBody::Stream(writes.gate(stream)),
})
}
}
fn ends_without_close(error: &tokio_tungstenite::tungstenite::Error) -> bool {
use tokio_tungstenite::tungstenite::Error;
use tokio_tungstenite::tungstenite::error::ProtocolError;
match error {
Error::Protocol(ProtocolError::ResetWithoutClosingHandshake) => true,
Error::Io(io) => io.kind() == std::io::ErrorKind::UnexpectedEof,
_ => false,
}
}
pub(crate) async fn read_loop(
mut stream: SplitStream<WebSocket>,
session: Weak<Session>,
conn: Arc<Upstream>,
idle: Duration,
) {
let error = 'read: loop {
let deadline = tokio::time::Instant::now() + idle;
let text = loop {
let message = match tokio::time::timeout_at(deadline, stream.next()).await {
Err(_) => break 'read transport("codex websockets executor: read idle timeout"),
Ok(None) => break 'read transport(&close_error_text(1006, "unexpected EOF")),
Ok(Some(Err(error))) if ends_without_close(&error) => {
break 'read transport(&close_error_text(1006, "unexpected EOF"));
}
Ok(Some(Err(_))) => break 'read transport("codex websockets executor: read failed"),
Ok(Some(Ok(message))) => message,
};
match message {
Message::Text(text) => break text.as_str().to_owned(),
Message::Binary(_) => break 'read transport(UNEXPECTED_BINARY),
Message::Close(frame) => {
if let Some(frame) = frame.as_ref().filter(|f| u16::from(f.code) == 1009) {
break 'read closed_too_big(frame.reason.as_str());
}
let text = match frame {
Some(frame) => close_error_text(u16::from(frame.code), frame.reason.as_str()),
None => close_error_text(1005, ""),
};
break 'read transport(&text);
}
Message::Ping(_) | Message::Pong(_) | Message::Frame(_) => continue,
}
};
let terminal = terminal_response_id(text.trim());
let active = {
let mut link = conn.link.lock().expect("link");
if let Some(id) = terminal {
link.terminal.insert(id);
}
link.active.clone()
};
if let Some(tx) = active {
let _ = tx.send(Read::Text(text)).await;
}
};
let active = {
let mut link = conn.link.lock().expect("link");
link.lost = Some(error.clone());
link.active.clone()
};
match session.upgrade() {
Some(session) => session.invalidate(&conn, &error, true),
None => conn.deactivate(),
}
if let Some(tx) = active {
let _ = tx.try_send(Read::Failed(turn_error(&error)));
}
}
pub(crate) enum UpgradeError {
Handshake,
Compression,
}
pub(crate) fn offer_compression(headers: &mut HeaderMap) -> String {
headers.insert(
http::header::SEC_WEBSOCKET_EXTENSIONS,
http::HeaderValue::from_static(deflate::OFFER),
);
tokio_tungstenite::tungstenite::handshake::client::generate_key()
}
pub(crate) async fn upgrade(
res: &mut wreq::ws::WebSocketResponse,
key: &str,
handshake: &HeaderMap,
) -> Result<WebSocket, UpgradeError> {
let accept = tokio_tungstenite::tungstenite::handshake::derive_accept_key(key.as_bytes());
if !token_list_contains(handshake, http::header::UPGRADE, "websocket")
|| !token_list_contains(handshake, http::header::CONNECTION, "upgrade")
|| handshake.get(http::header::SEC_WEBSOCKET_ACCEPT).map(|v| v.as_bytes()) != Some(accept.as_bytes())
{
return Err(UpgradeError::Handshake);
}
let compressed = deflate::negotiated(handshake).map_err(|()| UpgradeError::Compression)?;
let response = std::mem::replace(&mut **res, wreq::Response::from(http::Response::new(Vec::<u8>::new())));
let upgraded = response.upgrade().await.map_err(|_| UpgradeError::Handshake)?;
let config = WebSocketConfig::default()
.max_frame_size(Some(MAX_UPSTREAM_MESSAGE))
.max_message_size(Some(MAX_UPSTREAM_MESSAGE));
Ok(WebSocketStream::from_raw_socket(
Inflate::new(upgraded, compressed, MAX_UPSTREAM_MESSAGE),
Role::Client,
Some(config),
)
.await)
}
fn token_list_contains(headers: &HeaderMap, name: http::HeaderName, value: &str) -> bool {
headers.get_all(name).iter().any(|v| {
v.to_str().is_ok_and(|v| {
v.split(',')
.any(|t| t.trim_matches([' ', '\t']).eq_ignore_ascii_case(value))
})
})
}
#[path = "codex_ws_deflate.rs"]
pub(crate) mod deflate;
#[path = "codex_duplex.rs"]
mod duplex;
pub use duplex::{ClientFrames, SteeringInput};
#[cfg(test)]
#[path = "codex_ws_tests.rs"]
mod tests;
#[cfg(test)]
mod close_text_tests {
use super::close_error_text;
#[test]
fn close_errors_read_like_gorilla() {
assert_eq!(close_error_text(1000, ""), "websocket: close 1000 (normal)");
assert_eq!(close_error_text(1001, "bye"), "websocket: close 1001 (going away): bye");
assert_eq!(
close_error_text(1006, "unexpected EOF"),
"websocket: close 1006 (abnormal closure): unexpected EOF"
);
assert_eq!(close_error_text(4000, "x"), "websocket: close 4000: x");
}
}