Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

route OpenAI endpoints across providers

Raine Virta3ccc9f12459c
diff --git a/src/lib.rs b/src/lib.rs
index 802d68a..0bfa1ce 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,6 +3,7 @@ pub mod auth;
pub mod config;
pub mod logging;
pub mod monitor;
+pub mod openai_compat;
pub mod paths;
pub mod project;
pub mod provider;
diff --git a/src/openai_compat/mod.rs b/src/openai_compat/mod.rs
new file mode 100644
index 0000000..84a7263
--- /dev/null
+++ b/src/openai_compat/mod.rs
@@ -0,0 +1,109 @@
+pub mod request;
+pub mod response;
+pub mod stream;
+
+use axum::{
+ Json,
+ http::StatusCode,
+ response::{IntoResponse, Response},
+};
+use serde_json::json;
+
+use crate::provider::{ProviderError, ProviderErrorKind};
+
+pub const MAX_OPENAI_REQUEST_BYTES: usize = 16 * 1024 * 1024;
+pub const MAX_PROVIDER_STREAM_BYTES: usize = 32 * 1024 * 1024;
+pub const MAX_SSE_EVENT_BYTES: usize = 2 * 1024 * 1024;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OpenAiSurface {
+ ChatCompletions,
+ Responses,
+}
+
+impl OpenAiSurface {
+ pub fn label(self) -> &'static str {
+ match self {
+ Self::ChatCompletions => "chat_completions",
+ Self::Responses => "responses",
+ }
+ }
+}
+
+#[derive(Debug, Clone)]
+pub struct OpenAiError {
+ pub status: StatusCode,
+ pub kind: Box<str>,
+ pub message: Box<str>,
+ pub param: Option<Box<str>>,
+ pub code: Option<Box<str>>,
+ pub retry_after: Option<Box<str>>,
+}
+
+impl OpenAiError {
+ pub fn invalid(message: impl Into<String>, param: Option<impl Into<String>>) -> Self {
+ Self {
+ status: StatusCode::BAD_REQUEST,
+ kind: "invalid_request_error".into(),
+ message: message.into().into_boxed_str(),
+ param: param.map(|value| value.into().into_boxed_str()),
+ code: None,
+ retry_after: None,
+ }
+ }
+
+ pub fn unsupported(param: impl Into<String>) -> Self {
+ let param = param.into();
+ Self {
+ status: StatusCode::BAD_REQUEST,
+ kind: "invalid_request_error".into(),
+ message: format!("Unsupported parameter: '{param}'").into(),
+ param: Some(param.into()),
+ code: Some("unsupported_parameter".into()),
+ retry_after: None,
+ }
+ }
+
+ pub fn response(self) -> Response {
+ let status = self.status;
+ let retry_after = self.retry_after.clone();
+ let mut response = (
+ status,
+ Json(json!({
+ "error": {
+ "message": self.message,
+ "type": self.kind,
+ "param": self.param,
+ "code": self.code,
+ }
+ })),
+ )
+ .into_response();
+ if let Some(value) = retry_after.and_then(|value| value.parse().ok()) {
+ response
+ .headers_mut()
+ .insert(http::header::RETRY_AFTER, value);
+ }
+ response
+ }
+}
+
+impl From<ProviderError> for OpenAiError {
+ fn from(error: ProviderError) -> Self {
+ Self {
+ status: error.status,
+ kind: match error.kind {
+ ProviderErrorKind::Authentication => "authentication_error",
+ ProviderErrorKind::Permission => "permission_error",
+ ProviderErrorKind::RateLimit => "rate_limit_error",
+ ProviderErrorKind::InvalidRequest => "invalid_request_error",
+ ProviderErrorKind::Api => "api_error",
+ }
+ .into(),
+ message: error.message.into(),
+ param: error.param.map(Into::into),
+ code: error.code.map(Into::into),
+ retry_after: error.retry_after.map(Into::into),
+ }
+ }
+}
diff --git a/src/openai_compat/request.rs b/src/openai_compat/request.rs
new file mode 100644
index 0000000..3d9e103
--- /dev/null
+++ b/src/openai_compat/request.rs
@@ -0,0 +1,1155 @@
+use std::collections::HashSet;
+
+use serde_json::{Map, Value, json};
+
+use crate::{
+ anthropic::schema::{Message, MessagesRequest},
+ registry::normalize_incoming_model,
+};
+
+use super::{OpenAiError, OpenAiSurface};
+
+const MAX_MESSAGES: usize = 1_024;
+const MAX_TOOLS: usize = 128;
+const MAX_TOOL_ARGUMENT_BYTES: usize = 1024 * 1024;
+const MAX_IMAGE_DATA_BYTES: usize = 12 * 1024 * 1024;
+
+const CHAT_FIELDS: &[&str] = &[
+ "model",
+ "messages",
+ "stream",
+ "stream_options",
+ "max_tokens",
+ "max_completion_tokens",
+ "tools",
+ "tool_choice",
+ "reasoning_effort",
+ "n",
+ "parallel_tool_calls",
+];
+
+const RESPONSES_FIELDS: &[&str] = &[
+ "model",
+ "input",
+ "instructions",
+ "stream",
+ "max_output_tokens",
+ "tools",
+ "tool_choice",
+ "parallel_tool_calls",
+ "reasoning",
+ "store",
+];
+
+#[derive(Debug, Clone)]
+pub struct ParsedOpenAiRequest {
+ pub messages: MessagesRequest,
+ pub requested_model: String,
+ pub normalized_model: String,
+ pub stream: bool,
+ pub include_usage: bool,
+}
+
+pub fn extract_model(body: &Value) -> Result<(String, String), OpenAiError> {
+ let object = body.as_object().ok_or_else(|| {
+ OpenAiError::invalid("Request body must be a JSON object", None::<String>)
+ })?;
+ let requested = object
+ .get("model")
+ .and_then(Value::as_str)
+ .filter(|model| !model.is_empty())
+ .ok_or_else(|| OpenAiError::invalid("Missing or invalid 'model'", Some("model")))?
+ .to_string();
+ Ok((requested.clone(), normalize_incoming_model(&requested)))
+}
+
+pub fn parse_request(
+ surface: OpenAiSurface,
+ body: Value,
+ provider: &str,
+ session_id: Option<&str>,
+) -> Result<ParsedOpenAiRequest, OpenAiError> {
+ let (requested_model, normalized_model) = extract_model(&body)?;
+ let object = body
+ .as_object()
+ .expect("extract_model validated request object");
+ reject_fields(
+ object,
+ match surface {
+ OpenAiSurface::ChatCompletions => CHAT_FIELDS,
+ OpenAiSurface::Responses => RESPONSES_FIELDS,
+ },
+ )?;
+ let stream = optional_bool(object, "stream")?.unwrap_or(false);
+ let mut include_usage = false;
+ let (messages, system) = match surface {
+ OpenAiSurface::ChatCompletions => {
+ include_usage = parse_stream_options(object.get("stream_options"), stream)?;
+ parse_chat_messages(object.get("messages"))?
+ }
+ OpenAiSurface::Responses => {
+ parse_responses_input(object.get("input"), object.get("instructions"))?
+ }
+ };
+ if messages.is_empty() {
+ return Err(OpenAiError::invalid(
+ match surface {
+ OpenAiSurface::ChatCompletions => "'messages' must contain at least one message",
+ OpenAiSurface::Responses => "'input' must contain at least one input item",
+ },
+ Some(match surface {
+ OpenAiSurface::ChatCompletions => "messages",
+ OpenAiSurface::Responses => "input",
+ }),
+ ));
+ }
+ if messages.len() > MAX_MESSAGES {
+ return Err(OpenAiError::invalid(
+ format!("Request contains more than {MAX_MESSAGES} messages"),
+ Some(match surface {
+ OpenAiSurface::ChatCompletions => "messages",
+ OpenAiSurface::Responses => "input",
+ }),
+ ));
+ }
+ validate_single_choice(object)?;
+ validate_parallel_tools(object)?;
+ let max_tokens = parse_max_tokens(surface, object)?;
+ let tools = parse_tools(object.get("tools"), surface)?;
+ let tool_choice = parse_tool_choice(object.get("tool_choice"), &tools, surface)?;
+ let effort = parse_effort(surface, object)?;
+ validate_cursor(provider, session_id, &messages, &tools)?;
+
+ let mut extra = Map::new();
+ if !system.is_empty() {
+ extra.insert(
+ "system".to_string(),
+ Value::Array(
+ system
+ .into_iter()
+ .map(|text| json!({"type":"text", "text":text}))
+ .collect(),
+ ),
+ );
+ }
+ if !tools.is_empty() {
+ extra.insert("tools".to_string(), Value::Array(tools));
+ }
+ if let Some(choice) = tool_choice {
+ extra.insert("tool_choice".to_string(), choice);
+ }
+ if let Some(effort) = effort {
+ extra.insert("output_config".to_string(), json!({"effort":effort}));
+ }
+
+ Ok(ParsedOpenAiRequest {
+ messages: MessagesRequest {
+ model: Some(normalized_model.clone()),
+ max_tokens,
+ messages,
+ stream: true,
+ bypass_provider_model_override: false,
+ extra,
+ },
+ requested_model,
+ normalized_model,
+ stream,
+ include_usage,
+ })
+}
+
+fn reject_fields(object: &Map<String, Value>, allowed: &[&str]) -> Result<(), OpenAiError> {
+ for (key, value) in object {
+ if !allowed.contains(&key.as_str()) && !value.is_null() {
+ return Err(OpenAiError::unsupported(key));
+ }
+ }
+ Ok(())
+}
+
+fn optional_bool(
+ object: &Map<String, Value>,
+ key: &'static str,
+) -> Result<Option<bool>, OpenAiError> {
+ match object.get(key) {
+ None | Some(Value::Null) => Ok(None),
+ Some(Value::Bool(value)) => Ok(Some(*value)),
+ Some(_) => Err(OpenAiError::invalid(
+ format!("'{key}' must be a boolean"),
+ Some(key),
+ )),
+ }
+}
+
+fn parse_stream_options(value: Option<&Value>, stream: bool) -> Result<bool, OpenAiError> {
+ let Some(value) = value.filter(|value| !value.is_null()) else {
+ return Ok(false);
+ };
+ if !stream {
+ return Err(OpenAiError::invalid(
+ "'stream_options' is only supported when 'stream' is true",
+ Some("stream_options"),
+ ));
+ }
+ let object = value.as_object().ok_or_else(|| {
+ OpenAiError::invalid("'stream_options' must be an object", Some("stream_options"))
+ })?;
+ reject_fields(object, &["include_usage"])?;
+ optional_bool(object, "include_usage").map(|value| value.unwrap_or(false))
+}
+
+fn validate_single_choice(object: &Map<String, Value>) -> Result<(), OpenAiError> {
+ match object.get("n") {
+ None | Some(Value::Null) => Ok(()),
+ Some(Value::Number(number)) if number.as_u64() == Some(1) => Ok(()),
+ Some(Value::Number(_)) => Err(OpenAiError::unsupported("n")),
+ Some(_) => Err(OpenAiError::invalid("'n' must be an integer", Some("n"))),
+ }
+}
+
+fn validate_parallel_tools(object: &Map<String, Value>) -> Result<(), OpenAiError> {
+ match object.get("parallel_tool_calls") {
+ None | Some(Value::Null) | Some(Value::Bool(false)) => Ok(()),
+ Some(Value::Bool(true)) => Err(OpenAiError::unsupported("parallel_tool_calls")),
+ Some(_) => Err(OpenAiError::invalid(
+ "'parallel_tool_calls' must be a boolean",
+ Some("parallel_tool_calls"),
+ )),
+ }
+}
+
+fn parse_max_tokens(
+ surface: OpenAiSurface,
+ object: &Map<String, Value>,
+) -> Result<Option<u32>, OpenAiError> {
+ let (primary, alternate) = match surface {
+ OpenAiSurface::ChatCompletions => ("max_completion_tokens", Some("max_tokens")),
+ OpenAiSurface::Responses => ("max_output_tokens", None),
+ };
+ if let Some(alternate) = alternate
+ && object.get(primary).is_some_and(|value| !value.is_null())
+ && object.get(alternate).is_some_and(|value| !value.is_null())
+ {
+ return Err(OpenAiError::invalid(
+ format!("'{primary}' and '{alternate}' cannot both be set"),
+ Some(primary),
+ ));
+ }
+ let (key, value) = object
+ .get(primary)
+ .filter(|value| !value.is_null())
+ .map(|value| (primary, value))
+ .or_else(|| {
+ alternate.and_then(|key| {
+ object
+ .get(key)
+ .filter(|value| !value.is_null())
+ .map(|value| (key, value))
+ })
+ })
+ .unwrap_or((primary, &Value::Null));
+ if value.is_null() {
+ return Ok(None);
+ }
+ let value = value.as_u64().filter(|value| *value > 0).ok_or_else(|| {
+ OpenAiError::invalid(format!("'{key}' must be a positive integer"), Some(key))
+ })?;
+ u32::try_from(value)
+ .map(Some)
+ .map_err(|_| OpenAiError::invalid(format!("'{key}' is too large"), Some(key)))
+}
+
+fn parse_effort(
+ surface: OpenAiSurface,
+ object: &Map<String, Value>,
+) -> Result<Option<String>, OpenAiError> {
+ let value = match surface {
+ OpenAiSurface::ChatCompletions => object.get("reasoning_effort"),
+ OpenAiSurface::Responses => {
+ let Some(reasoning) = object.get("reasoning").filter(|value| !value.is_null()) else {
+ return Ok(None);
+ };
+ let reasoning = reasoning.as_object().ok_or_else(|| {
+ OpenAiError::invalid("'reasoning' must be an object", Some("reasoning"))
+ })?;
+ reject_fields(reasoning, &["effort"])?;
+ reasoning.get("effort")
+ }
+ };
+ let Some(value) = value.filter(|value| !value.is_null()) else {
+ return Ok(None);
+ };
+ let effort = value.as_str().ok_or_else(|| {
+ OpenAiError::invalid(
+ "Reasoning effort must be a string",
+ Some("reasoning_effort"),
+ )
+ })?;
+ match effort {
+ "low" | "medium" | "high" | "xhigh" | "max" => Ok(Some(effort.to_string())),
+ _ => Err(OpenAiError::invalid(
+ format!("Unsupported reasoning effort: '{effort}'"),
+ Some(match surface {
+ OpenAiSurface::ChatCompletions => "reasoning_effort",
+ OpenAiSurface::Responses => "reasoning.effort",
+ }),
+ )),
+ }
+}
+
+fn parse_chat_messages(value: Option<&Value>) -> Result<(Vec<Message>, Vec<String>), OpenAiError> {
+ let messages = value
+ .and_then(Value::as_array)
+ .ok_or_else(|| OpenAiError::invalid("Missing or invalid 'messages'", Some("messages")))?;
+ let mut out = Vec::new();
+ let mut system = Vec::new();
+ let mut calls = HashSet::new();
+ for (index, message) in messages.iter().enumerate() {
+ let param = format!("messages[{index}]");
+ let object = message
+ .as_object()
+ .ok_or_else(|| OpenAiError::invalid("Each message must be an object", Some(&param)))?;
+ reject_nested_fields(
+ object,
+ &[
+ "role",
+ "content",
+ "name",
+ "tool_calls",
+ "tool_call_id",
+ "reasoning_content",
+ ],
+ &param,
+ )?;
+ let role = required_string(object, "role", &format!("{param}.role"))?;
+ match role.as_str() {
+ "system" | "developer" => {
+ system.push(content_text(
+ object.get("content"),
+ &format!("{param}.content"),
+ )?);
+ }
+ "user" => out.push(Message {
+ role: "user".to_string(),
+ content: parse_content(object.get("content"), &format!("{param}.content"), true)?,
+ }),
+ "assistant" => {
+ let mut blocks = Vec::new();
+ if let Some(reasoning) = object
+ .get("reasoning_content")
+ .filter(|value| !value.is_null())
+ {
+ let reasoning = reasoning.as_str().ok_or_else(|| {
+ OpenAiError::invalid(
+ "'reasoning_content' must be a string",
+ Some(format!("{param}.reasoning_content")),
+ )
+ })?;
+ blocks.push(json!({"type":"thinking", "thinking":reasoning}));
+ }
+ append_text_blocks(
+ &mut blocks,
+ object.get("content"),
+ &format!("{param}.content"),
+ )?;
+ parse_chat_tool_calls(object.get("tool_calls"), &param, &mut blocks, &mut calls)?;
+ if blocks.is_empty() {
+ return Err(OpenAiError::invalid(
+ "Assistant message requires content or tool calls",
+ Some(format!("{param}.content")),
+ ));
+ }
+ out.push(Message {
+ role: "assistant".to_string(),
+ content: Value::Array(blocks),
+ });
+ }
+ "tool" => {
+ let id = required_string(object, "tool_call_id", &format!("{param}.tool_call_id"))?;
+ if !calls.contains(&id) {
+ return Err(OpenAiError::invalid(
+ format!("Tool result references unknown call '{id}'"),
+ Some(format!("{param}.tool_call_id")),
+ ));
+ }
+ let result = json!({
+ "type":"tool_result",
+ "tool_use_id":id,
+ "content":content_text(object.get("content"), &format!("{param}.content"))?,
+ });
+ push_tool_result(&mut out, result);
+ }
+ _ => {
+ return Err(OpenAiError::invalid(
+ format!("Unsupported message role: '{role}'"),
+ Some(format!("{param}.role")),
+ ));
+ }
+ }
+ }
+ Ok((out, system))
+}
+
+fn parse_responses_input(
+ value: Option<&Value>,
+ instructions: Option<&Value>,
+) -> Result<(Vec<Message>, Vec<String>), OpenAiError> {
+ let mut system = Vec::new();
+ if let Some(instructions) = instructions.filter(|value| !value.is_null()) {
+ system.push(
+ instructions
+ .as_str()
+ .filter(|text| !text.is_empty())
+ .ok_or_else(|| {
+ OpenAiError::invalid(
+ "'instructions' must be a non-empty string",
+ Some("instructions"),
+ )
+ })?
+ .to_string(),
+ );
+ }
+ let Some(value) = value else {
+ return Err(OpenAiError::invalid("Missing 'input'", Some("input")));
+ };
+ if let Some(text) = value.as_str() {
+ if text.is_empty() {
+ return Err(OpenAiError::invalid(
+ "'input' must not be empty",
+ Some("input"),
+ ));
+ }
+ return Ok((
+ vec![Message {
+ role: "user".to_string(),
+ content: Value::String(text.to_string()),
+ }],
+ system,
+ ));
+ }
+ let items = value
+ .as_array()
+ .ok_or_else(|| OpenAiError::invalid("'input' must be a string or array", Some("input")))?;
+ let mut out = Vec::new();
+ let mut calls = HashSet::new();
+ for (index, item) in items.iter().enumerate() {
+ let param = format!("input[{index}]");
+ let object = item
+ .as_object()
+ .ok_or_else(|| OpenAiError::invalid("Input items must be objects", Some(&param)))?;
+ let kind = object
+ .get("type")
+ .and_then(Value::as_str)
+ .unwrap_or("message");
+ match kind {
+ "message" => {
+ reject_nested_fields(object, &["type", "role", "content", "id", "status"], &param)?;
+ let role = required_string(object, "role", &format!("{param}.role"))?;
+ let content = parse_responses_message_content(
+ object.get("content"),
+ &format!("{param}.content"),
+ )?;
+ match role.as_str() {
+ "system" | "developer" => system.push(blocks_text(&content)),
+ "user" | "assistant" => out.push(Message {
+ role,
+ content: Value::Array(content),
+ }),
+ _ => {
+ return Err(OpenAiError::invalid(
+ format!("Unsupported input message role: '{role}'"),
+ Some(format!("{param}.role")),
+ ));
+ }
+ }
+ }
+ "function_call" => {
+ reject_nested_fields(
+ object,
+ &["type", "id", "call_id", "name", "arguments", "status"],
+ &param,
+ )?;
+ let id = object
+ .get("call_id")
+ .or_else(|| object.get("id"))
+ .and_then(Value::as_str)
+ .filter(|id| !id.is_empty())
+ .ok_or_else(|| {
+ OpenAiError::invalid(
+ "Function call requires 'call_id'",
+ Some(format!("{param}.call_id")),
+ )
+ })?
+ .to_string();
+ if !calls.insert(id.clone()) {
+ return Err(OpenAiError::invalid(
+ format!("Duplicate function call id '{id}'"),
+ Some(format!("{param}.call_id")),
+ ));
+ }
+ let name = required_string(object, "name", &format!("{param}.name"))?;
+ let input =
+ parse_arguments(object.get("arguments"), &format!("{param}.arguments"))?;
+ out.push(Message {
+ role: "assistant".to_string(),
+ content: json!([{"type":"tool_use", "id":id, "name":name, "input":input}]),
+ });
+ }
+ "function_call_output" => {
+ reject_nested_fields(
+ object,
+ &["type", "id", "call_id", "output", "status"],
+ &param,
+ )?;
+ let id = required_string(object, "call_id", &format!("{param}.call_id"))?;
+ if !calls.contains(&id) {
+ return Err(OpenAiError::invalid(
+ format!("Function output references unknown call '{id}'"),
+ Some(format!("{param}.call_id")),
+ ));
+ }
+ let output = object.get("output").ok_or_else(|| {
+ OpenAiError::invalid(
+ "Function output requires 'output'",
+ Some(format!("{param}.output")),
+ )
+ })?;
+ let content = match output {
+ Value::String(text) => Value::String(text.clone()),
+ value => Value::String(value.to_string()),
+ };
+ push_tool_result(
+ &mut out,
+ json!({"type":"tool_result", "tool_use_id":id, "content":content}),
+ );
+ }
+ _ => return Err(OpenAiError::unsupported(format!("{param}.type"))),
+ }
+ }
+ Ok((out, system))
+}
+
+fn parse_chat_tool_calls(
+ value: Option<&Value>,
+ parent: &str,
+ blocks: &mut Vec<Value>,
+ calls: &mut HashSet<String>,
+) -> Result<(), OpenAiError> {
+ let Some(value) = value.filter(|value| !value.is_null()) else {
+ return Ok(());
+ };
+ let items = value.as_array().ok_or_else(|| {
+ OpenAiError::invalid(
+ "'tool_calls' must be an array",
+ Some(format!("{parent}.tool_calls")),
+ )
+ })?;
+ for (index, item) in items.iter().enumerate() {
+ let param = format!("{parent}.tool_calls[{index}]");
+ let object = item
+ .as_object()
+ .ok_or_else(|| OpenAiError::invalid("Tool calls must be objects", Some(&param)))?;
+ reject_nested_fields(object, &["id", "type", "function"], &param)?;
+ if object.get("type").and_then(Value::as_str) != Some("function") {
+ return Err(OpenAiError::unsupported(format!("{param}.type")));
+ }
+ let id = required_string(object, "id", &format!("{param}.id"))?;
+ if !calls.insert(id.clone()) {
+ return Err(OpenAiError::invalid(
+ format!("Duplicate tool call id '{id}'"),
+ Some(format!("{param}.id")),
+ ));
+ }
+ let function = object
+ .get("function")
+ .and_then(Value::as_object)
+ .ok_or_else(|| {
+ OpenAiError::invalid(
+ "Tool call requires a function object",
+ Some(format!("{param}.function")),
+ )
+ })?;
+ reject_nested_fields(
+ function,
+ &["name", "arguments"],
+ &format!("{param}.function"),
+ )?;
+ let name = required_string(function, "name", &format!("{param}.function.name"))?;
+ let input = parse_arguments(
+ function.get("arguments"),
+ &format!("{param}.function.arguments"),
+ )?;
+ blocks.push(json!({"type":"tool_use", "id":id, "name":name, "input":input}));
+ }
+ Ok(())
+}
+
+fn parse_arguments(value: Option<&Value>, param: &str) -> Result<Value, OpenAiError> {
+ let arguments = value.and_then(Value::as_str).ok_or_else(|| {
+ OpenAiError::invalid("Function arguments must be a JSON string", Some(param))
+ })?;
+ if arguments.len() > MAX_TOOL_ARGUMENT_BYTES {
+ return Err(OpenAiError::invalid(
+ "Function arguments are too large",
+ Some(param),
+ ));
+ }
+ let value: Value = serde_json::from_str(arguments).map_err(|error| {
+ OpenAiError::invalid(
+ format!("Function arguments are invalid JSON: {error}"),
+ Some(param),
+ )
+ })?;
+ if !value.is_object() {
+ return Err(OpenAiError::invalid(
+ "Function arguments must decode to an object",
+ Some(param),
+ ));
+ }
+ Ok(value)
+}
+
+fn parse_tools(value: Option<&Value>, surface: OpenAiSurface) -> Result<Vec<Value>, OpenAiError> {
+ let Some(value) = value.filter(|value| !value.is_null()) else {
+ return Ok(Vec::new());
+ };
+ let tools = value
+ .as_array()
+ .ok_or_else(|| OpenAiError::invalid("'tools' must be an array", Some("tools")))?;
+ if tools.len() > MAX_TOOLS {
+ return Err(OpenAiError::invalid(
+ format!("'tools' cannot contain more than {MAX_TOOLS} entries"),
+ Some("tools"),
+ ));
+ }
+ let mut names = HashSet::new();
+ let mut out = Vec::new();
+ for (index, tool) in tools.iter().enumerate() {
+ let param = format!("tools[{index}]");
+ let object = tool
+ .as_object()
+ .ok_or_else(|| OpenAiError::invalid("Tools must be objects", Some(&param)))?;
+ if object.get("type").and_then(Value::as_str) != Some("function") {
+ return Err(OpenAiError::unsupported(format!("{param}.type")));
+ }
+ let function = match surface {
+ OpenAiSurface::ChatCompletions => {
+ reject_nested_fields(object, &["type", "function"], &param)?;
+ object
+ .get("function")
+ .and_then(Value::as_object)
+ .ok_or_else(|| {
+ OpenAiError::invalid(
+ "Function tool requires a function object",
+ Some(format!("{param}.function")),
+ )
+ })?
+ }
+ OpenAiSurface::Responses => object,
+ };
+ let function_param = match surface {
+ OpenAiSurface::ChatCompletions => format!("{param}.function"),
+ OpenAiSurface::Responses => param.clone(),
+ };
+ reject_nested_fields(
+ function,
+ &["type", "name", "description", "parameters", "strict"],
+ &function_param,
+ )?;
+ if function.get("strict").is_some_and(|value| !value.is_null()) {
+ return Err(OpenAiError::unsupported(format!("{function_param}.strict")));
+ }
+ let name = required_string(function, "name", &format!("{function_param}.name"))?;
+ if !names.insert(name.clone()) {
+ return Err(OpenAiError::invalid(
+ format!("Duplicate tool name '{name}'"),
+ Some(format!("{function_param}.name")),
+ ));
+ }
+ let schema = function
+ .get("parameters")
+ .cloned()
+ .unwrap_or_else(|| json!({"type":"object"}));
+ if !schema.is_object() {
+ return Err(OpenAiError::invalid(
+ "Function parameters must be an object",
+ Some(format!("{function_param}.parameters")),
+ ));
+ }
+ let mut translated = Map::from_iter([
+ ("name".to_string(), Value::String(name)),
+ ("input_schema".to_string(), schema),
+ ]);
+ if let Some(description) = function.get("description").filter(|value| !value.is_null()) {
+ translated.insert(
+ "description".to_string(),
+ Value::String(
+ description
+ .as_str()
+ .ok_or_else(|| {
+ OpenAiError::invalid(
+ "Function description must be a string",
+ Some(format!("{function_param}.description")),
+ )
+ })?
+ .to_string(),
+ ),
+ );
+ }
+ out.push(Value::Object(translated));
+ }
+ Ok(out)
+}
+
+fn parse_tool_choice(
+ value: Option<&Value>,
+ tools: &[Value],
+ surface: OpenAiSurface,
+) -> Result<Option<Value>, OpenAiError> {
+ let Some(value) = value.filter(|value| !value.is_null()) else {
+ return Ok(None);
+ };
+ let translated = if let Some(choice) = value.as_str() {
+ match choice {
+ "auto" => json!({"type":"auto"}),
+ "none" => json!({"type":"none"}),
+ "required" => json!({"type":"any"}),
+ _ => return Err(OpenAiError::unsupported("tool_choice")),
+ }
+ } else {
+ let object = value.as_object().ok_or_else(|| {
+ OpenAiError::invalid(
+ "'tool_choice' must be a string or object",
+ Some("tool_choice"),
+ )
+ })?;
+ let name = match surface {
+ OpenAiSurface::ChatCompletions => {
+ if object.get("type").and_then(Value::as_str) != Some("function") {
+ return Err(OpenAiError::unsupported("tool_choice.type"));
+ }
+ object
+ .get("function")
+ .and_then(Value::as_object)
+ .and_then(|function| function.get("name"))
+ .and_then(Value::as_str)
+ }
+ OpenAiSurface::Responses => {
+ if object.get("type").and_then(Value::as_str) != Some("function") {
+ return Err(OpenAiError::unsupported("tool_choice.type"));
+ }
+ object.get("name").and_then(Value::as_str)
+ }
+ }
+ .filter(|name| !name.is_empty())
+ .ok_or_else(|| OpenAiError::invalid("Tool choice requires a name", Some("tool_choice")))?;
+ if !tools
+ .iter()
+ .any(|tool| tool.get("name").and_then(Value::as_str) == Some(name))
+ {
+ return Err(OpenAiError::invalid(
+ format!("Tool choice references unknown tool '{name}'"),
+ Some("tool_choice"),
+ ));
+ }
+ json!({"type":"tool", "name":name})
+ };
+ Ok(Some(translated))
+}
+
+fn parse_content(
+ value: Option<&Value>,
+ param: &str,
+ allow_images: bool,
+) -> Result<Value, OpenAiError> {
+ match value {
+ Some(Value::String(text)) if !text.is_empty() => Ok(Value::String(text.clone())),
+ Some(Value::Array(parts)) if !parts.is_empty() => {
+ let mut out = Vec::new();
+ for (index, part) in parts.iter().enumerate() {
+ out.push(parse_chat_content_part(
+ part,
+ &format!("{param}[{index}]"),
+ allow_images,
+ )?);
+ }
+ Ok(Value::Array(out))
+ }
+ _ => Err(OpenAiError::invalid(
+ "Message content must not be empty",
+ Some(param),
+ )),
+ }
+}
+
+fn append_text_blocks(
+ out: &mut Vec<Value>,
+ value: Option<&Value>,
+ param: &str,
+) -> Result<(), OpenAiError> {
+ match value {
+ None | Some(Value::Null) => Ok(()),
+ Some(Value::String(text)) if !text.is_empty() => {
+ out.push(json!({"type":"text", "text":text}));
+ Ok(())
+ }
+ Some(Value::Array(parts)) => {
+ for (index, part) in parts.iter().enumerate() {
+ let block = parse_chat_content_part(part, &format!("{param}[{index}]"), false)?;
+ out.push(block);
+ }
+ Ok(())
+ }
+ _ => Err(OpenAiError::invalid(
+ "Invalid assistant content",
+ Some(param),
+ )),
+ }
+}
+
+fn parse_chat_content_part(
+ part: &Value,
+ param: &str,
+ allow_images: bool,
+) -> Result<Value, OpenAiError> {
+ let object = part
+ .as_object()
+ .ok_or_else(|| OpenAiError::invalid("Content parts must be objects", Some(param)))?;
+ match object.get("type").and_then(Value::as_str) {
+ Some("text") => Ok(json!({
+ "type":"text",
+ "text":required_string(object, "text", &format!("{param}.text"))?,
+ })),
+ Some("image_url") if allow_images => {
+ let image = object
+ .get("image_url")
+ .and_then(Value::as_object)
+ .ok_or_else(|| {
+ OpenAiError::invalid(
+ "Image content requires 'image_url'",
+ Some(format!("{param}.image_url")),
+ )
+ })?;
+ image_url_block(
+ image.get("url").and_then(Value::as_str).ok_or_else(|| {
+ OpenAiError::invalid(
+ "Image URL must be a string",
+ Some(format!("{param}.image_url.url")),
+ )
+ })?,
+ &format!("{param}.image_url.url"),
+ )
+ }
+ _ => Err(OpenAiError::unsupported(format!("{param}.type"))),
+ }
+}
+
+fn parse_responses_message_content(
+ value: Option<&Value>,
+ param: &str,
+) -> Result<Vec<Value>, OpenAiError> {
+ if let Some(text) = value.and_then(Value::as_str) {
+ return Ok(vec![json!({"type":"text", "text":text})]);
+ }
+ let parts = value.and_then(Value::as_array).ok_or_else(|| {
+ OpenAiError::invalid("Message content must be a string or array", Some(param))
+ })?;
+ let mut out = Vec::new();
+ for (index, part) in parts.iter().enumerate() {
+ let part_param = format!("{param}[{index}]");
+ let object = part.as_object().ok_or_else(|| {
+ OpenAiError::invalid("Content parts must be objects", Some(&part_param))
+ })?;
+ match object.get("type").and_then(Value::as_str) {
+ Some("input_text" | "output_text" | "text") => out.push(json!({
+ "type":"text",
+ "text":required_string(object, "text", &format!("{part_param}.text"))?,
+ })),
+ Some("input_image") => {
+ let url = object
+ .get("image_url")
+ .or_else(|| object.get("url"))
+ .and_then(Value::as_str)
+ .ok_or_else(|| {
+ OpenAiError::invalid(
+ "Input image requires 'image_url'",
+ Some(format!("{part_param}.image_url")),
+ )
+ })?;
+ out.push(image_url_block(url, &format!("{part_param}.image_url"))?);
+ }
+ _ => return Err(OpenAiError::unsupported(format!("{part_param}.type"))),
+ }
+ }
+ Ok(out)
+}
+
+fn image_url_block(url: &str, param: &str) -> Result<Value, OpenAiError> {
+ if let Some(data) = url.strip_prefix("data:") {
+ let (media_type, encoded) = data.split_once(";base64,").ok_or_else(|| {
+ OpenAiError::invalid("Image data URL must use base64 encoding", Some(param))
+ })?;
+ if encoded.len() > MAX_IMAGE_DATA_BYTES * 4 / 3 + 4 {
+ return Err(OpenAiError::invalid("Image data is too large", Some(param)));
+ }
+ if !matches!(
+ media_type,
+ "image/png" | "image/jpeg" | "image/gif" | "image/webp"
+ ) {
+ return Err(OpenAiError::invalid(
+ format!("Unsupported image media type '{media_type}'"),
+ Some(param),
+ ));
+ }
+ Ok(json!({
+ "type":"image",
+ "source":{"type":"base64", "media_type":media_type, "data":encoded},
+ }))
+ } else if url.starts_with("https://") || url.starts_with("http://") {
+ Ok(json!({"type":"image", "source":{"type":"url", "url":url}}))
+ } else {
+ Err(OpenAiError::invalid(
+ "Image URL must use http, https, or a base64 data URL",
+ Some(param),
+ ))
+ }
+}
+
+fn validate_cursor(
+ provider: &str,
+ session_id: Option<&str>,
+ messages: &[Message],
+ tools: &[Value],
+) -> Result<(), OpenAiError> {
+ if provider != "cursor" {
+ return Ok(());
+ }
+ if messages
+ .iter()
+ .any(|message| contains_url_image(&message.content))
+ {
+ return Err(OpenAiError::unsupported(
+ "input image URL for provider 'cursor'",
+ ));
+ }
+ if tools.is_empty() {
+ return Ok(());
+ }
+ if session_id.is_none_or(str::is_empty) {
+ return Err(OpenAiError::invalid(
+ "Cursor tools require a stable session header",
+ Some("tools"),
+ ));
+ }
+ for (index, tool) in tools.iter().enumerate() {
+ let name = tool.get("name").and_then(Value::as_str).unwrap_or_default();
+ if !matches!(name, "Read" | "Write" | "Bash") {
+ return Err(OpenAiError::invalid(
+ format!("Cursor cannot bridge tool '{name}'"),
+ Some(format!("tools[{index}].function.name")),
+ ));
+ }
+ }
+ Ok(())
+}
+
+fn contains_url_image(content: &Value) -> bool {
+ content.as_array().is_some_and(|blocks| {
+ blocks.iter().any(|block| {
+ block.get("type").and_then(Value::as_str) == Some("image")
+ && block.pointer("/source/type").and_then(Value::as_str) == Some("url")
+ })
+ })
+}
+
+fn push_tool_result(messages: &mut Vec<Message>, result: Value) {
+ if let Some(last) = messages.last_mut()
+ && last.role == "user"
+ && last.content.as_array().is_some_and(|blocks| {
+ blocks
+ .iter()
+ .all(|block| block.get("type").and_then(Value::as_str) == Some("tool_result"))
+ })
+ {
+ last.content
+ .as_array_mut()
+ .expect("checked tool result array")
+ .push(result);
+ } else {
+ messages.push(Message {
+ role: "user".to_string(),
+ content: Value::Array(vec![result]),
+ });
+ }
+}
+
+fn required_string(
+ object: &Map<String, Value>,
+ key: &str,
+ param: &str,
+) -> Result<String, OpenAiError> {
+ object
+ .get(key)
+ .and_then(Value::as_str)
+ .filter(|value| !value.is_empty())
+ .map(str::to_string)
+ .ok_or_else(|| {
+ OpenAiError::invalid(format!("'{param}' must be a non-empty string"), Some(param))
+ })
+}
+
+fn reject_nested_fields(
+ object: &Map<String, Value>,
+ allowed: &[&str],
+ parent: &str,
+) -> Result<(), OpenAiError> {
+ for (key, value) in object {
+ if !allowed.contains(&key.as_str()) && !value.is_null() {
+ return Err(OpenAiError::unsupported(format!("{parent}.{key}")));
+ }
+ }
+ Ok(())
+}
+
+fn content_text(value: Option<&Value>, param: &str) -> Result<String, OpenAiError> {
+ match value {
+ Some(Value::String(text)) if !text.is_empty() => Ok(text.clone()),
+ Some(Value::Array(parts)) => {
+ let mut out = Vec::new();
+ for (index, part) in parts.iter().enumerate() {
+ let object = part.as_object().ok_or_else(|| {
+ OpenAiError::invalid(
+ "Text content parts must be objects",
+ Some(format!("{param}[{index}]")),
+ )
+ })?;
+ if !matches!(
+ object.get("type").and_then(Value::as_str),
+ Some("text" | "input_text" | "output_text")
+ ) {
+ return Err(OpenAiError::unsupported(format!("{param}[{index}].type")));
+ }
+ out.push(required_string(
+ object,
+ "text",
+ &format!("{param}[{index}].text"),
+ )?);
+ }
+ if out.is_empty() {
+ Err(OpenAiError::invalid(
+ "Content must not be empty",
+ Some(param),
+ ))
+ } else {
+ Ok(out.join(""))
+ }
+ }
+ _ => Err(OpenAiError::invalid(
+ "Content must be non-empty text",
+ Some(param),
+ )),
+ }
+}
+
+fn blocks_text(blocks: &[Value]) -> String {
+ blocks
+ .iter()
+ .filter_map(|block| block.get("text").and_then(Value::as_str))
+ .collect::<Vec<_>>()
+ .join("")
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn chat_maps_tools_and_results() {
+ let parsed = parse_request(
+ OpenAiSurface::ChatCompletions,
+ json!({
+ "model":"kimi-k2.6",
+ "messages":[
+ {"role":"user","content":"look up x"},
+ {"role":"assistant","content":null,"tool_calls":[{"id":"call_1","type":"function","function":{"name":"lookup","arguments":"{\"q\":\"x\"}"}}]},
+ {"role":"tool","tool_call_id":"call_1","content":"answer"}
+ ],
+ "tools":[{"type":"function","function":{"name":"lookup","description":"lookup","parameters":{"type":"object"}}}],
+ "tool_choice":{"type":"function","function":{"name":"lookup"}}
+ }),
+ "kimi",
+ Some("session"),
+ )
+ .unwrap();
+ assert_eq!(parsed.messages.extra["tools"][0]["name"], "lookup");
+ assert_eq!(parsed.messages.messages[1].content[0]["type"], "tool_use");
+ assert_eq!(
+ parsed.messages.messages[2].content[0]["type"],
+ "tool_result"
+ );
+ assert_eq!(parsed.messages.extra["tool_choice"]["name"], "lookup");
+ }
+
+ #[test]
+ fn responses_maps_function_items() {
+ let parsed = parse_request(
+ OpenAiSurface::Responses,
+ json!({
+ "model":"grok-4.5",
+ "instructions":"be concise",
+ "input":[
+ {"type":"message","role":"user","content":[{"type":"input_text","text":"hello"}]},
+ {"type":"function_call","call_id":"call_1","name":"lookup","arguments":"{}"},
+ {"type":"function_call_output","call_id":"call_1","output":"done"}
+ ],
+ "reasoning":{"effort":"high"}
+ }),
+ "grok",
+ None,
+ )
+ .unwrap();
+ assert_eq!(parsed.messages.extra["system"][0]["text"], "be concise");
+ assert_eq!(parsed.messages.messages[1].content[0]["type"], "tool_use");
+ assert_eq!(parsed.messages.extra["output_config"]["effort"], "high");
+ }
+
+ #[test]
+ fn rejects_unsupported_fields_and_cursor_tools_without_session() {
+ let error = parse_request(
+ OpenAiSurface::ChatCompletions,
+ json!({"model":"kimi-k2.6","messages":[{"role":"user","content":"x"}],"temperature":0.5}),
+ "kimi",
+ None,
+ )
+ .unwrap_err();
+ assert_eq!(error.param.as_deref(), Some("temperature"));
+ assert_eq!(error.code.as_deref(), Some("unsupported_parameter"));
+
+ let error = parse_request(
+ OpenAiSurface::ChatCompletions,
+ json!({
+ "model":"cursor:gpt-5.5",
+ "messages":[{"role":"user","content":"x"}],
+ "tools":[{"type":"function","function":{"name":"Read","parameters":{"type":"object"}}}]
+ }),
+ "cursor",
+ None,
+ )
+ .unwrap_err();
+ assert_eq!(error.param.as_deref(), Some("tools"));
+ }
+
+ #[test]
+ fn normalizes_model_and_preserves_requested_value() {
+ let parsed = parse_request(
+ OpenAiSurface::Responses,
+ json!({"model":"grok-4.5[1m]","input":"hello"}),
+ "grok",
+ None,
+ )
+ .unwrap();
+ assert_eq!(parsed.requested_model, "grok-4.5[1m]");
+ assert_eq!(parsed.normalized_model, "grok-4.5");
+ assert_eq!(parsed.messages.model.as_deref(), Some("grok-4.5"));
+ }
+}
diff --git a/src/openai_compat/response.rs b/src/openai_compat/response.rs
new file mode 100644
index 0000000..ca142da
--- /dev/null
+++ b/src/openai_compat/response.rs
@@ -0,0 +1,542 @@
+use serde_json::{Value, json};
+
+use super::{OpenAiError, OpenAiSurface};
+
+#[derive(Debug, Clone)]
+pub struct SseEvent {
+ pub event: Option<String>,
+ pub data: Value,
+}
+
+#[derive(Debug, Clone)]
+pub enum BlockKind {
+ Text {
+ text: String,
+ },
+ Thinking {
+ text: String,
+ },
+ Tool {
+ id: String,
+ name: String,
+ arguments: String,
+ },
+}
+
+#[derive(Debug, Clone)]
+pub struct Block {
+ pub index: usize,
+ pub kind: BlockKind,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Usage {
+ pub input_tokens: u64,
+ pub output_tokens: u64,
+ pub cache_read_tokens: u64,
+ pub cache_creation_tokens: u64,
+}
+
+impl Usage {
+ pub fn chat_value(&self) -> Value {
+ json!({
+ "prompt_tokens": self.input_tokens + self.cache_read_tokens,
+ "completion_tokens": self.output_tokens,
+ "total_tokens": self.input_tokens + self.cache_read_tokens + self.output_tokens,
+ "prompt_tokens_details": {"cached_tokens": self.cache_read_tokens},
+ })
+ }
+
+ pub fn responses_value(&self) -> Value {
+ json!({
+ "input_tokens": self.input_tokens + self.cache_read_tokens,
+ "input_tokens_details": {"cached_tokens": self.cache_read_tokens},
+ "output_tokens": self.output_tokens,
+ "output_tokens_details": {"reasoning_tokens": 0},
+ "total_tokens": self.input_tokens + self.cache_read_tokens + self.output_tokens,
+ })
+ }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct AnthropicAccumulator {
+ pub upstream_id: Option<String>,
+ pub model: Option<String>,
+ pub blocks: Vec<Block>,
+ pub stop_reason: Option<String>,
+ pub usage: Usage,
+ pub stopped: bool,
+}
+
+impl AnthropicAccumulator {
+ pub fn apply(&mut self, event: &SseEvent) -> Result<(), OpenAiError> {
+ let kind = event
+ .data
+ .get("type")
+ .and_then(Value::as_str)
+ .or(event.event.as_deref())
+ .unwrap_or_default();
+ match kind {
+ "message_start" => {
+ let message = event.data.get("message").ok_or_else(|| {
+ OpenAiError::invalid(
+ "Provider message_start is missing 'message'",
+ None::<String>,
+ )
+ })?;
+ self.upstream_id = message
+ .get("id")
+ .and_then(Value::as_str)
+ .map(str::to_string);
+ self.model = message
+ .get("model")
+ .and_then(Value::as_str)
+ .map(str::to_string);
+ self.update_usage(message.get("usage"));
+ }
+ "content_block_start" => {
+ let index = required_index(&event.data)?;
+ let block = event.data.get("content_block").ok_or_else(|| {
+ OpenAiError::invalid("Provider content block is missing", None::<String>)
+ })?;
+ let kind = match block.get("type").and_then(Value::as_str) {
+ Some("text") => BlockKind::Text {
+ text: block
+ .get("text")
+ .and_then(Value::as_str)
+ .unwrap_or_default()
+ .to_string(),
+ },
+ Some("thinking") => BlockKind::Thinking {
+ text: block
+ .get("thinking")
+ .and_then(Value::as_str)
+ .unwrap_or_default()
+ .to_string(),
+ },
+ Some("tool_use") => BlockKind::Tool {
+ id: required_block_string(block, "id")?,
+ name: required_block_string(block, "name")?,
+ arguments: block
+ .get("input")
+ .filter(|value| !value.is_null())
+ .map(Value::to_string)
+ .filter(|value| value != "{}")
+ .unwrap_or_default(),
+ },
+ Some(other) => {
+ return Err(OpenAiError::invalid(
+ format!("Unsupported provider output block '{other}'"),
+ None::<String>,
+ ));
+ }
+ None => {
+ return Err(OpenAiError::invalid(
+ "Provider output block has no type",
+ None::<String>,
+ ));
+ }
+ };
+ self.blocks.push(Block { index, kind });
+ }
+ "content_block_delta" => {
+ let index = required_index(&event.data)?;
+ let delta = event.data.get("delta").ok_or_else(|| {
+ OpenAiError::invalid("Provider content delta is missing", None::<String>)
+ })?;
+ let block = self
+ .blocks
+ .iter_mut()
+ .rev()
+ .find(|block| block.index == index)
+ .ok_or_else(|| {
+ OpenAiError::invalid(
+ "Provider delta references an unknown block",
+ None::<String>,
+ )
+ })?;
+ match (delta.get("type").and_then(Value::as_str), &mut block.kind) {
+ (Some("text_delta"), BlockKind::Text { text }) => {
+ text.push_str(
+ delta
+ .get("text")
+ .and_then(Value::as_str)
+ .unwrap_or_default(),
+ );
+ }
+ (Some("thinking_delta"), BlockKind::Thinking { text }) => {
+ text.push_str(
+ delta
+ .get("thinking")
+ .and_then(Value::as_str)
+ .unwrap_or_default(),
+ );
+ }
+ (Some("signature_delta"), BlockKind::Thinking { .. }) => {}
+ (Some("input_json_delta"), BlockKind::Tool { arguments, .. }) => {
+ arguments.push_str(
+ delta
+ .get("partial_json")
+ .and_then(Value::as_str)
+ .unwrap_or_default(),
+ );
+ }
+ _ => {
+ return Err(OpenAiError::invalid(
+ "Provider delta does not match its content block",
+ None::<String>,
+ ));
+ }
+ }
+ }
+ "content_block_stop" => {}
+ "message_delta" => {
+ self.stop_reason = event
+ .data
+ .pointer("/delta/stop_reason")
+ .and_then(Value::as_str)
+ .map(str::to_string);
+ self.update_usage(event.data.get("usage"));
+ }
+ "message_stop" => self.stopped = true,
+ "ping" => {}
+ "error" => {
+ return Err(OpenAiError {
+ status: http::StatusCode::BAD_GATEWAY,
+ kind: event
+ .data
+ .pointer("/error/type")
+ .and_then(Value::as_str)
+ .unwrap_or("api_error")
+ .into(),
+ message: event
+ .data
+ .pointer("/error/message")
+ .and_then(Value::as_str)
+ .unwrap_or("Provider stream failed")
+ .into(),
+ param: None,
+ code: None,
+ retry_after: None,
+ });
+ }
+ other if !other.is_empty() => {
+ return Err(OpenAiError::invalid(
+ format!("Unsupported provider stream event '{other}'"),
+ None::<String>,
+ ));
+ }
+ _ => {}
+ }
+ Ok(())
+ }
+
+ fn update_usage(&mut self, usage: Option<&Value>) {
+ let Some(usage) = usage else { return };
+ if let Some(value) = usage.get("input_tokens").and_then(Value::as_u64) {
+ self.usage.input_tokens = value;
+ }
+ if let Some(value) = usage.get("output_tokens").and_then(Value::as_u64) {
+ self.usage.output_tokens = value;
+ }
+ if let Some(value) = usage.get("cache_read_input_tokens").and_then(Value::as_u64) {
+ self.usage.cache_read_tokens = value;
+ }
+ if let Some(value) = usage
+ .get("cache_creation_input_tokens")
+ .and_then(Value::as_u64)
+ {
+ self.usage.cache_creation_tokens = value;
+ }
+ }
+}
+
+pub fn buffered_response(
+ surface: OpenAiSurface,
+ events: &[SseEvent],
+ response_id: &str,
+ model: &str,
+ created: u64,
+) -> Result<Value, OpenAiError> {
+ let mut state = AnthropicAccumulator::default();
+ for event in events {
+ state.apply(event)?;
+ }
+ if !state.stopped {
+ return Err(OpenAiError::invalid(
+ "Provider stream ended before message_stop",
+ None::<String>,
+ ));
+ }
+ match surface {
+ OpenAiSurface::ChatCompletions => Ok(chat_response(&state, response_id, model, created)),
+ OpenAiSurface::Responses => Ok(responses_response(&state, response_id, model, created)),
+ }
+}
+
+pub fn chat_response(
+ state: &AnthropicAccumulator,
+ response_id: &str,
+ model: &str,
+ created: u64,
+) -> Value {
+ let content = state
+ .blocks
+ .iter()
+ .filter_map(|block| match &block.kind {
+ BlockKind::Text { text } => Some(text.as_str()),
+ _ => None,
+ })
+ .collect::<String>();
+ let reasoning = state
+ .blocks
+ .iter()
+ .filter_map(|block| match &block.kind {
+ BlockKind::Thinking { text } => Some(text.as_str()),
+ _ => None,
+ })
+ .collect::<String>();
+ let tools: Vec<Value> = state
+ .blocks
+ .iter()
+ .filter_map(|block| match &block.kind {
+ BlockKind::Tool {
+ id,
+ name,
+ arguments,
+ } => Some(json!({
+ "id":id,
+ "type":"function",
+ "function":{"name":name, "arguments":normalized_arguments(arguments)},
+ })),
+ _ => None,
+ })
+ .collect();
+ let mut message = serde_json::Map::from_iter([
+ ("role".to_string(), json!("assistant")),
+ (
+ "content".to_string(),
+ if content.is_empty() {
+ Value::Null
+ } else {
+ Value::String(content)
+ },
+ ),
+ ("refusal".to_string(), Value::Null),
+ ]);
+ if !reasoning.is_empty() {
+ message.insert("reasoning_content".to_string(), Value::String(reasoning));
+ }
+ if !tools.is_empty() {
+ message.insert("tool_calls".to_string(), Value::Array(tools));
+ }
+ json!({
+ "id":response_id,
+ "object":"chat.completion",
+ "created":created,
+ "model":model,
+ "choices":[{
+ "index":0,
+ "message":message,
+ "finish_reason":chat_finish_reason(state.stop_reason.as_deref()),
+ "logprobs":null,
+ }],
+ "usage":state.usage.chat_value(),
+ })
+}
+
+pub fn responses_response(
+ state: &AnthropicAccumulator,
+ response_id: &str,
+ model: &str,
+ created: u64,
+) -> Value {
+ let mut output = Vec::new();
+ let reasoning = state
+ .blocks
+ .iter()
+ .filter_map(|block| match &block.kind {
+ BlockKind::Thinking { text } => Some(text.as_str()),
+ _ => None,
+ })
+ .collect::<String>();
+ if !reasoning.is_empty() {
+ output.push(json!({
+ "id":format!("rs_{}", stable_suffix(response_id, 0)),
+ "type":"reasoning",
+ "summary":[{"type":"summary_text", "text":reasoning}],
+ "status":"completed",
+ }));
+ }
+ let text = state
+ .blocks
+ .iter()
+ .filter_map(|block| match &block.kind {
+ BlockKind::Text { text } => Some(text.as_str()),
+ _ => None,
+ })
+ .collect::<String>();
+ if !text.is_empty() {
+ output.push(json!({
+ "id":format!("msg_{}", stable_suffix(response_id, 1)),
+ "type":"message",
+ "role":"assistant",
+ "status":"completed",
+ "content":[{"type":"output_text", "text":text, "annotations":[]}],
+ }));
+ }
+ for (index, block) in state.blocks.iter().enumerate() {
+ if let BlockKind::Tool {
+ id,
+ name,
+ arguments,
+ } = &block.kind
+ {
+ output.push(json!({
+ "id":format!("fc_{}", stable_suffix(response_id, index + 2)),
+ "type":"function_call",
+ "call_id":id,
+ "name":name,
+ "arguments":normalized_arguments(arguments),
+ "status":"completed",
+ }));
+ }
+ }
+ json!({
+ "id":response_id,
+ "object":"response",
+ "created_at":created,
+ "status":"completed",
+ "model":model,
+ "output":output,
+ "parallel_tool_calls":false,
+ "error":null,
+ "incomplete_details":null,
+ "usage":state.usage.responses_value(),
+ })
+}
+
+pub fn chat_finish_reason(reason: Option<&str>) -> &'static str {
+ match reason {
+ Some("tool_use") => "tool_calls",
+ Some("max_tokens") => "length",
+ _ => "stop",
+ }
+}
+
+pub fn normalized_arguments(arguments: &str) -> String {
+ if arguments.is_empty() {
+ "{}".to_string()
+ } else if serde_json::from_str::<Value>(arguments).is_ok() {
+ arguments.to_string()
+ } else {
+ json!({"value":arguments}).to_string()
+ }
+}
+
+fn stable_suffix(response_id: &str, index: usize) -> String {
+ format!("{}_{index}", response_id.trim_start_matches("resp_"))
+}
+
+fn required_index(value: &Value) -> Result<usize, OpenAiError> {
+ value
+ .get("index")
+ .and_then(Value::as_u64)
+ .and_then(|value| usize::try_from(value).ok())
+ .ok_or_else(|| OpenAiError::invalid("Provider event has an invalid index", None::<String>))
+}
+
+fn required_block_string(block: &Value, key: &str) -> Result<String, OpenAiError> {
+ block
+ .get(key)
+ .and_then(Value::as_str)
+ .filter(|value| !value.is_empty())
+ .map(str::to_string)
+ .ok_or_else(|| {
+ OpenAiError::invalid(
+ format!("Provider tool block has an invalid '{key}'"),
+ None::<String>,
+ )
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn events() -> Vec<SseEvent> {
+ vec![
+ SseEvent {
+ event: Some("message_start".into()),
+ data: json!({"type":"message_start","message":{"id":"msg_1","model":"kimi-k2.6","usage":{"input_tokens":7}}}),
+ },
+ SseEvent {
+ event: Some("content_block_start".into()),
+ data: json!({"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}),
+ },
+ SseEvent {
+ event: Some("content_block_delta".into()),
+ data: json!({"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"hello"}}),
+ },
+ SseEvent {
+ event: Some("content_block_stop".into()),
+ data: json!({"type":"content_block_stop","index":0}),
+ },
+ SseEvent {
+ event: Some("content_block_start".into()),
+ data: json!({"type":"content_block_start","index":1,"content_block":{"type":"tool_use","id":"call_1","name":"lookup","input":{}}}),
+ },
+ SseEvent {
+ event: Some("content_block_delta".into()),
+ data: json!({"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"{\"q\":\"x\"}"}}),
+ },
+ SseEvent {
+ event: Some("content_block_stop".into()),
+ data: json!({"type":"content_block_stop","index":1}),
+ },
+ SseEvent {
+ event: Some("message_delta".into()),
+ data: json!({"type":"message_delta","delta":{"stop_reason":"tool_use"},"usage":{"output_tokens":3}}),
+ },
+ SseEvent {
+ event: Some("message_stop".into()),
+ data: json!({"type":"message_stop"}),
+ },
+ ]
+ }
+
+ #[test]
+ fn renders_chat_tool_calls_and_usage() {
+ let response = buffered_response(
+ OpenAiSurface::ChatCompletions,
+ &events(),
+ "chatcmpl_test",
+ "kimi-k2.6",
+ 1,
+ )
+ .unwrap();
+ assert_eq!(response["choices"][0]["message"]["content"], "hello");
+ assert_eq!(
+ response["choices"][0]["message"]["tool_calls"][0]["function"]["name"],
+ "lookup"
+ );
+ assert_eq!(response["choices"][0]["finish_reason"], "tool_calls");
+ assert_eq!(response["usage"]["total_tokens"], 10);
+ }
+
+ #[test]
+ fn renders_responses_function_items() {
+ let response = buffered_response(
+ OpenAiSurface::Responses,
+ &events(),
+ "resp_test",
+ "kimi-k2.6",
+ 1,
+ )
+ .unwrap();
+ assert_eq!(response["object"], "response");
+ assert_eq!(response["output"][0]["type"], "message");
+ assert_eq!(response["output"][1]["type"], "function_call");
+ assert_eq!(response["usage"]["total_tokens"], 10);
+ }
+}
diff --git a/src/openai_compat/stream.rs b/src/openai_compat/stream.rs
new file mode 100644
index 0000000..4130343
--- /dev/null
+++ b/src/openai_compat/stream.rs
@@ -0,0 +1,688 @@
+use std::{collections::VecDeque, convert::Infallible};
+
+use axum::{
+ Json,
+ body::Body,
+ http::StatusCode,
+ response::{IntoResponse, Response},
+};
+use bytes::{Bytes, BytesMut};
+use http_body_util::BodyExt;
+use serde_json::{Value, json};
+
+use crate::{
+ provider::{Generation, GenerationBody},
+ providers::codex::native::NativeResponseOutcome,
+};
+
+use super::{
+ MAX_PROVIDER_STREAM_BYTES, MAX_SSE_EVENT_BYTES, OpenAiError, OpenAiSurface,
+ response::{
+ AnthropicAccumulator, BlockKind, SseEvent, buffered_response, chat_finish_reason,
+ normalized_arguments, responses_response,
+ },
+};
+
+#[derive(Default)]
+pub struct SseDecoder {
+ pending: BytesMut,
+}
+
+impl SseDecoder {
+ pub fn push(&mut self, bytes: &[u8]) -> Result<Vec<SseEvent>, OpenAiError> {
+ self.pending.extend_from_slice(bytes);
+ if self.pending.len() > MAX_SSE_EVENT_BYTES {
+ return Err(OpenAiError::invalid(
+ "Provider SSE event exceeded the size limit",
+ None::<String>,
+ ));
+ }
+ let mut events = Vec::new();
+ while let Some((position, delimiter_len)) = find_event_delimiter(&self.pending) {
+ let frame = self.pending.split_to(position + delimiter_len);
+ let payload = &frame[..position];
+ if let Some(event) = parse_frame(payload)? {
+ events.push(event);
+ }
+ }
+ Ok(events)
+ }
+
+ pub fn finish(&self) -> Result<(), OpenAiError> {
+ if self.pending.iter().all(u8::is_ascii_whitespace) {
+ Ok(())
+ } else {
+ Err(OpenAiError::invalid(
+ "Provider SSE stream ended with an incomplete event",
+ None::<String>,
+ ))
+ }
+ }
+}
+
+pub async fn openai_response(
+ surface: OpenAiSurface,
+ generation: Generation,
+ stream: bool,
+ include_usage: bool,
+ model: String,
+) -> Result<Response, OpenAiError> {
+ let response_id = match surface {
+ OpenAiSurface::ChatCompletions => format!("chatcmpl-{}", uuid::Uuid::new_v4().simple()),
+ OpenAiSurface::Responses => format!("resp_{}", uuid::Uuid::new_v4().simple()),
+ };
+ let created = current_seconds();
+ if stream {
+ return Ok(streaming_response(
+ surface,
+ generation.body,
+ include_usage,
+ response_id,
+ model,
+ created,
+ ));
+ }
+ let bytes = collect_generation(generation.body).await?;
+ let events = decode_all(&bytes)?;
+ let value = buffered_response(surface, &events, &response_id, &model, created)?;
+ Ok((StatusCode::OK, Json(value)).into_response())
+}
+
+async fn collect_generation(body: GenerationBody) -> Result<Bytes, OpenAiError> {
+ match body {
+ GenerationBody::BufferedSse(bytes) => {
+ if bytes.len() > MAX_PROVIDER_STREAM_BYTES {
+ Err(OpenAiError::invalid(
+ "Provider response exceeded the size limit",
+ None::<String>,
+ ))
+ } else {
+ Ok(bytes)
+ }
+ }
+ GenerationBody::LiveSse(mut body) => {
+ let mut output = BytesMut::new();
+ while let Some(frame) = body.frame().await {
+ let frame = frame.map_err(|error| OpenAiError {
+ status: StatusCode::BAD_GATEWAY,
+ kind: "api_error".into(),
+ message: format!("Provider stream read failed: {error}").into(),
+ param: None,
+ code: None,
+ retry_after: None,
+ })?;
+ if let Ok(data) = frame.into_data() {
+ if output.len().saturating_add(data.len()) > MAX_PROVIDER_STREAM_BYTES {
+ return Err(OpenAiError::invalid(
+ "Provider response exceeded the size limit",
+ None::<String>,
+ ));
+ }
+ output.extend_from_slice(&data);
+ }
+ }
+ Ok(output.freeze())
+ }
+ }
+}
+
+fn decode_all(bytes: &[u8]) -> Result<Vec<SseEvent>, OpenAiError> {
+ let mut decoder = SseDecoder::default();
+ let events = decoder.push(bytes)?;
+ decoder.finish()?;
+ Ok(events)
+}
+
+fn streaming_response(
+ surface: OpenAiSurface,
+ body: GenerationBody,
+ include_usage: bool,
+ response_id: String,
+ model: String,
+ created: u64,
+) -> Response {
+ let outcome = NativeResponseOutcome::default();
+ let state = StreamState {
+ body: match body {
+ GenerationBody::BufferedSse(bytes) => Body::from(bytes),
+ GenerationBody::LiveSse(body) => body,
+ },
+ decoder: SseDecoder::default(),
+ renderer: Renderer::new(surface, include_usage, response_id, model, created),
+ pending: VecDeque::new(),
+ finished: false,
+ bytes: 0,
+ outcome: outcome.clone(),
+ };
+ let stream = futures_util::stream::unfold(state, |mut state| async move {
+ state
+ .next()
+ .await
+ .map(|bytes| (Ok::<Bytes, Infallible>(bytes), state))
+ });
+ let mut response = (
+ [
+ (http::header::CONTENT_TYPE, "text/event-stream"),
+ (http::header::CACHE_CONTROL, "no-cache"),
+ (http::header::CONNECTION, "keep-alive"),
+ ],
+ Body::from_stream(stream),
+ )
+ .into_response();
+ response.extensions_mut().insert(outcome);
+ response
+}
+
+struct StreamState {
+ body: Body,
+ decoder: SseDecoder,
+ renderer: Renderer,
+ pending: VecDeque<Bytes>,
+ finished: bool,
+ bytes: usize,
+ outcome: NativeResponseOutcome,
+}
+
+impl StreamState {
+ async fn next(&mut self) -> Option<Bytes> {
+ loop {
+ if let Some(bytes) = self.pending.pop_front() {
+ return Some(bytes);
+ }
+ if self.finished {
+ return None;
+ }
+ match self.body.frame().await {
+ Some(Ok(frame)) => {
+ let Ok(data) = frame.into_data() else {
+ continue;
+ };
+ self.bytes = self.bytes.saturating_add(data.len());
+ if self.bytes > MAX_PROVIDER_STREAM_BYTES {
+ self.fail(OpenAiError::invalid(
+ "Provider response exceeded the size limit",
+ None::<String>,
+ ));
+ continue;
+ }
+ match self.decoder.push(&data) {
+ Ok(events) => {
+ for event in events {
+ match self.renderer.render(&event) {
+ Ok(frames) => self.pending.extend(frames),
+ Err(error) => {
+ self.fail(error);
+ break;
+ }
+ }
+ }
+ }
+ Err(error) => self.fail(error),
+ }
+ }
+ Some(Err(error)) => self.fail(OpenAiError {
+ status: StatusCode::BAD_GATEWAY,
+ kind: "api_error".into(),
+ message: format!("Provider stream read failed: {error}").into(),
+ param: None,
+ code: None,
+ retry_after: None,
+ }),
+ None => {
+ if let Err(error) = self.decoder.finish() {
+ self.fail(error);
+ } else if !self.renderer.state.stopped {
+ self.fail(OpenAiError::invalid(
+ "Provider stream ended before message_stop",
+ None::<String>,
+ ));
+ } else {
+ self.finished = true;
+ }
+ }
+ }
+ }
+ }
+
+ fn fail(&mut self, error: OpenAiError) {
+ self.outcome.fail(error.message.to_string());
+ self.pending.extend(self.renderer.failure(&error));
+ self.finished = true;
+ }
+}
+
+struct Renderer {
+ surface: OpenAiSurface,
+ include_usage: bool,
+ response_id: String,
+ model: String,
+ created: u64,
+ sequence: u64,
+ state: AnthropicAccumulator,
+ responses_message_started: bool,
+}
+
+impl Renderer {
+ fn new(
+ surface: OpenAiSurface,
+ include_usage: bool,
+ response_id: String,
+ model: String,
+ created: u64,
+ ) -> Self {
+ Self {
+ surface,
+ include_usage,
+ response_id,
+ model,
+ created,
+ sequence: 0,
+ state: AnthropicAccumulator::default(),
+ responses_message_started: false,
+ }
+ }
+
+ fn render(&mut self, event: &SseEvent) -> Result<Vec<Bytes>, OpenAiError> {
+ self.state.apply(event)?;
+ match self.surface {
+ OpenAiSurface::ChatCompletions => self.render_chat(event),
+ OpenAiSurface::Responses => self.render_responses(event),
+ }
+ }
+
+ fn render_chat(&self, event: &SseEvent) -> Result<Vec<Bytes>, OpenAiError> {
+ let kind = event
+ .data
+ .get("type")
+ .and_then(Value::as_str)
+ .unwrap_or_default();
+ let mut out = Vec::new();
+ match kind {
+ "message_start" => out.push(chat_data(json!({
+ "id":self.response_id,
+ "object":"chat.completion.chunk",
+ "created":self.created,
+ "model":self.model,
+ "choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null,"logprobs":null}],
+ }))),
+ "content_block_start" => {
+ let index = event.data.get("index").and_then(Value::as_u64).unwrap_or_default();
+ if let Some(block) = self.state.blocks.iter().rev().find(|block| block.index == index as usize)
+ && let BlockKind::Tool { id, name, .. } = &block.kind
+ {
+ out.push(chat_data(json!({
+ "id":self.response_id,
+ "object":"chat.completion.chunk",
+ "created":self.created,
+ "model":self.model,
+ "choices":[{"index":0,"delta":{"tool_calls":[{"index":index,"id":id,"type":"function","function":{"name":name,"arguments":""}}]},"finish_reason":null,"logprobs":null}],
+ })));
+ }
+ }
+ "content_block_delta" => {
+ let index = event.data.get("index").and_then(Value::as_u64).unwrap_or_default();
+ let delta = event.data.get("delta").unwrap_or(&Value::Null);
+ let payload = match delta.get("type").and_then(Value::as_str) {
+ Some("text_delta") => json!({"content":delta.get("text").and_then(Value::as_str).unwrap_or_default()}),
+ Some("thinking_delta") => json!({"reasoning_content":delta.get("thinking").and_then(Value::as_str).unwrap_or_default()}),
+ Some("input_json_delta") => json!({"tool_calls":[{"index":index,"function":{"arguments":delta.get("partial_json").and_then(Value::as_str).unwrap_or_default()}}]}),
+ Some("signature_delta") => return Ok(out),
+ _ => return Err(OpenAiError::invalid("Unsupported provider content delta", None::<String>)),
+ };
+ out.push(chat_data(json!({
+ "id":self.response_id,
+ "object":"chat.completion.chunk",
+ "created":self.created,
+ "model":self.model,
+ "choices":[{"index":0,"delta":payload,"finish_reason":null,"logprobs":null}],
+ })));
+ }
+ "message_delta" => {
+ let mut chunk = json!({
+ "id":self.response_id,
+ "object":"chat.completion.chunk",
+ "created":self.created,
+ "model":self.model,
+ "choices":[{"index":0,"delta":{},"finish_reason":chat_finish_reason(self.state.stop_reason.as_deref()),"logprobs":null}],
+ });
+ if self.include_usage {
+ chunk["usage"] = self.state.usage.chat_value();
+ }
+ out.push(chat_data(chunk));
+ }
+ "message_stop" => out.push(Bytes::from_static(b"data: [DONE]\n\n")),
+ _ => {}
+ }
+ Ok(out)
+ }
+
+ fn render_responses(&mut self, event: &SseEvent) -> Result<Vec<Bytes>, OpenAiError> {
+ let kind = event
+ .data
+ .get("type")
+ .and_then(Value::as_str)
+ .unwrap_or_default();
+ let mut out = Vec::new();
+ match kind {
+ "message_start" => {
+ let response =
+ response_shell(&self.response_id, &self.model, self.created, "in_progress");
+ out.push(self.responses_event("response.created", json!({"response":response})));
+ out.push(
+ self.responses_event("response.in_progress", json!({"response":response})),
+ );
+ }
+ "content_block_start" => {
+ let index = event
+ .data
+ .get("index")
+ .and_then(Value::as_u64)
+ .unwrap_or_default() as usize;
+ let block = self
+ .state
+ .blocks
+ .iter()
+ .rev()
+ .find(|block| block.index == index)
+ .ok_or_else(|| {
+ OpenAiError::invalid("Provider content block is missing", None::<String>)
+ })?;
+ match &block.kind {
+ BlockKind::Text { .. } => {
+ let item_id = self.message_item_id();
+ if !self.responses_message_started {
+ out.push(self.responses_event("response.output_item.added", json!({
+ "output_index":index,
+ "item":{"id":item_id,"type":"message","role":"assistant","status":"in_progress","content":[]},
+ })));
+ self.responses_message_started = true;
+ }
+ out.push(self.responses_event("response.content_part.added", json!({
+ "item_id":item_id,"output_index":index,"content_index":0,
+ "part":{"type":"output_text","text":"","annotations":[]},
+ })));
+ }
+ BlockKind::Thinking { .. } => out.push(self.responses_event("response.output_item.added", json!({
+ "output_index":index,
+ "item":{"id":self.block_item_id("rs", index),"type":"reasoning","status":"in_progress","summary":[]},
+ }))),
+ BlockKind::Tool { id, name, .. } => out.push(self.responses_event("response.output_item.added", json!({
+ "output_index":index,
+ "item":{"id":self.block_item_id("fc", index),"type":"function_call","call_id":id,"name":name,"arguments":"","status":"in_progress"},
+ }))),
+ }
+ }
+ "content_block_delta" => {
+ let index = event
+ .data
+ .get("index")
+ .and_then(Value::as_u64)
+ .unwrap_or_default() as usize;
+ let delta = event.data.get("delta").unwrap_or(&Value::Null);
+ match delta.get("type").and_then(Value::as_str) {
+ Some("text_delta") => out.push(self.responses_event("response.output_text.delta", json!({
+ "item_id":self.message_item_id(),"output_index":index,"content_index":0,
+ "delta":delta.get("text").and_then(Value::as_str).unwrap_or_default(),"logprobs":[],
+ }))),
+ Some("thinking_delta") => out.push(self.responses_event("response.reasoning_summary_text.delta", json!({
+ "item_id":self.block_item_id("rs", index),"output_index":index,"summary_index":0,
+ "delta":delta.get("thinking").and_then(Value::as_str).unwrap_or_default(),
+ }))),
+ Some("input_json_delta") => out.push(self.responses_event("response.function_call_arguments.delta", json!({
+ "item_id":self.block_item_id("fc", index),"output_index":index,
+ "delta":delta.get("partial_json").and_then(Value::as_str).unwrap_or_default(),
+ }))),
+ Some("signature_delta") => {}
+ _ => return Err(OpenAiError::invalid("Unsupported provider content delta", None::<String>)),
+ }
+ }
+ "content_block_stop" => {
+ let index = event
+ .data
+ .get("index")
+ .and_then(Value::as_u64)
+ .unwrap_or_default() as usize;
+ let block = self
+ .state
+ .blocks
+ .iter()
+ .rev()
+ .find(|block| block.index == index)
+ .cloned()
+ .ok_or_else(|| {
+ OpenAiError::invalid("Provider content block is missing", None::<String>)
+ })?;
+ match block.kind {
+ BlockKind::Text { text } => {
+ out.push(self.responses_event("response.output_text.done", json!({
+ "item_id":self.message_item_id(),"output_index":index,"content_index":0,"text":text,"logprobs":[],
+ })));
+ out.push(self.responses_event("response.content_part.done", json!({
+ "item_id":self.message_item_id(),"output_index":index,"content_index":0,
+ "part":{"type":"output_text","text":text,"annotations":[]},
+ })));
+ out.push(self.responses_event("response.output_item.done", json!({
+ "output_index":index,
+ "item":{"id":self.message_item_id(),"type":"message","role":"assistant","status":"completed","content":[{"type":"output_text","text":text,"annotations":[]}]},
+ })));
+ }
+ BlockKind::Thinking { text } => {
+ out.push(self.responses_event("response.reasoning_summary_text.done", json!({
+ "item_id":self.block_item_id("rs", index),"output_index":index,"summary_index":0,"text":text,
+ })));
+ out.push(self.responses_event("response.output_item.done", json!({
+ "output_index":index,
+ "item":{"id":self.block_item_id("rs", index),"type":"reasoning","status":"completed","summary":[{"type":"summary_text","text":text}]},
+ })));
+ }
+ BlockKind::Tool {
+ id,
+ name,
+ arguments,
+ } => {
+ let arguments = normalized_arguments(&arguments);
+ out.push(self.responses_event("response.function_call_arguments.done", json!({
+ "item_id":self.block_item_id("fc", index),"output_index":index,"arguments":arguments,
+ })));
+ out.push(self.responses_event("response.output_item.done", json!({
+ "output_index":index,
+ "item":{"id":self.block_item_id("fc", index),"type":"function_call","call_id":id,"name":name,"arguments":arguments,"status":"completed"},
+ })));
+ }
+ }
+ }
+ "message_stop" => {
+ let response =
+ responses_response(&self.state, &self.response_id, &self.model, self.created);
+ out.push(self.responses_event("response.completed", json!({"response":response})));
+ }
+ _ => {}
+ }
+ Ok(out)
+ }
+
+ fn failure(&mut self, error: &OpenAiError) -> Vec<Bytes> {
+ match self.surface {
+ OpenAiSurface::ChatCompletions => vec![chat_data(json!({
+ "error":{"message":error.message,"type":error.kind,"param":error.param,"code":error.code}
+ }))],
+ OpenAiSurface::Responses => {
+ let mut response =
+ response_shell(&self.response_id, &self.model, self.created, "failed");
+ response["error"] = json!({"code":error.code,"message":error.message});
+ vec![self.responses_event("response.failed", json!({"response":response}))]
+ }
+ }
+ }
+
+ fn responses_event(&mut self, kind: &str, fields: Value) -> Bytes {
+ let sequence = self.sequence;
+ self.sequence = self.sequence.saturating_add(1);
+ let mut value = fields.as_object().cloned().unwrap_or_default();
+ value.insert("type".to_string(), Value::String(kind.to_string()));
+ value.insert("sequence_number".to_string(), json!(sequence));
+ named_sse(kind, Value::Object(value))
+ }
+
+ fn message_item_id(&self) -> String {
+ format!("msg_{}", self.response_id.trim_start_matches("resp_"))
+ }
+
+ fn block_item_id(&self, prefix: &str, index: usize) -> String {
+ format!(
+ "{prefix}_{}_{index}",
+ self.response_id.trim_start_matches("resp_")
+ )
+ }
+}
+
+fn chat_data(value: Value) -> Bytes {
+ Bytes::from(format!("data: {}\n\n", value))
+}
+
+fn named_sse(kind: &str, value: Value) -> Bytes {
+ Bytes::from(format!("event: {kind}\ndata: {value}\n\n"))
+}
+
+fn response_shell(id: &str, model: &str, created: u64, status: &str) -> Value {
+ json!({
+ "id":id,
+ "object":"response",
+ "created_at":created,
+ "status":status,
+ "model":model,
+ "output":[],
+ "parallel_tool_calls":false,
+ "error":null,
+ "incomplete_details":null,
+ "usage":null,
+ })
+}
+
+fn parse_frame(frame: &[u8]) -> Result<Option<SseEvent>, OpenAiError> {
+ let text = std::str::from_utf8(frame)
+ .map_err(|_| OpenAiError::invalid("Provider SSE event is not UTF-8", None::<String>))?;
+ let mut event = None;
+ let mut data = Vec::new();
+ for line in text.lines() {
+ let line = line.trim_end_matches('\r');
+ if line.starts_with(':') || line.is_empty() {
+ continue;
+ }
+ if let Some(value) = line.strip_prefix("event:") {
+ event = Some(value.trim_start().to_string());
+ } else if let Some(value) = line.strip_prefix("data:") {
+ data.push(value.trim_start());
+ }
+ }
+ if data.is_empty() {
+ return Ok(None);
+ }
+ let data = data.join("\n");
+ if data == "[DONE]" {
+ return Ok(None);
+ }
+ let data = serde_json::from_str(&data).map_err(|error| {
+ OpenAiError::invalid(
+ format!("Provider SSE event contains invalid JSON: {error}"),
+ None::<String>,
+ )
+ })?;
+ Ok(Some(SseEvent { event, data }))
+}
+
+fn find_event_delimiter(bytes: &[u8]) -> Option<(usize, usize)> {
+ bytes
+ .windows(2)
+ .position(|window| window == b"\n\n")
+ .map(|position| (position, 2))
+ .or_else(|| {
+ bytes
+ .windows(4)
+ .position(|window| window == b"\r\n\r\n")
+ .map(|position| (position, 4))
+ })
+}
+
+fn current_seconds() -> u64 {
+ use std::time::{SystemTime, UNIX_EPOCH};
+ SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .unwrap_or_default()
+ .as_secs()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use http_body_util::BodyExt;
+
+ #[test]
+ fn decoder_handles_fragmented_and_batched_events() {
+ let mut decoder = SseDecoder::default();
+ assert!(
+ decoder
+ .push(b"event: message_start\nda")
+ .unwrap()
+ .is_empty()
+ );
+ let events = decoder
+ .push(b"ta: {\"type\":\"message_start\",\"message\":{}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\n")
+ .unwrap();
+ assert_eq!(events.len(), 2);
+ assert_eq!(events[0].event.as_deref(), Some("message_start"));
+ decoder.finish().unwrap();
+ }
+
+ #[tokio::test]
+ async fn chat_stream_emits_tool_deltas_usage_and_done() {
+ let input = concat!(
+ "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_1\",\"usage\":{\"input_tokens\":2}}}\n\n",
+ "event: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"call_1\",\"name\":\"lookup\",\"input\":{}}}\n\n",
+ "event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"{}\"}}\n\n",
+ "event: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\n",
+ "event: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\"},\"usage\":{\"output_tokens\":1}}\n\n",
+ "event: message_stop\ndata: {\"type\":\"message_stop\"}\n\n",
+ );
+ let response = streaming_response(
+ OpenAiSurface::ChatCompletions,
+ GenerationBody::BufferedSse(Bytes::from_static(input.as_bytes())),
+ true,
+ "chatcmpl_test".into(),
+ "kimi-k2.6".into(),
+ 1,
+ );
+ let bytes = response.into_body().collect().await.unwrap().to_bytes();
+ let text = String::from_utf8(bytes.to_vec()).unwrap();
+ assert!(text.contains("tool_calls"));
+ assert!(text.contains("\"finish_reason\":\"tool_calls\""));
+ assert!(text.contains("\"total_tokens\":3"));
+ assert!(text.ends_with("data: [DONE]\n\n"));
+ }
+
+ #[tokio::test]
+ async fn responses_stream_numbers_events_and_completes() {
+ let input = concat!(
+ "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_1\",\"usage\":{}}}\n\n",
+ "event: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}}\n\n",
+ "event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"hi\"}}\n\n",
+ "event: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\n",
+ "event: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\"},\"usage\":{\"output_tokens\":1}}\n\n",
+ "event: message_stop\ndata: {\"type\":\"message_stop\"}\n\n",
+ );
+ let response = streaming_response(
+ OpenAiSurface::Responses,
+ GenerationBody::BufferedSse(Bytes::from_static(input.as_bytes())),
+ false,
+ "resp_test".into(),
+ "grok-4.5".into(),
+ 1,
+ );
+ let bytes = response.into_body().collect().await.unwrap().to_bytes();
+ let text = String::from_utf8(bytes.to_vec()).unwrap();
+ assert!(text.contains("event: response.created"));
+ assert!(text.contains("event: response.output_text.delta"));
+ assert!(text.contains("event: response.completed"));
+ assert!(text.contains("\"sequence_number\":0"));
+ }
+}
diff --git a/src/provider.rs b/src/provider.rs
index ec0c53b..2e57fbc 100644
--- a/src/provider.rs
+++ b/src/provider.rs
@@ -3,7 +3,8 @@ use crate::monitor::MonitorHandle;
use crate::traffic::TrafficCapture;
use anyhow::Result;
use async_trait::async_trait;
-use axum::response::Response;
+use axum::{body::Body, http::StatusCode, response::Response};
+use bytes::Bytes;
use clap::Subcommand;
use std::sync::Arc;
@@ -26,6 +27,73 @@ pub trait Provider: Send + Sync {
fn cli(&self) -> &'static dyn CliHandlers;
async fn handle_messages(&self, body: MessagesRequest, ctx: RequestContext) -> Response;
async fn handle_count_tokens(&self, body: MessagesRequest, ctx: RequestContext) -> Response;
+
+ async fn generate_anthropic_stream(
+ &self,
+ _body: MessagesRequest,
+ _ctx: RequestContext,
+ ) -> Result<Generation, ProviderError> {
+ Err(ProviderError::new(
+ StatusCode::NOT_IMPLEMENTED,
+ ProviderErrorKind::InvalidRequest,
+ format!(
+ "provider '{}' does not support OpenAI-compatible generation",
+ self.name()
+ ),
+ ))
+ }
+}
+
+pub enum GenerationBody {
+ BufferedSse(Bytes),
+ LiveSse(Body),
+}
+
+pub struct Generation {
+ pub body: GenerationBody,
+ pub resolved_model: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ProviderErrorKind {
+ Authentication,
+ Permission,
+ RateLimit,
+ InvalidRequest,
+ Api,
+}
+
+#[derive(Debug, Clone)]
+pub struct ProviderError {
+ pub status: StatusCode,
+ pub kind: ProviderErrorKind,
+ pub message: String,
+ pub retry_after: Option<String>,
+ pub param: Option<String>,
+ pub code: Option<String>,
+}
+
+impl ProviderError {
+ pub fn new(status: StatusCode, kind: ProviderErrorKind, message: impl Into<String>) -> Self {
+ Self {
+ status,
+ kind,
+ message: message.into(),
+ retry_after: None,
+ param: None,
+ code: None,
+ }
+ }
+
+ pub fn error_type(&self) -> &'static str {
+ match self.kind {
+ ProviderErrorKind::Authentication => "authentication_error",
+ ProviderErrorKind::Permission => "permission_error",
+ ProviderErrorKind::RateLimit => "rate_limit_error",
+ ProviderErrorKind::InvalidRequest => "invalid_request_error",
+ ProviderErrorKind::Api => "api_error",
+ }
+ }
}
pub trait CliHandlers: Send + Sync {
diff --git a/src/providers/cursor/mod.rs b/src/providers/cursor/mod.rs
index ec75918..69a8501 100644
--- a/src/providers/cursor/mod.rs
+++ b/src/providers/cursor/mod.rs
@@ -19,7 +19,10 @@ use http::StatusCode;
use crate::anthropic::error::json_error;
use crate::anthropic::schema::{CountTokensResponse, MessagesRequest};
use crate::monitor::usage_from_anthropic_sse;
-use crate::provider::{CliHandlers, Provider, RequestContext};
+use crate::provider::{
+ CliHandlers, Generation, GenerationBody, Provider, ProviderError, ProviderErrorKind,
+ RequestContext,
+};
use crate::providers::cursor::auth::{
clear_cursor_auth, expired_auth_message, load_cursor_auth, missing_auth_message,
run_cursor_login,
@@ -234,6 +237,98 @@ impl Provider for CursorProvider {
)
.into_response()
}
+
+ async fn generate_anthropic_stream(
+ &self,
+ mut body: MessagesRequest,
+ ctx: RequestContext,
+ ) -> Result<Generation, ProviderError> {
+ body.stream = true;
+ let requested = body.model.clone().unwrap_or_else(|| "cursor".to_string());
+ let resolved = resolve_cursor_model(&requested).map_err(|error| {
+ ProviderError::new(
+ StatusCode::BAD_REQUEST,
+ ProviderErrorKind::InvalidRequest,
+ format!("Model \"{requested}\" is not supported: {error}"),
+ )
+ })?;
+ if let Some(monitor) = ctx.monitor.as_ref() {
+ monitor.model_resolved(&ctx.req_id, &resolved.model_id);
+ }
+ let message_id = format!("msg_{}", uuid::Uuid::new_v4().simple());
+ if let Some(session_id) = ctx.session_id.as_deref()
+ && let Some(pending) = BridgeRegistry::pending_tool(session_id)
+ && let Some(result) = find_tool_result(&body, pending.tool_use_id())
+ {
+ let (_, bytes) =
+ resume_cursor_tool_bridge(session_id, &message_id, &requested, result, &pending);
+ return Ok(Generation {
+ body: GenerationBody::BufferedSse(bytes.into()),
+ resolved_model: resolved.model_id,
+ });
+ }
+ let auth = load_cursor_auth()
+ .map_err(|error| {
+ ProviderError::new(
+ StatusCode::UNAUTHORIZED,
+ ProviderErrorKind::Authentication,
+ format!("Cursor auth failed: {error}"),
+ )
+ })?
+ .ok_or_else(|| {
+ ProviderError::new(
+ StatusCode::UNAUTHORIZED,
+ ProviderErrorKind::Authentication,
+ missing_auth_message(),
+ )
+ })?;
+ if matches!(auth.expires, Some(expires) if expires <= now_ms() + 60_000) {
+ return Err(ProviderError::new(
+ StatusCode::UNAUTHORIZED,
+ ProviderErrorKind::Authentication,
+ expired_auth_message(&auth),
+ ));
+ }
+ let prompt = render_cursor_prompt(&body);
+ let images = request::cursor_selected_images(&body);
+ if let Some(monitor) = ctx.monitor.as_ref() {
+ monitor.upstream_started(&ctx.req_id);
+ }
+ let upstream = CursorHttpClient::new()
+ .run_agent(&auth.access_token, &prompt, &requested, &images)
+ .await
+ .map_err(cursor_provider_error)?;
+ let bytes = if can_bridge_cursor_native_tools(&body, ctx.session_id.as_deref()) {
+ let events =
+ decode_upstream_response(&upstream.body).map_err(cursor_decode_provider_error)?;
+ let allowed = advertised_tool_names(&body);
+ start_cursor_tool_bridge(
+ &message_id,
+ &requested,
+ ctx.session_id.as_deref().expect("bridge session validated"),
+ &events,
+ allowed,
+ Box::new(|| uuid::Uuid::new_v4().simple().to_string()),
+ )
+ .0
+ } else {
+ sse::frame_cursor_stream(&upstream, &message_id, &requested)
+ };
+ if let Some(monitor) = ctx.monitor.as_ref() {
+ let (input_tokens, output_tokens) = usage_from_anthropic_sse(&bytes);
+ monitor.stream_progress(
+ &ctx.req_id,
+ bytes.len() as u64,
+ count_sse_events(&bytes),
+ input_tokens,
+ output_tokens,
+ );
+ }
+ Ok(Generation {
+ body: GenerationBody::BufferedSse(bytes.into()),
+ resolved_model: resolved.model_id,
+ })
+ }
}
fn count_sse_events(bytes: &[u8]) -> u64 {
@@ -251,6 +346,28 @@ fn now_ms() -> u64 {
// Error mapping
// ---------------------------------------------------------------------------
+fn cursor_provider_error(err: client::CursorError) -> ProviderError {
+ let (status, kind) = match err.status {
+ 401 | 403 => (StatusCode::UNAUTHORIZED, ProviderErrorKind::Authentication),
+ 429 => (StatusCode::TOO_MANY_REQUESTS, ProviderErrorKind::RateLimit),
+ _ => (StatusCode::BAD_GATEWAY, ProviderErrorKind::Api),
+ };
+ let mut error = ProviderError::new(status, kind, err.detail.unwrap_or(err.message));
+ if err.status == 429 {
+ error.retry_after = Some(err.retry_after.unwrap_or_else(|| "5".to_string()));
+ }
+ error
+}
+
+fn cursor_decode_provider_error(err: CursorDecodeError) -> ProviderError {
+ let (status, kind) = match err.status() {
+ Some(401 | 403) => (StatusCode::UNAUTHORIZED, ProviderErrorKind::Authentication),
+ Some(429) => (StatusCode::TOO_MANY_REQUESTS, ProviderErrorKind::RateLimit),
+ _ => (StatusCode::BAD_GATEWAY, ProviderErrorKind::Api),
+ };
+ ProviderError::new(status, kind, format!("Response decoding error: {err}"))
+}
+
fn map_cursor_error_to_response(err: &client::CursorError) -> Response {
match err.status {
401 | 403 => json_error(
diff --git a/src/providers/grok/mod.rs b/src/providers/grok/mod.rs
index aea839e..63633b7 100644
--- a/src/providers/grok/mod.rs
+++ b/src/providers/grok/mod.rs
@@ -22,7 +22,10 @@ use crate::anthropic::{
schema::{CountTokensResponse, MessagesRequest},
};
use crate::monitor::MonitorHandle;
-use crate::provider::{CliHandlers, Provider, RequestContext};
+use crate::provider::{
+ CliHandlers, Generation, GenerationBody, Provider, ProviderError, ProviderErrorKind,
+ RequestContext,
+};
use crate::{registry::GROK_MODELS, traffic::StreamTrafficCapture};
use self::auth::token_store::file_store;
@@ -187,6 +190,51 @@ impl Provider for GrokProvider {
)
.into_response()
}
+
+ async fn generate_anthropic_stream(
+ &self,
+ mut body: MessagesRequest,
+ ctx: RequestContext,
+ ) -> Result<Generation, ProviderError> {
+ body.stream = true;
+ let requested = body.model.clone().unwrap_or_else(|| "grok-4.5".into());
+ let resolved = resolve_model(&requested);
+ assert_allowed_model(&resolved).map_err(|error| {
+ ProviderError::new(
+ StatusCode::BAD_REQUEST,
+ ProviderErrorKind::InvalidRequest,
+ error.to_string(),
+ )
+ })?;
+ let translated = translate_request(&body, resolved.clone()).map_err(|error| {
+ ProviderError::new(
+ StatusCode::BAD_REQUEST,
+ ProviderErrorKind::InvalidRequest,
+ error.to_string(),
+ )
+ })?;
+ if let Some(monitor) = ctx.monitor.as_ref() {
+ monitor.model_resolved(&ctx.req_id, &resolved);
+ monitor.upstream_started(&ctx.req_id);
+ }
+ let upstream = self
+ .client
+ .post(&translated, ctx.traffic.clone())
+ .await
+ .map_err(grok_provider_error)?;
+ let response = stream_response(
+ upstream,
+ format!("msg_{}", uuid::Uuid::new_v4().simple()),
+ requested,
+ ctx.monitor.clone(),
+ ctx.req_id.clone(),
+ ctx.traffic.clone(),
+ );
+ Ok(Generation {
+ body: GenerationBody::LiveSse(response.into_body()),
+ resolved_model: resolved,
+ })
+ }
}
fn stream_response(
@@ -441,6 +489,22 @@ fn write_error(traffic: Option<&crate::traffic::TrafficCapture>, stage: &str, ki
}
}
+fn grok_provider_error(error: client::GrokError) -> ProviderError {
+ let kind = match error.status {
+ StatusCode::UNAUTHORIZED => ProviderErrorKind::Authentication,
+ StatusCode::TOO_MANY_REQUESTS => ProviderErrorKind::RateLimit,
+ StatusCode::PAYMENT_REQUIRED | StatusCode::FORBIDDEN => ProviderErrorKind::Permission,
+ _ => ProviderErrorKind::Api,
+ };
+ let status = match kind {
+ ProviderErrorKind::Api => StatusCode::BAD_GATEWAY,
+ _ => error.status,
+ };
+ let mut mapped = ProviderError::new(status, kind, error.message);
+ mapped.retry_after = error.retry_after;
+ mapped
+}
+
fn map_error(error: client::GrokError) -> Response {
match error.status {
StatusCode::UNAUTHORIZED => json_error(
diff --git a/src/providers/kimi/mod.rs b/src/providers/kimi/mod.rs
index 956f4d3..7184f16 100644
--- a/src/providers/kimi/mod.rs
+++ b/src/providers/kimi/mod.rs
@@ -12,7 +12,10 @@ use std::time::{SystemTime, UNIX_EPOCH};
use crate::anthropic::error::json_error;
use crate::anthropic::schema::{CountTokensResponse, MessagesRequest};
use crate::monitor::usage_from_anthropic_sse;
-use crate::provider::{CliHandlers, Provider, RequestContext};
+use crate::provider::{
+ CliHandlers, Generation, GenerationBody, Provider, ProviderError, ProviderErrorKind,
+ RequestContext,
+};
use crate::providers::kimi::auth::token_store::file_store;
use crate::providers::kimi::translate::accumulate::accumulate_response;
use crate::providers::kimi::translate::model_allowlist::{assert_allowed_model, resolve_model};
@@ -185,12 +188,105 @@ impl Provider for KimiProvider {
)
.into_response()
}
+
+ async fn generate_anthropic_stream(
+ &self,
+ mut body: MessagesRequest,
+ ctx: RequestContext,
+ ) -> Result<Generation, ProviderError> {
+ body.stream = true;
+ let requested = body
+ .model
+ .clone()
+ .unwrap_or_else(|| "kimi-for-coding".to_string());
+ let resolved = resolve_model(&requested);
+ assert_allowed_model(&resolved).map_err(|error| {
+ ProviderError::new(
+ StatusCode::BAD_REQUEST,
+ ProviderErrorKind::InvalidRequest,
+ format!(
+ "Model \"{requested}\" resolves to unsupported model \"{}\"",
+ error.model
+ ),
+ )
+ })?;
+ if let Some(monitor) = ctx.monitor.as_ref() {
+ monitor.model_resolved(&ctx.req_id, &resolved);
+ }
+ let translated = translate_request(
+ &body,
+ TranslateOptions {
+ session_id: ctx.session_id.clone(),
+ },
+ )
+ .map_err(|error| {
+ ProviderError::new(
+ StatusCode::BAD_REQUEST,
+ ProviderErrorKind::InvalidRequest,
+ error.to_string(),
+ )
+ })?;
+ if let Some(monitor) = ctx.monitor.as_ref() {
+ monitor.upstream_started(&ctx.req_id);
+ }
+ let upstream = tokio::task::spawn_blocking(move || {
+ let client = client::KimiHttpClient::new();
+ let result = client.post_kimi(&translated);
+ drop(client);
+ result
+ })
+ .await
+ .map_err(|error| {
+ ProviderError::new(
+ StatusCode::BAD_GATEWAY,
+ ProviderErrorKind::Api,
+ format!("Blocking task join error: {error}"),
+ )
+ })?
+ .map_err(kimi_provider_error)?;
+ let message_id = format!("msg_{}", uuid::Uuid::new_v4().simple());
+ let sse =
+ translate_stream_bytes(&upstream.body, &message_id, &requested).map_err(|error| {
+ ProviderError::new(
+ StatusCode::BAD_GATEWAY,
+ ProviderErrorKind::Api,
+ format!("Stream translation error: {error}"),
+ )
+ })?;
+ if let Some(monitor) = ctx.monitor.as_ref() {
+ let (input_tokens, output_tokens) = usage_from_anthropic_sse(&sse);
+ monitor.stream_progress(
+ &ctx.req_id,
+ sse.len() as u64,
+ count_sse_events(&sse),
+ input_tokens,
+ output_tokens,
+ );
+ }
+ Ok(Generation {
+ body: GenerationBody::BufferedSse(sse.into()),
+ resolved_model: resolved,
+ })
+ }
}
fn count_sse_events(bytes: &[u8]) -> u64 {
String::from_utf8_lossy(bytes).matches("event:").count() as u64
}
+fn kimi_provider_error(err: client::KimiError) -> ProviderError {
+ let (status, kind) = match err.status {
+ 401 | 403 => (StatusCode::UNAUTHORIZED, ProviderErrorKind::Authentication),
+ 429 => (StatusCode::TOO_MANY_REQUESTS, ProviderErrorKind::RateLimit),
+ _ => (StatusCode::BAD_GATEWAY, ProviderErrorKind::Api),
+ };
+ let mut error = ProviderError::new(status, kind, err.detail.unwrap_or(err.message));
+ if err.status == 429 {
+ error.retry_after = Some(err.retry_after.unwrap_or_else(|| "5".to_string()));
+ }
+ error
+}
+
fn map_kimi_error_to_response(err: &client::KimiError) -> Response {
match err.status {
401 | 403 => json_error(
diff --git a/src/registry.rs b/src/registry.rs
index a20c737..b181200 100644
--- a/src/registry.rs
+++ b/src/registry.rs
@@ -98,6 +98,24 @@ impl Registry {
Self::new(crate::config::alias_provider())
}
+ pub fn from_providers(
+ alias_provider: AliasProvider,
+ providers: impl IntoIterator<Item = Arc<dyn Provider>>,
+ ) -> Self {
+ let mut models = BTreeMap::new();
+ let mut handlers = BTreeMap::new();
+ for provider in providers {
+ let name = provider.name().to_string();
+ models.insert(name.clone(), provider.supported_models());
+ handlers.insert(name, provider);
+ }
+ Self {
+ alias_provider,
+ models,
+ handlers,
+ }
+ }
+
pub fn list_provider_names(&self) -> Vec<String> {
let mut names: Vec<String> = self.handlers.keys().cloned().collect();
names.sort_unstable();
diff --git a/src/server.rs b/src/server.rs
index 46fda05..b895698 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -2,6 +2,11 @@ use crate::{
anthropic::json_error,
logging::{Logger, REDACT_KEYS, create_logger},
monitor::{EndpointKind, MonitorHandle},
+ openai_compat::{
+ MAX_OPENAI_REQUEST_BYTES, OpenAiError, OpenAiSurface,
+ request::{extract_model, parse_request},
+ stream::openai_response as render_openai_response,
+ },
project,
provider::RequestContext,
providers::codex::{
@@ -298,6 +303,7 @@ async fn handler_models(
.map(|(model, provider)| {
json!({
"type": "model",
+ "object": "model",
"id": model,
"display_name": format!("{model} ({provider})"),
})
@@ -308,6 +314,7 @@ async fn handler_models(
data.truncate(limit);
}
Json(json!({
+ "object": "list",
"data": data,
"has_more": has_more,
"first_id": data.first().and_then(|entry| entry.get("id")).cloned(),
@@ -606,7 +613,7 @@ async fn handler_responses(State(state): State<Arc<AppState>>, req: Request<Body
monitor.request_started(&req_id, session_id.clone(), None, EndpointKind::Responses);
}
let request_guard = RequestMonitorGuard::new(state.monitor.clone(), req_id.clone());
- let body_bytes = match axum::body::to_bytes(req.into_body(), usize::MAX).await {
+ let body_bytes = match axum::body::to_bytes(req.into_body(), MAX_OPENAI_REQUEST_BYTES).await {
Ok(bytes) => bytes,
Err(error) => {
let response = openai_error(
@@ -641,54 +648,80 @@ async fn handler_responses(State(state): State<Arc<AppState>>, req: Request<Body
return monitor_response_body(response, request_guard);
}
};
- if let Err(response) = validate_native_request_model(&body) {
- log_native_request_completed(
- &log,
- &req_id,
- "responses",
- None,
- response.status(),
- started_at,
- );
- return monitor_response_body(response, request_guard);
- }
- let model = body
- .get("model")
- .and_then(Value::as_str)
- .map(normalize_incoming_model);
- let effort = body
- .pointer("/reasoning/effort")
- .and_then(Value::as_str)
- .map(str::to_string);
+ let (requested_model, normalized_model) = match extract_model(&body) {
+ Ok(model) => model,
+ Err(error) => return monitor_response_body(error.response(), request_guard),
+ };
let now = current_millis();
- let session_state = if let Some(session_id) = session_id.as_deref() {
- session::existing_session(Some(session_id), now)
- } else {
- None
+ let session_state = session::existing_session(session_id.as_deref(), now);
+ let affinity = session_state
+ .as_ref()
+ .and_then(|session| session.affinity_provider.as_ref());
+ let Some(provider) = state
+ .registry
+ .provider_for_model(&normalized_model, affinity)
+ else {
+ let response = OpenAiError::invalid(
+ format!(
+ "Unknown model \"{normalized_model}\". {}",
+ state.registry.unknown_model_message()
+ ),
+ Some("model"),
+ )
+ .response();
+ return monitor_response_body(response, request_guard);
};
- let current = model.as_deref().and_then(|model| {
- session::record_session_request(
+ let parsed = if provider.name() == "codex" {
+ if let Err(response) = validate_native_request_model(&body) {
+ return monitor_response_body(response, request_guard);
+ }
+ None
+ } else {
+ match parse_request(
+ OpenAiSurface::Responses,
+ body.clone(),
+ provider.name(),
session_id.as_deref(),
- session_state.as_ref(),
- "codex",
- model,
- now,
- )
- });
+ ) {
+ Ok(parsed) => Some(parsed),
+ Err(error) => return monitor_response_body(error.response(), request_guard),
+ }
+ };
+ if provider.name() != "codex"
+ && let Some(session_id) = session_id.as_deref()
+ {
+ crate::providers::codex::clear_session_compaction(session_id);
+ }
+ let current = session::record_session_request(
+ session_id.as_deref(),
+ session_state.as_ref(),
+ provider.name(),
+ &normalized_model,
+ now,
+ );
+ let effort = parsed
+ .as_ref()
+ .and_then(|parsed| {
+ parsed
+ .messages
+ .extra
+ .get("output_config")
+ .and_then(|value| value.get("effort"))
+ .and_then(Value::as_str)
+ })
+ .or_else(|| body.pointer("/reasoning/effort").and_then(Value::as_str))
+ .map(str::to_string);
if let Some(monitor) = state.monitor.as_ref() {
if let Some(current) = current.as_ref() {
monitor.session_sequence_resolved(&req_id, current.seq);
}
- if let Some(model) = model.as_deref() {
- monitor.provider_selected(&req_id, "codex", model, effort);
- }
+ monitor.provider_selected(&req_id, provider.name(), &normalized_model, effort);
}
-
let traffic = create_traffic_capture(TrafficCaptureOptions {
req_id: req_id.clone(),
session_id: session_id.clone(),
- session_seq: current.as_ref().map(|state| state.seq),
- provider: Some("codex".to_string()),
+ session_seq: current.as_ref().map(|session| session.seq),
+ provider: Some(provider.name().to_string()),
state_dir_override: None,
})
.map(Arc::new);
@@ -701,10 +734,11 @@ async fn handler_responses(State(state): State<Arc<AppState>>, req: Request<Body
&json!({
"reqId": &req_id,
"sessionId": &session_id,
- "sessionSeq": current.as_ref().map(|state| state.seq),
+ "sessionSeq": current.as_ref().map(|session| session.seq),
"kind": "responses",
- "provider": "codex",
- "model": &model,
+ "provider": provider.name(),
+ "model": &normalized_model,
+ "requestedModel": &requested_model,
"method": method.as_str(),
"path": &path,
"query": &query,
@@ -712,31 +746,66 @@ async fn handler_responses(State(state): State<Arc<AppState>>, req: Request<Body
}),
);
capture.write_json("010-openai-responses-request", &body);
+ if let Some(parsed) = parsed.as_ref() {
+ capture.write_json(
+ "015-anthropic-request",
+ &serde_json::to_value(&parsed.messages).unwrap_or_else(|_| json!({})),
+ );
+ }
}
-
let context = RequestContext {
req_id: req_id.clone(),
session_id,
- session_seq: current.map(|state| state.seq),
- provider: "codex".to_string(),
- traffic,
+ session_seq: current.map(|session| session.seq),
+ provider: provider.name().to_string(),
+ traffic: traffic.clone(),
monitor: state.monitor.clone(),
};
- let response = match state.native_responses.as_ref() {
- Some(backend) => backend.handle(body, context).await,
- None => openai_error(
- StatusCode::NOT_FOUND,
- "not_found_error",
- "Native Responses API is disabled",
- None,
- None,
- ),
+ let response = if let Some(parsed) = parsed {
+ match provider
+ .generate_anthropic_stream(parsed.messages, context)
+ .await
+ {
+ Ok(generation) => {
+ if let Some(capture) = traffic.as_ref() {
+ capture.write_json(
+ "016-model-resolution",
+ &json!({"requestedModel":requested_model,"resolvedModel":generation.resolved_model}),
+ );
+ }
+ match render_openai_response(
+ OpenAiSurface::Responses,
+ generation,
+ parsed.stream,
+ parsed.include_usage,
+ normalized_model.clone(),
+ )
+ .await
+ {
+ Ok(response) => response,
+ Err(error) => error.response(),
+ }
+ }
+ Err(error) => OpenAiError::from(error).response(),
+ }
+ } else {
+ match state.native_responses.as_ref() {
+ Some(backend) => backend.handle(body, context).await,
+ None => openai_error(
+ StatusCode::NOT_FOUND,
+ "not_found_error",
+ "Native Responses API is disabled",
+ None,
+ None,
+ ),
+ }
};
- log_native_request_completed(
+ log_routed_openai_request_completed(
&log,
&req_id,
"responses",
- model.as_deref(),
+ provider.name(),
+ Some(&normalized_model),
response.status(),
started_at,
);
@@ -775,7 +844,7 @@ async fn handler_chat_completions(
);
}
let request_guard = RequestMonitorGuard::new(state.monitor.clone(), req_id.clone());
- let body_bytes = match axum::body::to_bytes(req.into_body(), usize::MAX).await {
+ let body_bytes = match axum::body::to_bytes(req.into_body(), MAX_OPENAI_REQUEST_BYTES).await {
Ok(bytes) => bytes,
Err(error) => {
let response = openai_error(
@@ -810,50 +879,84 @@ async fn handler_chat_completions(
return monitor_response_body(response, request_guard);
}
};
- let translated = match translate_request(body.clone()) {
- Ok(translated) => translated,
- Err(error) => {
- let response = error.response();
- log_native_request_completed(
- &log,
- &req_id,
- "chat_completions",
- None,
- response.status(),
- started_at,
- );
- return monitor_response_body(response, request_guard);
- }
+ let (requested_model, normalized_model) = match extract_model(&body) {
+ Ok(model) => model,
+ Err(error) => return monitor_response_body(error.response(), request_guard),
};
-
let now = current_millis();
- let session_state = session_id
- .as_deref()
- .and_then(|session_id| session::existing_session(Some(session_id), now));
+ let session_state = session::existing_session(session_id.as_deref(), now);
+ let affinity = session_state
+ .as_ref()
+ .and_then(|session| session.affinity_provider.as_ref());
+ let Some(provider) = state
+ .registry
+ .provider_for_model(&normalized_model, affinity)
+ else {
+ let response = OpenAiError::invalid(
+ format!(
+ "Unknown model \"{normalized_model}\". {}",
+ state.registry.unknown_model_message()
+ ),
+ Some("model"),
+ )
+ .response();
+ return monitor_response_body(response, request_guard);
+ };
+ let (translated, parsed) = if provider.name() == "codex" {
+ let translated = match translate_request(body.clone()) {
+ Ok(translated) => translated,
+ Err(error) => return monitor_response_body(error.response(), request_guard),
+ };
+ (Some(translated), None)
+ } else {
+ let parsed = match parse_request(
+ OpenAiSurface::ChatCompletions,
+ body.clone(),
+ provider.name(),
+ session_id.as_deref(),
+ ) {
+ Ok(parsed) => parsed,
+ Err(error) => return monitor_response_body(error.response(), request_guard),
+ };
+ (None, Some(parsed))
+ };
+ if provider.name() != "codex"
+ && let Some(session_id) = session_id.as_deref()
+ {
+ crate::providers::codex::clear_session_compaction(session_id);
+ }
let current = session::record_session_request(
session_id.as_deref(),
session_state.as_ref(),
- "codex",
- &translated.model,
+ provider.name(),
+ &normalized_model,
now,
);
+ let effort = translated
+ .as_ref()
+ .and_then(|translated| translated.effort.clone())
+ .or_else(|| {
+ parsed.as_ref().and_then(|parsed| {
+ parsed
+ .messages
+ .extra
+ .get("output_config")
+ .and_then(|value| value.get("effort"))
+ .and_then(Value::as_str)
+ .map(str::to_string)
+ })
+ });
if let Some(monitor) = state.monitor.as_ref() {
if let Some(current) = current.as_ref() {
monitor.session_sequence_resolved(&req_id, current.seq);
}
- monitor.provider_selected(
- &req_id,
- "codex",
- &translated.model,
- translated.effort.clone(),
- );
+ monitor.provider_selected(&req_id, provider.name(), &normalized_model, effort.clone());
}
-
let traffic = create_traffic_capture(TrafficCaptureOptions {
req_id: req_id.clone(),
session_id: session_id.clone(),
- session_seq: current.as_ref().map(|state| state.seq),
- provider: Some("codex".to_string()),
+ session_seq: current.as_ref().map(|session| session.seq),
+ provider: Some(provider.name().to_string()),
state_dir_override: None,
})
.map(Arc::new);
@@ -866,12 +969,12 @@ async fn handler_chat_completions(
&json!({
"reqId": &req_id,
"sessionId": &session_id,
- "sessionSeq": current.as_ref().map(|state| state.seq),
+ "sessionSeq": current.as_ref().map(|session| session.seq),
"kind": "chat_completions",
- "provider": "codex",
- "model": &translated.model,
- "requestedModel": &translated.requested_model,
- "effort": &translated.effort,
+ "provider": provider.name(),
+ "model": &normalized_model,
+ "requestedModel": &requested_model,
+ "effort": &effort,
"method": method.as_str(),
"path": &path,
"query": &query,
@@ -879,32 +982,70 @@ async fn handler_chat_completions(
}),
);
capture.write_json("010-openai-chat-completions-request", &body);
- capture.write_json("020-upstream-request", &translated.upstream);
+ if let Some(translated) = translated.as_ref() {
+ capture.write_json("020-upstream-request", &translated.upstream);
+ }
+ if let Some(parsed) = parsed.as_ref() {
+ capture.write_json(
+ "015-anthropic-request",
+ &serde_json::to_value(&parsed.messages).unwrap_or_else(|_| json!({})),
+ );
+ }
}
-
let context = RequestContext {
req_id: req_id.clone(),
session_id,
- session_seq: current.map(|state| state.seq),
- provider: "codex".to_string(),
- traffic,
+ session_seq: current.map(|session| session.seq),
+ provider: provider.name().to_string(),
+ traffic: traffic.clone(),
monitor: state.monitor.clone(),
};
- let response = match state.chat_completions.as_ref() {
- Some(backend) => backend.handle(translated.clone(), context).await,
- None => openai_error(
- StatusCode::NOT_FOUND,
- "not_found_error",
- "Chat Completions API is disabled",
- None,
- None,
- ),
+ let response = if let Some(translated) = translated {
+ match state.chat_completions.as_ref() {
+ Some(backend) => backend.handle(translated, context).await,
+ None => openai_error(
+ StatusCode::NOT_FOUND,
+ "not_found_error",
+ "Chat Completions API is disabled",
+ None,
+ None,
+ ),
+ }
+ } else {
+ let parsed = parsed.expect("non-Codex request was parsed");
+ match provider
+ .generate_anthropic_stream(parsed.messages, context)
+ .await
+ {
+ Ok(generation) => {
+ if let Some(capture) = traffic.as_ref() {
+ capture.write_json(
+ "016-model-resolution",
+ &json!({"requestedModel":requested_model,"resolvedModel":generation.resolved_model}),
+ );
+ }
+ match render_openai_response(
+ OpenAiSurface::ChatCompletions,
+ generation,
+ parsed.stream,
+ parsed.include_usage,
+ normalized_model.clone(),
+ )
+ .await
+ {
+ Ok(response) => response,
+ Err(error) => error.response(),
+ }
+ }
+ Err(error) => OpenAiError::from(error).response(),
+ }
};
- log_native_request_completed(
+ log_routed_openai_request_completed(
&log,
&req_id,
"chat_completions",
- Some(&translated.model),
+ provider.name(),
+ Some(&normalized_model),
response.status(),
started_at,
);
@@ -949,6 +1090,29 @@ fn parse_native_json_body(body: &[u8]) -> Result<Value, Response> {
})
}
+fn log_routed_openai_request_completed(
+ log: &Logger,
+ req_id: &str,
+ endpoint: &str,
+ provider: &str,
+ model: Option<&str>,
+ status: StatusCode,
+ started_at: Instant,
+) {
+ log.info(
+ "request_completed",
+ Some(serde_json::Map::from_iter([
+ ("reqId".to_string(), json!(req_id)),
+ ("endpoint".to_string(), json!(endpoint)),
+ ("provider".to_string(), json!(provider)),
+ ("model".to_string(), json!(model)),
+ ("countTokens".to_string(), json!(false)),
+ ("status".to_string(), json!(status.as_u16())),
+ ("ms".to_string(), json!(started_at.elapsed().as_millis())),
+ ])),
+ );
+}
+
fn log_native_request_completed(
log: &Logger,
req_id: &str,
@@ -1008,7 +1172,7 @@ async fn dispatch_request(
}
let request_guard = RequestMonitorGuard::new(state.monitor.clone(), req_id.clone());
let now = current_millis();
- let body_bytes = match axum::body::to_bytes(req.into_body(), usize::MAX).await {
+ let body_bytes = match axum::body::to_bytes(req.into_body(), MAX_OPENAI_REQUEST_BYTES).await {
Ok(bytes) => bytes,
Err(err) => {
let response = json_error(
diff --git a/src/session.rs b/src/session.rs
index c6b31e9..6b97e96 100644
--- a/src/session.rs
+++ b/src/session.rs
@@ -66,11 +66,25 @@ pub(crate) fn record_session_request_with_affinity_update(
) -> Option<SessionState> {
let id = session_id?;
let mut store = SESSIONS.lock().expect("session lock");
- let mut next = prior.cloned().unwrap_or(SessionState {
- seq: 0,
- affinity_provider: None,
- last_seen: now,
- });
+ let stored = store
+ .map
+ .get(id)
+ .cloned()
+ .filter(|state| now.saturating_sub(state.last_seen) <= SESSION_IDLE_TTL_MS);
+ if stored.is_none() && store.map.remove(id).is_some() {
+ store.order.retain(|item| item != id);
+ }
+ let mut next = stored
+ .or_else(|| {
+ prior
+ .filter(|state| now.saturating_sub(state.last_seen) <= SESSION_IDLE_TTL_MS)
+ .cloned()
+ })
+ .unwrap_or(SessionState {
+ seq: 0,
+ affinity_provider: None,
+ last_seen: now,
+ });
next.seq += 1;
next.last_seen = now;
if update_affinity
@@ -119,6 +133,35 @@ pub fn affinity_provider_from_session(session: &SessionState) -> Option<AliasPro
mod tests {
use super::*;
+ #[test]
+ fn concurrent_requests_increment_latest_sequence() {
+ let session_id = "session-concurrent-sequence-test";
+ let initial = record_session_request(Some(session_id), None, "codex", "gpt-5.6-sol", 1)
+ .expect("initial session");
+ let handles: Vec<_> = (0..16)
+ .map(|offset| {
+ let stale = initial.clone();
+ std::thread::spawn(move || {
+ record_session_request(
+ Some(session_id),
+ Some(&stale),
+ "codex",
+ "gpt-5.6-sol",
+ 2 + offset,
+ )
+ .expect("recorded session")
+ .seq
+ })
+ })
+ .collect();
+ let mut sequences: Vec<_> = handles
+ .into_iter()
+ .map(|handle| handle.join().expect("session thread"))
+ .collect();
+ sequences.sort_unstable();
+ assert_eq!(sequences, (2..=17).collect::<Vec<_>>());
+ }
+
#[test]
fn auxiliary_request_does_not_change_session_affinity() {
let session_id = "session-affinity-auxiliary-request-test";
diff --git a/tests/server.rs b/tests/server.rs
index 0873b1c..0bdad3f 100644
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -1,7 +1,12 @@
+use async_trait::async_trait;
use axum::body::Body;
use axum::http::{Method, Request, StatusCode};
+use axum::response::IntoResponse;
use claude_code_proxy::{
+ MessagesRequest,
+ config::AliasProvider,
monitor::{MonitorHandle, RequestStatus},
+ provider::{CliHandlers, Generation, GenerationBody, Provider, ProviderError, RequestContext},
registry::Registry,
server::{
AppFeatures, app, app_with_features, app_with_monitor, app_with_options,
@@ -16,6 +21,100 @@ fn body_string(json: &str) -> Body {
Body::from(json.to_string())
}
+struct FakeCli;
+
+impl CliHandlers for FakeCli {
+ fn login(&self) -> anyhow::Result<()> {
+ Ok(())
+ }
+
+ fn device(&self) -> anyhow::Result<()> {
+ Ok(())
+ }
+
+ fn status(&self) -> anyhow::Result<()> {
+ Ok(())
+ }
+
+ fn logout(&self) -> anyhow::Result<()> {
+ Ok(())
+ }
+}
+
+static FAKE_CLI: FakeCli = FakeCli;
+
+struct FakeProvider {
+ name: &'static str,
+ models: Vec<String>,
+}
+
+#[async_trait]
+impl Provider for FakeProvider {
+ fn name(&self) -> &'static str {
+ self.name
+ }
+
+ fn supported_models(&self) -> Vec<String> {
+ self.models.clone()
+ }
+
+ fn cli(&self) -> &'static dyn CliHandlers {
+ &FAKE_CLI
+ }
+
+ async fn handle_messages(
+ &self,
+ _body: MessagesRequest,
+ _ctx: RequestContext,
+ ) -> axum::response::Response {
+ (StatusCode::NOT_IMPLEMENTED, "unused").into_response()
+ }
+
+ async fn handle_count_tokens(
+ &self,
+ _body: MessagesRequest,
+ _ctx: RequestContext,
+ ) -> axum::response::Response {
+ (StatusCode::NOT_IMPLEMENTED, "unused").into_response()
+ }
+
+ async fn generate_anthropic_stream(
+ &self,
+ body: MessagesRequest,
+ _ctx: RequestContext,
+ ) -> Result<Generation, ProviderError> {
+ let model = body.model.unwrap_or_default();
+ let sse = format!(
+ "event: message_start\ndata: {{\"type\":\"message_start\",\"message\":{{\"id\":\"msg_fake\",\"model\":{model:?},\"usage\":{{\"input_tokens\":2}}}}}}\n\nevent: content_block_start\ndata: {{\"type\":\"content_block_start\",\"index\":0,\"content_block\":{{\"type\":\"text\",\"text\":\"\"}}}}\n\nevent: content_block_delta\ndata: {{\"type\":\"content_block_delta\",\"index\":0,\"delta\":{{\"type\":\"text_delta\",\"text\":\"{name}\"}}}}\n\nevent: content_block_stop\ndata: {{\"type\":\"content_block_stop\",\"index\":0}}\n\nevent: message_delta\ndata: {{\"type\":\"message_delta\",\"delta\":{{\"stop_reason\":\"end_turn\"}},\"usage\":{{\"output_tokens\":1}}}}\n\nevent: message_stop\ndata: {{\"type\":\"message_stop\"}}\n\n",
+ name = self.name,
+ );
+ Ok(Generation {
+ body: GenerationBody::BufferedSse(sse.into()),
+ resolved_model: model,
+ })
+ }
+}
+
+fn routed_registry() -> Arc<Registry> {
+ Arc::new(Registry::from_providers(
+ AliasProvider::Kimi,
+ vec![
+ Arc::new(FakeProvider {
+ name: "kimi",
+ models: vec!["kimi-k2.6".to_string()],
+ }) as Arc<dyn Provider>,
+ Arc::new(FakeProvider {
+ name: "grok",
+ models: vec!["grok-4.5".to_string()],
+ }),
+ Arc::new(FakeProvider {
+ name: "cursor",
+ models: vec!["cursor".to_string()],
+ }),
+ ],
+ ))
+}
+
#[tokio::test]
async fn bind_error_names_address_and_port() {
let occupied = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
@@ -509,6 +608,142 @@ async fn chat_completions_route_uses_responses_api_gate() {
assert_eq!(body["error"]["code"], "invalid_json");
}
+#[tokio::test]
+async fn openai_routes_select_non_codex_providers_and_aliases() {
+ for (uri, request, expected) in [
+ (
+ "/v1/chat/completions",
+ json!({"model":"kimi-k2.6","messages":[{"role":"user","content":"hello"}]}),
+ "kimi",
+ ),
+ (
+ "/v1/responses",
+ json!({"model":"grok-4.5","input":"hello"}),
+ "grok",
+ ),
+ (
+ "/v1/chat/completions",
+ json!({"model":"cursor:gpt-5.5","messages":[{"role":"user","content":"hello"}]}),
+ "cursor",
+ ),
+ (
+ "/v1/responses",
+ json!({"model":"sonnet","input":"hello"}),
+ "kimi",
+ ),
+ ] {
+ let response = app_with_options(routed_registry(), None, true)
+ .oneshot(
+ Request::builder()
+ .method(Method::POST)
+ .uri(uri)
+ .header("content-type", "application/json")
+ .body(body_string(&request.to_string()))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(response.status(), StatusCode::OK, "{uri} {request}");
+ let value: Value = serde_json::from_slice(
+ &axum::body::to_bytes(response.into_body(), usize::MAX)
+ .await
+ .unwrap(),
+ )
+ .unwrap();
+ let text = if uri.ends_with("responses") {
+ value["output"][0]["content"][0]["text"].as_str()
+ } else {
+ value["choices"][0]["message"]["content"].as_str()
+ };
+ assert_eq!(text, Some(expected));
+ }
+}
+
+#[tokio::test]
+async fn routed_openai_streams_use_surface_specific_events() {
+ let chat = app_with_options(routed_registry(), None, true)
+ .oneshot(
+ Request::builder()
+ .method(Method::POST)
+ .uri("/v1/chat/completions")
+ .header("content-type", "application/json")
+ .body(body_string(
+ r#"{"model":"kimi-k2.6","stream":true,"stream_options":{"include_usage":true},"messages":[{"role":"user","content":"hello"}]}"#,
+ ))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ let chat = String::from_utf8(
+ axum::body::to_bytes(chat.into_body(), usize::MAX)
+ .await
+ .unwrap()
+ .to_vec(),
+ )
+ .unwrap();
+ assert!(chat.contains("chat.completion.chunk"));
+ assert!(chat.contains("\"total_tokens\":3"));
+ assert!(chat.ends_with("data: [DONE]\n\n"));
+
+ let responses = app_with_options(routed_registry(), None, true)
+ .oneshot(
+ Request::builder()
+ .method(Method::POST)
+ .uri("/v1/responses")
+ .header("content-type", "application/json")
+ .body(body_string(
+ r#"{"model":"grok-4.5","stream":true,"input":"hello"}"#,
+ ))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ let responses = String::from_utf8(
+ axum::body::to_bytes(responses.into_body(), usize::MAX)
+ .await
+ .unwrap()
+ .to_vec(),
+ )
+ .unwrap();
+ assert!(responses.contains("event: response.created"));
+ assert!(responses.contains("event: response.completed"));
+ assert!(responses.contains("\"sequence_number\":0"));
+}
+
+#[tokio::test]
+async fn non_codex_validation_uses_openai_errors_before_generation() {
+ let monitor = MonitorHandle::new(10);
+ let response = app_with_options(routed_registry(), Some(monitor.clone()), true)
+ .oneshot(
+ Request::builder()
+ .method(Method::POST)
+ .uri("/v1/chat/completions")
+ .header("content-type", "application/json")
+ .header("x-client-request-id", "invalid-routed-request")
+ .body(body_string(
+ r#"{"model":"kimi-k2.6","messages":[{"role":"user","content":"hello"}],"temperature":0.5}"#,
+ ))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+ let value: Value = serde_json::from_slice(
+ &axum::body::to_bytes(response.into_body(), usize::MAX)
+ .await
+ .unwrap(),
+ )
+ .unwrap();
+ assert_eq!(value["error"]["param"], "temperature");
+ assert_eq!(value["error"]["code"], "unsupported_parameter");
+ assert!(
+ claude_code_proxy::session::existing_session_now(Some("invalid-routed-request")).is_none()
+ );
+ let snapshot = monitor.snapshot();
+ assert_eq!(snapshot.recent[0].session_seq, None);
+ assert_eq!(snapshot.recent[0].provider, None);
+}
+
#[tokio::test]
async fn chat_completions_validation_returns_openai_parameter_errors() {
let app = app_with_options(Arc::new(Registry::with_default_alias()), None, true);