Add OpenAI Responses API support (/v1/responses endpoint)

src/adapter/convert_responses.rs

@@ -0,0 +1,593 @@
+use serde_json::value::RawValue;
+use crate::types::openrouter::{
+    CreateChatCompletionRequest, ChatCompletionMessage, MessageContent, ContentPart,
+    ContentPartType, ImageUrl, ChatCompletionChunk, Tool, Function, Role, ToolCallType,
+};
+use crate::types::responses::{
+    CreateResponseRequest, Input, InputMessage, InputMessageContent,
+    ContentPart as ResponsesContentPart, Tool as ResponsesTool, ToolChoice as ResponsesToolChoice,
+    Response, ResponseStatus, ResponseUsage, OutputItem, OutputStatus,
+    OutputContent, ReasoningContent, StreamEvent,
+};
+
+/// Convert Responses API request to Chat Completions request
+pub fn convert_responses_to_openrouter(req: &CreateResponseRequest) -> CreateChatCompletionRequest {
+    let mut messages = Vec::new();
+
+    // Add system message if instructions provided
+    if let Some(instructions) = &req.instructions {
+        messages.push(ChatCompletionMessage {
+            role: Role::System,
+            content: Some(MessageContent::Text(instructions.clone())),
+            tool_call_id: None,
+            refusal: None,
+            tool_calls: None,
+            reasoning: None,
+            reasoning_details: None,
+        });
+    }
+
+    // Convert input to messages
+    match &req.input {
+        Input::Text(text) => {
+            messages.push(ChatCompletionMessage {
+                role: Role::User,
+                content: Some(MessageContent::Text(text.clone())),
+                tool_call_id: None,
+                refusal: None,
+                tool_calls: None,
+                reasoning: None,
+                reasoning_details: None,
+            });
+        }
+        Input::Messages(input_messages) => {
+            for msg in input_messages {
+                if let Some(chat_msg) = convert_input_message(msg) {
+                    messages.push(chat_msg);
+                }
+            }
+        }
+    }
+
+    // Convert tools
+    let tools = req.tools.as_ref().map(|tools| {
+        tools.iter().filter_map(|tool| {
+            match tool {
+                ResponsesTool::Function { name, description, parameters, strict } => {
+                    Some(Tool {
+                        tool_type: ToolCallType::Function,
+                        function: Function {
+                            name: name.clone(),
+                            description: description.clone(),
+                            parameters: parameters.as_ref().and_then(|p| {
+                                RawValue::from_string(p.to_string()).ok()
+                            }),
+                            strict: *strict,
+                        },
+                    })
+                }
+            }
+        }).collect()
+    });
+
+    // Convert tool_choice
+    let tool_choice = req.tool_choice.as_ref().and_then(|tc| {
+        match tc {
+            ResponsesToolChoice::Auto(s) => {
+                match s.as_str() {
+                    "auto" => Some(crate::types::openrouter::ToolChoice::Mode(crate::types::openrouter::ToolChoiceMode::Auto)),
+                    "none" => Some(crate::types::openrouter::ToolChoice::Mode(crate::types::openrouter::ToolChoiceMode::None)),
+                    "required" => Some(crate::types::openrouter::ToolChoice::Mode(crate::types::openrouter::ToolChoiceMode::Required)),
+                    _ => None,
+                }
+            }
+            ResponsesToolChoice::Function { name, .. } => {
+                Some(crate::types::openrouter::ToolChoice::Tool(Tool {
+                    tool_type: ToolCallType::Function,
+                    function: Function {
+                        name: name.clone(),
+                        description: None,
+                        parameters: None,
+                        strict: None,
+                    },
+                }))
+            }
+        }
+    });
+
+    CreateChatCompletionRequest {
+        model: req.model.clone(),
+        messages,
+        stream: true,
+        max_tokens: req.max_output_tokens.map(|t| t as i32),
+        temperature: req.temperature,
+        top_p: req.top_p,
+        tools,
+        tool_choice,
+        ..Default::default()
+    }
+}
+
+fn convert_input_message(msg: &InputMessage) -> Option<ChatCompletionMessage> {
+    let role = match msg.role.as_str() {
+        "user" => Role::User,
+        "assistant" => Role::Assistant,
+        "system" => Role::System,
+        "developer" => Role::Developer,
+        "tool" => Role::Tool,
+        _ => Role::User,
+    };
+
+    let (content, tool_call_id) = match &msg.content {
+        InputMessageContent::Text { content } => {
+            (Some(MessageContent::Text(content.clone())), None)
+        }
+        InputMessageContent::Array { content } => {
+            let parts: Vec<ContentPart> = content.iter().filter_map(|part| {
+                match part {
+                    ResponsesContentPart::InputText { text } => {
+                        Some(ContentPart {
+                            part_type: ContentPartType::Text,
+                            text: Some(text.clone()),
+                            refusal: None,
+                            image_url: None,
+                            cache_control: None,
+                        })
+                    }
+                    ResponsesContentPart::InputImage { image_url } => {
+                        Some(ContentPart {
+                            part_type: ContentPartType::ImageUrl,
+                            text: None,
+                            refusal: None,
+                            image_url: Some(ImageUrl {
+                                url: image_url.clone(),
+                                detail: None,
+                            }),
+                            cache_control: None,
+                        })
+                    }
+                    ResponsesContentPart::OutputText { text } => {
+                        Some(ContentPart {
+                            part_type: ContentPartType::Text,
+                            text: Some(text.clone()),
+                            refusal: None,
+                            image_url: None,
+                            cache_control: None,
+                        })
+                    }
+                }
+            }).collect();
+            (Some(MessageContent::Parts(parts)), None)
+        }
+        InputMessageContent::FunctionCallOutput { call_id, output, .. } => {
+            return Some(ChatCompletionMessage {
+                role: Role::Tool,
+                content: Some(MessageContent::Text(output.clone())),
+                tool_call_id: Some(call_id.clone()),
+                refusal: None,
+                tool_calls: None,
+                reasoning: None,
+                reasoning_details: None,
+            });
+        }
+        InputMessageContent::FunctionCall { .. } => {
+            return None;
+        }
+    };
+
+    Some(ChatCompletionMessage {
+        role,
+        content,
+        tool_call_id,
+        refusal: None,
+        tool_calls: None,
+        reasoning: None,
+        reasoning_details: None,
+    })
+}
+
+/// Stream converter for Chat Completions → Responses API
+#[derive(Debug, Default)]
+pub struct ResponsesStreamConverter {
+    response_id: String,
+    model: String,
+    created_at: i64,
+    sequence_number: i64,
+    // Current output state
+    current_message_id: Option<String>,
+    current_reasoning_id: Option<String>,
+    current_function_call_id: Option<String>,
+    // Accumulated content
+    full_text: String,
+    full_reasoning: String,
+    full_arguments: String,
+    // Indices
+    output_index: i64,
+    // Usage tracking
+    input_tokens: i64,
+    output_tokens: i64,
+    // State
+    started: bool,
+    in_reasoning: bool,
+}
+
+impl ResponsesStreamConverter {
+    pub fn new() -> Self {
+        Self {
+            response_id: format!("resp_{}", uuid::Uuid::new_v4().to_string().replace("-", "")[..24].to_string()),
+            created_at: std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_secs() as i64,
+            ..Default::default()
+        }
+    }
+
+    pub fn convert_chunk(&mut self, chunk: &ChatCompletionChunk) -> Vec<StreamEvent> {
+        let mut events = Vec::new();
+
+        // Set model from first chunk
+        if self.model.is_empty() {
+            self.model = chunk.model.clone();
+        }
+
+        // Update usage
+        if let Some(usage) = &chunk.usage {
+            self.input_tokens = usage.prompt_tokens;
+            self.output_tokens = usage.completion_tokens;
+        }
+
+        // Initial response.created event
+        if !self.started {
+            self.started = true;
+            events.push(self.create_response_event(StreamEventType::Created));
+            events.push(self.create_response_event(StreamEventType::InProgress));
+        }
+
+        // Process choices
+        if let Some(choice) = chunk.choices.first() {
+            if let Some(delta) = &choice.delta {
+                // Handle reasoning content
+                if let Some(reasoning) = &delta.reasoning {
+                    if !reasoning.is_empty() {
+                        events.extend(self.handle_reasoning(reasoning));
+                    }
+                }
+                if let Some(reasoning_content) = &delta.reasoning_content {
+                    if !reasoning_content.is_empty() {
+                        events.extend(self.handle_reasoning(reasoning_content));
+                    }
+                }
+
+                // Handle text content
+                if let Some(content) = &delta.content {
+                    if !content.is_empty() {
+                        events.extend(self.handle_text(content));
+                    }
+                }
+
+                // Handle tool calls
+                if let Some(tool_calls) = &delta.tool_calls {
+                    if let Some(tool_call) = tool_calls.first() {
+                        events.extend(self.handle_tool_call(tool_call));
+                    }
+                }
+            }
+        }
+
+        events
+    }
+
+    fn handle_reasoning(&mut self, content: &str) -> Vec<StreamEvent> {
+        let mut events = Vec::new();
+
+        // Close text message if we were in text mode
+        if !self.in_reasoning && self.current_message_id.is_some() {
+            events.extend(self.close_current_message());
+        }
+
+        // Start reasoning if needed
+        if self.current_reasoning_id.is_none() {
+            self.in_reasoning = true;
+            let reasoning_id = format!("rs_{}", &uuid::Uuid::new_v4().to_string().replace("-", "")[..24]);
+            self.current_reasoning_id = Some(reasoning_id.clone());
+
+            events.push(StreamEvent::OutputItemAdded {
+                output_index: self.output_index,
+                item: OutputItem::Reasoning {
+                    id: reasoning_id.clone(),
+                    status: OutputStatus::InProgress,
+                    content: vec![],
+                },
+                sequence_number: self.next_sequence(),
+            });
+
+            events.push(StreamEvent::ContentPartAdded {
+                item_id: reasoning_id.clone(),
+                output_index: self.output_index,
+                content_index: 0,
+                part: OutputContent::Text { text: String::new() },
+                sequence_number: self.next_sequence(),
+            });
+        }
+
+        // Emit reasoning delta
+        self.full_reasoning.push_str(content);
+        events.push(StreamEvent::ReasoningTextDelta {
+            item_id: self.current_reasoning_id.clone().unwrap(),
+            output_index: self.output_index,
+            content_index: 0,
+            delta: content.to_string(),
+            sequence_number: self.next_sequence(),
+        });
+
+        events
+    }
+
+    fn handle_text(&mut self, content: &str) -> Vec<StreamEvent> {
+        let mut events = Vec::new();
+
+        // Close reasoning if we were in reasoning mode
+        if self.in_reasoning && self.current_reasoning_id.is_some() {
+            events.extend(self.close_current_reasoning());
+        }
+
+        // Start message if needed
+        if self.current_message_id.is_none() {
+            self.in_reasoning = false;
+            let message_id = format!("msg_{}", &uuid::Uuid::new_v4().to_string().replace("-", "")[..24]);
+            self.current_message_id = Some(message_id.clone());
+
+            events.push(StreamEvent::OutputItemAdded {
+                output_index: self.output_index,
+                item: OutputItem::Message {
+                    id: message_id.clone(),
+                    role: "assistant".to_string(),
+                    status: OutputStatus::InProgress,
+                    content: vec![],
+                },
+                sequence_number: self.next_sequence(),
+            });
+
+            events.push(StreamEvent::ContentPartAdded {
+                item_id: message_id.clone(),
+                output_index: self.output_index,
+                content_index: 0,
+                part: OutputContent::Text { text: String::new() },
+                sequence_number: self.next_sequence(),
+            });
+        }
+
+        // Emit text delta
+        self.full_text.push_str(content);
+        events.push(StreamEvent::OutputTextDelta {
+            item_id: self.current_message_id.clone().unwrap(),
+            output_index: self.output_index,
+            content_index: 0,
+            delta: content.to_string(),
+            sequence_number: self.next_sequence(),
+        });
+
+        events
+    }
+
+    fn handle_tool_call(&mut self, tool_call: &crate::types::openrouter::ToolCall) -> Vec<StreamEvent> {
+        let mut events = Vec::new();
+
+        // Close message/reasoning if needed
+        if self.current_message_id.is_some() {
+            events.extend(self.close_current_message());
+        }
+        if self.current_reasoning_id.is_some() {
+            events.extend(self.close_current_reasoning());
+        }
+
+        // Start function call if this is a new one
+        let is_new = !tool_call.id.is_empty() &&
+            self.current_function_call_id.as_ref() != Some(&tool_call.id);
+
+        if is_new || self.current_function_call_id.is_none() {
+            if self.current_function_call_id.is_some() {
+                events.extend(self.close_current_function_call());
+            }
+
+            let fc_id = format!("fc_{}", &uuid::Uuid::new_v4().to_string().replace("-", "")[..24]);
+            self.current_function_call_id = Some(tool_call.id.clone());
+            self.full_arguments.clear();
+
+            events.push(StreamEvent::OutputItemAdded {
+                output_index: self.output_index,
+                item: OutputItem::FunctionCall {
+                    id: fc_id,
+                    call_id: tool_call.id.clone(),
+                    name: tool_call.function.name.clone(),
+                    arguments: String::new(),
+                    status: Some(OutputStatus::InProgress),
+                },
+                sequence_number: self.next_sequence(),
+            });
+        }
+
+        // Emit arguments delta
+        if !tool_call.function.arguments.is_empty() {
+            self.full_arguments.push_str(&tool_call.function.arguments);
+            events.push(StreamEvent::FunctionCallArgumentsDelta {
+                item_id: self.current_function_call_id.clone().unwrap_or_default(),
+                output_index: self.output_index,
+                delta: tool_call.function.arguments.clone(),
+                sequence_number: self.next_sequence(),
+            });
+        }
+
+        events
+    }
+
+    fn close_current_message(&mut self) -> Vec<StreamEvent> {
+        let mut events = Vec::new();
+
+        if let Some(message_id) = self.current_message_id.take() {
+            events.push(StreamEvent::OutputTextDone {
+                item_id: message_id.clone(),
+                output_index: self.output_index,
+                content_index: 0,
+                text: self.full_text.clone(),
+                sequence_number: self.next_sequence(),
+            });
+
+            events.push(StreamEvent::ContentPartDone {
+                item_id: message_id.clone(),
+                output_index: self.output_index,
+                content_index: 0,
+                part: OutputContent::Text { text: self.full_text.clone() },
+                sequence_number: self.next_sequence(),
+            });
+
+            events.push(StreamEvent::OutputItemDone {
+                output_index: self.output_index,
+                item: OutputItem::Message {
+                    id: message_id,
+                    role: "assistant".to_string(),
+                    status: OutputStatus::Completed,
+                    content: vec![OutputContent::Text { text: self.full_text.clone() }],
+                },
+                sequence_number: self.next_sequence(),
+            });
+
+            self.output_index += 1;
+            self.full_text.clear();
+        }
+
+        events
+    }
+
+    fn close_current_reasoning(&mut self) -> Vec<StreamEvent> {
+        let mut events = Vec::new();
+
+        if let Some(reasoning_id) = self.current_reasoning_id.take() {
+            events.push(StreamEvent::ReasoningTextDone {
+                item_id: reasoning_id.clone(),
+                output_index: self.output_index,
+                content_index: 0,
+                text: self.full_reasoning.clone(),
+                sequence_number: self.next_sequence(),
+            });
+
+            events.push(StreamEvent::OutputItemDone {
+                output_index: self.output_index,
+                item: OutputItem::Reasoning {
+                    id: reasoning_id,
+                    status: OutputStatus::Completed,
+                    content: vec![ReasoningContent::Text { text: self.full_reasoning.clone() }],
+                },
+                sequence_number: self.next_sequence(),
+            });
+
+            self.output_index += 1;
+            self.full_reasoning.clear();
+            self.in_reasoning = false;
+        }
+
+        events
+    }
+
+    fn close_current_function_call(&mut self) -> Vec<StreamEvent> {
+        let mut events = Vec::new();
+
+        if let Some(call_id) = self.current_function_call_id.take() {
+            events.push(StreamEvent::FunctionCallArgumentsDone {
+                item_id: call_id.clone(),
+                output_index: self.output_index,
+                arguments: self.full_arguments.clone(),
+                sequence_number: self.next_sequence(),
+            });
+
+            events.push(StreamEvent::OutputItemDone {
+                output_index: self.output_index,
+                item: OutputItem::FunctionCall {
+                    id: format!("fc_{}", &uuid::Uuid::new_v4().to_string().replace("-", "")[..24]),
+                    call_id,
+                    name: String::new(), // Would need to track this
+                    arguments: self.full_arguments.clone(),
+                    status: Some(OutputStatus::Completed),
+                },
+                sequence_number: self.next_sequence(),
+            });
+
+            self.output_index += 1;
+            self.full_arguments.clear();
+        }
+
+        events
+    }
+
+    pub fn finish(&mut self) -> Vec<StreamEvent> {
+        let mut events = Vec::new();
+
+        // Close any open items
+        if self.current_message_id.is_some() {
+            events.extend(self.close_current_message());
+        }
+        if self.current_reasoning_id.is_some() {
+            events.extend(self.close_current_reasoning());
+        }
+        if self.current_function_call_id.is_some() {
+            events.extend(self.close_current_function_call());
+        }
+
+        // Emit response.completed
+        events.push(self.create_response_event(StreamEventType::Completed));
+
+        events
+    }
+
+    fn next_sequence(&mut self) -> i64 {
+        self.sequence_number += 1;
+        self.sequence_number
+    }
+
+    fn create_response_event(&mut self, event_type: StreamEventType) -> StreamEvent {
+        let response = Response {
+            id: self.response_id.clone(),
+            object: "response".to_string(),
+            created_at: self.created_at,
+            model: self.model.clone(),
+            status: match event_type {
+                StreamEventType::Created | StreamEventType::InProgress => ResponseStatus::InProgress,
+                StreamEventType::Completed => ResponseStatus::Completed,
+            },
+            error: None,
+            instructions: None,
+            max_output_tokens: None,
+            temperature: None,
+            top_p: None,
+            output: vec![],
+            usage: Some(ResponseUsage {
+                input_tokens: self.input_tokens,
+                output_tokens: self.output_tokens,
+                total_tokens: self.input_tokens + self.output_tokens,
+            }),
+        };
+
+        match event_type {
+            StreamEventType::Created => StreamEvent::ResponseCreated {
+                response,
+                sequence_number: self.next_sequence(),
+            },
+            StreamEventType::InProgress => StreamEvent::ResponseInProgress {
+                response,
+                sequence_number: self.next_sequence(),
+            },
+            StreamEventType::Completed => StreamEvent::ResponseCompleted {
+                response,
+                sequence_number: self.next_sequence(),
+            },
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum StreamEventType {
+    Created,
+    InProgress,
+    Completed,
+}

src/adapter/mod.rs

@@ -1,5 +1,7 @@
 pub mod convert_request;
+pub mod convert_responses;
 pub mod convert_stream;
 
 pub use convert_request::convert_anthropic_to_openrouter;
+pub use convert_responses::{convert_responses_to_openrouter, ResponsesStreamConverter};
 pub use convert_stream::StreamConverter;

src/handlers/mod.rs

@@ -1,5 +1,7 @@
 pub mod count_tokens;
 pub mod messages;
+pub mod responses;
 
 pub use count_tokens::count_tokens;
 pub use messages::messages;
+pub use responses::responses;

src/handlers/responses.rs

@@ -0,0 +1,150 @@
+use axum::{
+    body::Body,
+    extract::State,
+    http::{header, HeaderMap, StatusCode},
+    response::Response,
+    Json,
+};
+use futures::StreamExt;
+use tokio_stream::wrappers::ReceiverStream;
+
+use crate::adapter::{convert_responses_to_openrouter, ResponsesStreamConverter};
+use crate::error::AppError;
+use crate::types::openrouter::ChatCompletionChunk;
+use crate::types::responses::CreateResponseRequest;
+use crate::AppState;
+
+pub async fn responses(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Json(request): Json<CreateResponseRequest>,
+) -> Result<Response, AppError> {
+    // Extract API key from incoming request headers
+    let api_key = headers
+        .get("x-api-key")
+        .and_then(|v| v.to_str().ok())
+        .map(|s| s.to_string())
+        .or_else(|| {
+            headers
+                .get(header::AUTHORIZATION)
+                .and_then(|v| v.to_str().ok())
+                .and_then(|s| s.strip_prefix("Bearer "))
+                .map(|s| s.to_string())
+        })
+        .or_else(|| {
+            if state.openrouter_api_key.is_empty() {
+                None
+            } else {
+                Some(state.openrouter_api_key.clone())
+            }
+        })
+        .ok_or_else(|| AppError::InvalidRequest("Missing API key".to_string()))?;
+
+    let request_id = uuid::Uuid::new_v4().to_string()[..8].to_string();
+    tracing::info!(req = %request_id, model = %request.model, "POST /v1/responses");
+
+    // Convert Responses API request to OpenRouter/Chat Completions format
+    let openrouter_request = convert_responses_to_openrouter(&request);
+
+    // Create request to backend
+    let url = format!("{}/v1/chat/completions", state.openrouter_base_url);
+
+    let response = state
+        .http_client
+        .post(&url)
+        .header("Authorization", format!("Bearer {}", api_key))
+        .header("Content-Type", "application/json")
+        .header("Accept", "text/event-stream")
+        .json(&openrouter_request)
+        .send()
+        .await
+        .map_err(|e| AppError::RequestError(e.to_string()))?;
+
+    if !response.status().is_success() {
+        let status = response.status();
+        let body = response.text().await.unwrap_or_default();
+        return Err(AppError::UpstreamError(status.as_u16(), body));
+    }
+
+    // Create SSE stream
+    let (tx, rx) = tokio::sync::mpsc::channel::<Result<String, std::io::Error>>(100);
+
+    // Spawn task to handle SSE conversion
+    let req_id = request_id.clone();
+    tokio::spawn(async move {
+        let mut converter = ResponsesStreamConverter::new();
+        let mut stream = response.bytes_stream();
+        let mut buffer = String::new();
+
+        while let Some(chunk_result) = stream.next().await {
+            match chunk_result {
+                Ok(bytes) => {
+                    let text = match String::from_utf8(bytes.to_vec()) {
+                        Ok(t) => t,
+                        Err(_) => continue,
+                    };
+                    buffer.push_str(&text);
+
+                    // Process complete SSE events from buffer
+                    while let Some(event_end) = buffer.find("\n\n") {
+                        let event_str = buffer[..event_end].to_string();
+                        buffer = buffer[event_end + 2..].to_string();
+
+                        // Parse SSE event
+                        let mut data = String::new();
+                        for line in event_str.lines() {
+                            if let Some(rest) = line.strip_prefix("data:") {
+                                data = rest.trim().to_string();
+                            } else if line.starts_with("data:") {
+                                data = line[5..].trim().to_string();
+                            }
+                        }
+
+                        if data == "[DONE]" {
+                            tracing::debug!(req = %req_id, "Stream completed");
+                            let finish_events = converter.finish();
+                            for event in finish_events {
+                                if tx.send(Ok(event.to_sse_string())).await.is_err() {
+                                    return;
+                                }
+                            }
+                            return;
+                        }
+
+                        if !data.is_empty() {
+                            if let Ok(chunk) = serde_json::from_str::<ChatCompletionChunk>(&data) {
+                                let events = converter.convert_chunk(&chunk);
+                                for event in events {
+                                    if tx.send(Ok(event.to_sse_string())).await.is_err() {
+                                        return;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                Err(_) => {
+                    break;
+                }
+            }
+        }
+
+        // If we exit the loop without [DONE], still finish
+        let finish_events = converter.finish();
+        for event in finish_events {
+            let _ = tx.send(Ok(event.to_sse_string())).await;
+        }
+    });
+
+    // Create response stream
+    let stream = ReceiverStream::new(rx);
+    let body = Body::from_stream(stream);
+
+    Ok(Response::builder()
+        .status(StatusCode::OK)
+        .header(header::CONTENT_TYPE, "text/event-stream")
+        .header(header::CACHE_CONTROL, "no-cache")
+        .header(header::CONNECTION, "keep-alive")
+        .body(body)
+        .unwrap())
+}

src/server.rs

@@ -12,6 +12,7 @@ pub fn create_router(state: AppState) -> Router {
         .route("/", get(health_check))
         .route("/v1/messages", post(handlers::messages))
         .route("/v1/messages/count_tokens", post(handlers::count_tokens))
+        .route("/v1/responses", post(handlers::responses))
         .layer(TraceLayer::new_for_http())
         .with_state(state)
 }

src/types/mod.rs

@@ -1,2 +1,3 @@
 pub mod anthropic;
 pub mod openrouter;
+pub mod responses;

src/types/openrouter.rs

@@ -2,7 +2,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_json::value::RawValue;
 
 // Request types
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct CreateChatCompletionRequest {
     pub messages: Vec<ChatCompletionMessage>,
     pub model: String,

src/types/responses.rs

@@ -0,0 +1,303 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+// ============== Request Types ==============
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CreateResponseRequest {
+    pub model: String,
+    pub input: Input,
+    #[serde(default)]
+    pub stream: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub instructions: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_output_tokens: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub temperature: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_p: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tools: Option<Vec<Tool>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_choice: Option<ToolChoice>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<std::collections::HashMap<String, String>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum Input {
+    Text(String),
+    Messages(Vec<InputMessage>),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct InputMessage {
+    pub role: String,
+    #[serde(flatten)]
+    pub content: InputMessageContent,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum InputMessageContent {
+    Text { content: String },
+    Array { content: Vec<ContentPart> },
+    FunctionCall {
+        #[serde(rename = "type")]
+        content_type: String, // "function_call"
+        call_id: String,
+        name: String,
+        arguments: String,
+    },
+    FunctionCallOutput {
+        #[serde(rename = "type")]
+        content_type: String, // "function_call_output"
+        call_id: String,
+        output: String,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum ContentPart {
+    #[serde(rename = "input_text")]
+    InputText { text: String },
+    #[serde(rename = "input_image")]
+    InputImage { image_url: String },
+    #[serde(rename = "output_text")]
+    OutputText { text: String },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum Tool {
+    #[serde(rename = "function")]
+    Function {
+        name: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        description: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        parameters: Option<Value>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        strict: Option<bool>,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum ToolChoice {
+    Auto(String), // "auto", "none", "required"
+    Function {
+        #[serde(rename = "type")]
+        choice_type: String,
+        name: String
+    },
+}
+
+// ============== Response Types ==============
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Response {
+    pub id: String,
+    pub object: String, // "response"
+    pub created_at: i64,
+    pub model: String,
+    pub status: ResponseStatus,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<ResponseError>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub instructions: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_output_tokens: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub temperature: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_p: Option<f64>,
+    pub output: Vec<OutputItem>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub usage: Option<ResponseUsage>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum ResponseStatus {
+    InProgress,
+    Completed,
+    Failed,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ResponseError {
+    pub code: String,
+    pub message: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ResponseUsage {
+    pub input_tokens: i64,
+    pub output_tokens: i64,
+    pub total_tokens: i64,
+}
+
+// ============== Output Items ==============
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum OutputItem {
+    #[serde(rename = "message")]
+    Message {
+        id: String,
+        role: String,
+        status: OutputStatus,
+        content: Vec<OutputContent>,
+    },
+    #[serde(rename = "reasoning")]
+    Reasoning {
+        id: String,
+        status: OutputStatus,
+        content: Vec<ReasoningContent>,
+    },
+    #[serde(rename = "function_call")]
+    FunctionCall {
+        id: String,
+        call_id: String,
+        name: String,
+        arguments: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        status: Option<OutputStatus>,
+    },
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum OutputStatus {
+    InProgress,
+    Completed,
+    Incomplete,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum OutputContent {
+    #[serde(rename = "output_text")]
+    Text { text: String },
+    #[serde(rename = "refusal")]
+    Refusal { refusal: String },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum ReasoningContent {
+    #[serde(rename = "reasoning_text")]
+    Text { text: String },
+}
+
+// ============== Streaming Events ==============
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum StreamEvent {
+    #[serde(rename = "response.created")]
+    ResponseCreated {
+        response: Response,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.in_progress")]
+    ResponseInProgress {
+        response: Response,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.completed")]
+    ResponseCompleted {
+        response: Response,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.failed")]
+    ResponseFailed {
+        response: Response,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.output_item.added")]
+    OutputItemAdded {
+        output_index: i64,
+        item: OutputItem,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.output_item.done")]
+    OutputItemDone {
+        output_index: i64,
+        item: OutputItem,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.content_part.added")]
+    ContentPartAdded {
+        item_id: String,
+        output_index: i64,
+        content_index: i64,
+        part: OutputContent,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.content_part.done")]
+    ContentPartDone {
+        item_id: String,
+        output_index: i64,
+        content_index: i64,
+        part: OutputContent,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.output_text.delta")]
+    OutputTextDelta {
+        item_id: String,
+        output_index: i64,
+        content_index: i64,
+        delta: String,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.output_text.done")]
+    OutputTextDone {
+        item_id: String,
+        output_index: i64,
+        content_index: i64,
+        text: String,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.reasoning_text.delta")]
+    ReasoningTextDelta {
+        item_id: String,
+        output_index: i64,
+        content_index: i64,
+        delta: String,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.reasoning_text.done")]
+    ReasoningTextDone {
+        item_id: String,
+        output_index: i64,
+        content_index: i64,
+        text: String,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.function_call_arguments.delta")]
+    FunctionCallArgumentsDelta {
+        item_id: String,
+        output_index: i64,
+        delta: String,
+        sequence_number: i64,
+    },
+    #[serde(rename = "response.function_call_arguments.done")]
+    FunctionCallArgumentsDone {
+        item_id: String,
+        output_index: i64,
+        arguments: String,
+        sequence_number: i64,
+    },
+}
+
+impl StreamEvent {
+    pub fn to_sse_string(&self) -> String {
+        let json = serde_json::to_string(self).unwrap_or_default();
+        format!("data: {}\n\n", json)
+    }
+}