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.rsindex 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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(¶m)))?;+ reject_nested_fields(+ object,+ &[+ "role",+ "content",+ "name",+ "tool_calls",+ "tool_call_id",+ "reasoning_content",+ ],+ ¶m,+ )?;+ 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"), ¶m, &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(¶m)))?;+ 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"], ¶m)?;+ 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"],+ ¶m,+ )?;+ 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"],+ ¶m,+ )?;+ 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(¶m)))?;+ reject_nested_fields(object, &["id", "type", "function"], ¶m)?;+ 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(¶m)))?;+ 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"], ¶m)?;+ 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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<Bodymonitor.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<Bodyreturn 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.rsindex 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<AliasPromod 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.rsindex 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);