Skip to content

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

Rust

capture and map provider-native OpenAI events

Raine Virta8d3aec45bdb9
diff --git a/src/openai_compat/response.rs b/src/openai_compat/response.rs
index ca142da..141313d 100644
--- a/src/openai_compat/response.rs
+++ b/src/openai_compat/response.rs
@@ -21,6 +21,12 @@ pub enum BlockKind {
name: String,
arguments: String,
},
+ HostedSearch {
+ id: String,
+ name: String,
+ arguments: String,
+ },
+ HostedResult,
}
#[derive(Debug, Clone)]
@@ -65,6 +71,7 @@ pub struct AnthropicAccumulator {
pub blocks: Vec<Block>,
pub stop_reason: Option<String>,
pub usage: Usage,
+ pub citations: Vec<Value>,
pub stopped: bool,
}
@@ -124,6 +131,12 @@ impl AnthropicAccumulator {
.filter(|value| value != "{}")
.unwrap_or_default(),
},
+ Some("server_tool_use") => BlockKind::HostedSearch {
+ id: required_block_string(block, "id")?,
+ name: required_block_string(block, "name")?,
+ arguments: String::new(),
+ },
+ Some(kind) if kind.ends_with("_tool_result") => BlockKind::HostedResult,
Some(other) => {
return Err(OpenAiError::invalid(
format!("Unsupported provider output block '{other}'"),
@@ -173,7 +186,11 @@ impl AnthropicAccumulator {
);
}
(Some("signature_delta"), BlockKind::Thinking { .. }) => {}
- (Some("input_json_delta"), BlockKind::Tool { arguments, .. }) => {
+ (
+ Some("input_json_delta"),
+ BlockKind::Tool { arguments, .. }
+ | BlockKind::HostedSearch { arguments, .. },
+ ) => {
arguments.push_str(
delta
.get("partial_json")
@@ -181,6 +198,11 @@ impl AnthropicAccumulator {
.unwrap_or_default(),
);
}
+ (Some("citations_delta"), BlockKind::Text { .. }) => {
+ if let Some(citation) = delta.get("citation") {
+ self.citations.push(openai_citation(citation));
+ }
+ }
_ => {
return Err(OpenAiError::invalid(
"Provider delta does not match its content block",
@@ -330,6 +352,12 @@ pub fn chat_response(
if !tools.is_empty() {
message.insert("tool_calls".to_string(), Value::Array(tools));
}
+ if !state.citations.is_empty() {
+ message.insert(
+ "annotations".to_string(),
+ Value::Array(state.citations.clone()),
+ );
+ }
json!({
"id":response_id,
"object":"chat.completion",
@@ -382,24 +410,34 @@ pub fn responses_response(
"type":"message",
"role":"assistant",
"status":"completed",
- "content":[{"type":"output_text", "text":text, "annotations":[]}],
+ "content":[{"type":"output_text", "text":text, "annotations":state.citations}],
}));
}
for (index, block) in state.blocks.iter().enumerate() {
- if let BlockKind::Tool {
- id,
- name,
- arguments,
- } = &block.kind
- {
- output.push(json!({
+ match &block.kind {
+ BlockKind::Tool {
+ id,
+ name,
+ arguments,
+ } => 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",
- }));
+ })),
+ BlockKind::HostedSearch {
+ id,
+ name,
+ arguments,
+ } => output.push(json!({
+ "id":id,
+ "type":"web_search_call",
+ "status":"completed",
+ "action":hosted_search_action(name, arguments),
+ })),
+ _ => {}
}
}
json!({
@@ -424,6 +462,31 @@ pub fn chat_finish_reason(reason: Option<&str>) -> &'static str {
}
}
+pub fn hosted_search_action(_name: &str, arguments: &str) -> Value {
+ let query = serde_json::from_str::<Value>(arguments)
+ .ok()
+ .and_then(|value| {
+ value
+ .get("query")
+ .and_then(Value::as_str)
+ .map(str::to_string)
+ })
+ .unwrap_or_default();
+ json!({"type":"search", "query":query})
+}
+
+fn openai_citation(citation: &Value) -> Value {
+ json!({
+ "type":"url_citation",
+ "url_citation":{
+ "url":citation.get("url").and_then(Value::as_str).unwrap_or_default(),
+ "title":citation.get("title").and_then(Value::as_str).unwrap_or_default(),
+ "start_index":0,
+ "end_index":0,
+ }
+ })
+}
+
pub fn normalized_arguments(arguments: &str) -> String {
if arguments.is_empty() {
"{}".to_string()
@@ -505,6 +568,85 @@ mod tests {
]
}
+ #[test]
+ fn maps_hosted_search_and_citations_to_responses() {
+ let events = vec![
+ SseEvent {
+ event: Some("message_start".into()),
+ data: json!({"type":"message_start","message":{"id":"msg_1","usage":{}}}),
+ },
+ SseEvent {
+ event: Some("content_block_start".into()),
+ data: json!({"type":"content_block_start","index":0,"content_block":{"type":"server_tool_use","id":"search_1","name":"x_search","input":{}}}),
+ },
+ SseEvent {
+ event: Some("content_block_delta".into()),
+ data: json!({"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"{\"query\":\"rust\"}"}}),
+ },
+ 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":"x_search_tool_result","tool_use_id":"search_1","content":[]}}),
+ },
+ SseEvent {
+ event: Some("content_block_stop".into()),
+ data: json!({"type":"content_block_stop","index":1}),
+ },
+ SseEvent {
+ event: Some("content_block_start".into()),
+ data: json!({"type":"content_block_start","index":2,"content_block":{"type":"text","text":""}}),
+ },
+ SseEvent {
+ event: Some("content_block_delta".into()),
+ data: json!({"type":"content_block_delta","index":2,"delta":{"type":"text_delta","text":"result"}}),
+ },
+ SseEvent {
+ event: Some("content_block_delta".into()),
+ data: json!({"type":"content_block_delta","index":2,"delta":{"type":"citations_delta","citation":{"url":"https://example.com","title":"Example"}}}),
+ },
+ SseEvent {
+ event: Some("content_block_stop".into()),
+ data: json!({"type":"content_block_stop","index":2}),
+ },
+ SseEvent {
+ event: Some("message_delta".into()),
+ data: json!({"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":1}}),
+ },
+ SseEvent {
+ event: Some("message_stop".into()),
+ data: json!({"type":"message_stop"}),
+ },
+ ];
+ let response = buffered_response(
+ OpenAiSurface::Responses,
+ &events,
+ "resp_test",
+ "grok-4.5",
+ 1,
+ )
+ .unwrap();
+ assert!(
+ response["output"]
+ .as_array()
+ .unwrap()
+ .iter()
+ .any(|item| item["type"] == "web_search_call")
+ );
+ let message = response["output"]
+ .as_array()
+ .unwrap()
+ .iter()
+ .find(|item| item["type"] == "message")
+ .unwrap();
+ assert_eq!(
+ message["content"][0]["annotations"][0]["type"],
+ "url_citation"
+ );
+ }
+
#[test]
fn renders_chat_tool_calls_and_usage() {
let response = buffered_response(
diff --git a/src/openai_compat/stream.rs b/src/openai_compat/stream.rs
index 4130343..4ead47a 100644
--- a/src/openai_compat/stream.rs
+++ b/src/openai_compat/stream.rs
@@ -1,4 +1,4 @@
-use std::{collections::VecDeque, convert::Infallible};
+use std::{collections::VecDeque, convert::Infallible, sync::Arc};
use axum::{
Json,
@@ -13,13 +13,14 @@ use serde_json::{Value, json};
use crate::{
provider::{Generation, GenerationBody},
providers::codex::native::NativeResponseOutcome,
+ traffic::{MAX_SSE_CAPTURE_BYTES, TrafficCapture},
};
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,
+ hosted_search_action, normalized_arguments, responses_response,
},
};
@@ -66,6 +67,7 @@ pub async fn openai_response(
stream: bool,
include_usage: bool,
model: String,
+ traffic: Option<Arc<TrafficCapture>>,
) -> Result<Response, OpenAiError> {
let response_id = match surface {
OpenAiSurface::ChatCompletions => format!("chatcmpl-{}", uuid::Uuid::new_v4().simple()),
@@ -80,11 +82,15 @@ pub async fn openai_response(
response_id,
model,
created,
+ traffic,
));
}
let bytes = collect_generation(generation.body).await?;
let events = decode_all(&bytes)?;
let value = buffered_response(surface, &events, &response_id, &model, created)?;
+ if let Some(capture) = traffic.as_ref() {
+ capture.write_json("071-openai-downstream-response", &value);
+ }
Ok((StatusCode::OK, Json(value)).into_response())
}
@@ -140,6 +146,7 @@ fn streaming_response(
response_id: String,
model: String,
created: u64,
+ traffic: Option<Arc<TrafficCapture>>,
) -> Response {
let outcome = NativeResponseOutcome::default();
let state = StreamState {
@@ -153,6 +160,10 @@ fn streaming_response(
finished: false,
bytes: 0,
outcome: outcome.clone(),
+ traffic,
+ downstream: Vec::new(),
+ downstream_truncated: false,
+ capture_finished: false,
};
let stream = futures_util::stream::unfold(state, |mut state| async move {
state
@@ -181,15 +192,26 @@ struct StreamState {
finished: bool,
bytes: usize,
outcome: NativeResponseOutcome,
+ traffic: Option<Arc<TrafficCapture>>,
+ downstream: Vec<u8>,
+ downstream_truncated: bool,
+ capture_finished: bool,
}
impl StreamState {
async fn next(&mut self) -> Option<Bytes> {
loop {
if let Some(bytes) = self.pending.pop_front() {
+ self.capture_bytes(&bytes);
return Some(bytes);
}
if self.finished {
+ let outcome = if self.outcome.failure().is_some() {
+ "failed"
+ } else {
+ "completed"
+ };
+ self.finish_capture(outcome);
return None;
}
match self.body.frame().await {
@@ -244,6 +266,32 @@ impl StreamState {
}
}
+ fn capture_bytes(&mut self, bytes: &[u8]) {
+ if self.downstream.len().saturating_add(bytes.len()) <= MAX_SSE_CAPTURE_BYTES {
+ self.downstream.extend_from_slice(bytes);
+ } else {
+ self.downstream_truncated = true;
+ }
+ }
+
+ fn finish_capture(&mut self, outcome: &str) {
+ if self.capture_finished {
+ return;
+ }
+ self.capture_finished = true;
+ if let Some(traffic) = self.traffic.as_ref() {
+ traffic.write_bytes("071-openai-downstream.sse", &self.downstream);
+ traffic.write_json(
+ "072-openai-stream-summary",
+ &json!({
+ "outcome":outcome,
+ "capturedBytes":self.downstream.len(),
+ "truncated":self.downstream_truncated,
+ }),
+ );
+ }
+ }
+
fn fail(&mut self, error: OpenAiError) {
self.outcome.fail(error.message.to_string());
self.pending.extend(self.renderer.failure(&error));
@@ -251,6 +299,14 @@ impl StreamState {
}
}
+impl Drop for StreamState {
+ fn drop(&mut self) {
+ if !self.capture_finished {
+ self.finish_capture("abandoned");
+ }
+ }
+}
+
struct Renderer {
surface: OpenAiSurface,
include_usage: bool,
@@ -325,7 +381,17 @@ impl Renderer {
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("input_json_delta") => {
+ if self.state.blocks.iter().any(|block| {
+ block.index == index as usize
+ && matches!(block.kind, BlockKind::Tool { .. })
+ }) {
+ json!({"tool_calls":[{"index":index,"function":{"arguments":delta.get("partial_json").and_then(Value::as_str).unwrap_or_default()}}]})
+ } else {
+ return Ok(out);
+ }
+ }
+ Some("citations_delta") => json!({"annotations":self.state.citations.last().cloned().into_iter().collect::<Vec<_>>()}),
Some("signature_delta") => return Ok(out),
_ => return Err(OpenAiError::invalid("Unsupported provider content delta", None::<String>)),
};
@@ -384,6 +450,7 @@ impl Renderer {
.iter()
.rev()
.find(|block| block.index == index)
+ .cloned()
.ok_or_else(|| {
OpenAiError::invalid("Provider content block is missing", None::<String>)
})?;
@@ -410,6 +477,11 @@ impl Renderer {
"output_index":index,
"item":{"id":self.block_item_id("fc", index),"type":"function_call","call_id":id,"name":name,"arguments":"","status":"in_progress"},
}))),
+ BlockKind::HostedSearch { id, .. } => out.push(self.responses_event("response.output_item.added", json!({
+ "output_index":index,
+ "item":{"id":id,"type":"web_search_call","status":"in_progress"},
+ }))),
+ BlockKind::HostedResult => {}
}
}
"content_block_delta" => {
@@ -428,9 +500,20 @@ impl Renderer {
"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("input_json_delta") => {
+ if self.state.blocks.iter().any(|block| {
+ block.index == index && matches!(block.kind, BlockKind::Tool { .. })
+ }) {
+ 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("citations_delta") => out.push(self.responses_event("response.output_text.annotation.added", json!({
+ "item_id":self.message_item_id(),"output_index":index,"content_index":0,
+ "annotation_index":self.state.citations.len().saturating_sub(1),
+ "annotation":self.state.citations.last().cloned().unwrap_or(Value::Null),
}))),
Some("signature_delta") => {}
_ => return Err(OpenAiError::invalid("Unsupported provider content delta", None::<String>)),
@@ -459,11 +542,11 @@ impl Renderer {
})));
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":[]},
+ "part":{"type":"output_text","text":text,"annotations":self.state.citations},
})));
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":[]}]},
+ "item":{"id":self.message_item_id(),"type":"message","role":"assistant","status":"completed","content":[{"type":"output_text","text":text,"annotations":self.state.citations}]},
})));
}
BlockKind::Thinking { text } => {
@@ -489,6 +572,15 @@ impl Renderer {
"item":{"id":self.block_item_id("fc", index),"type":"function_call","call_id":id,"name":name,"arguments":arguments,"status":"completed"},
})));
}
+ BlockKind::HostedSearch {
+ id,
+ name,
+ arguments,
+ } => out.push(self.responses_event("response.output_item.done", json!({
+ "output_index":index,
+ "item":{"id":id,"type":"web_search_call","status":"completed","action":hosted_search_action(&name, &arguments)},
+ }))),
+ BlockKind::HostedResult => {}
}
}
"message_stop" => {
@@ -651,6 +743,7 @@ mod tests {
"chatcmpl_test".into(),
"kimi-k2.6".into(),
1,
+ None,
);
let bytes = response.into_body().collect().await.unwrap().to_bytes();
let text = String::from_utf8(bytes.to_vec()).unwrap();
@@ -677,6 +770,7 @@ mod tests {
"resp_test".into(),
"grok-4.5".into(),
1,
+ None,
);
let bytes = response.into_body().collect().await.unwrap().to_bytes();
let text = String::from_utf8(bytes.to_vec()).unwrap();
diff --git a/src/providers/cursor/mod.rs b/src/providers/cursor/mod.rs
index 69a8501..3d7732d 100644
--- a/src/providers/cursor/mod.rs
+++ b/src/providers/cursor/mod.rs
@@ -291,6 +291,16 @@ impl Provider for CursorProvider {
}
let prompt = render_cursor_prompt(&body);
let images = request::cursor_selected_images(&body);
+ if let Some(traffic) = ctx.traffic.as_ref() {
+ traffic.write_json(
+ "020-upstream-request",
+ &serde_json::json!({
+ "model": requested,
+ "prompt": prompt,
+ "image_count": images.len(),
+ }),
+ );
+ }
if let Some(monitor) = ctx.monitor.as_ref() {
monitor.upstream_started(&ctx.req_id);
}
@@ -298,6 +308,9 @@ impl Provider for CursorProvider {
.run_agent(&auth.access_token, &prompt, &requested, &images)
.await
.map_err(cursor_provider_error)?;
+ if let Some(traffic) = ctx.traffic.as_ref() {
+ traffic.write_bytes("032-upstream-response-body.bin", &upstream.body);
+ }
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)?;
@@ -314,6 +327,9 @@ impl Provider for CursorProvider {
} else {
sse::frame_cursor_stream(&upstream, &message_id, &requested)
};
+ if let Some(traffic) = ctx.traffic.as_ref() {
+ traffic.write_bytes("050-anthropic-intermediate.sse", &bytes);
+ }
if let Some(monitor) = ctx.monitor.as_ref() {
let (input_tokens, output_tokens) = usage_from_anthropic_sse(&bytes);
monitor.stream_progress(
diff --git a/src/providers/kimi/mod.rs b/src/providers/kimi/mod.rs
index 7184f16..beff04c 100644
--- a/src/providers/kimi/mod.rs
+++ b/src/providers/kimi/mod.rs
@@ -226,6 +226,12 @@ impl Provider for KimiProvider {
error.to_string(),
)
})?;
+ if let Some(traffic) = ctx.traffic.as_ref() {
+ traffic.write_json(
+ "020-upstream-request",
+ &serde_json::to_value(&translated).unwrap_or_default(),
+ );
+ }
if let Some(monitor) = ctx.monitor.as_ref() {
monitor.upstream_started(&ctx.req_id);
}
@@ -244,6 +250,9 @@ impl Provider for KimiProvider {
)
})?
.map_err(kimi_provider_error)?;
+ if let Some(traffic) = ctx.traffic.as_ref() {
+ traffic.write_bytes("032-upstream-response-body.sse", &upstream.body);
+ }
let message_id = format!("msg_{}", uuid::Uuid::new_v4().simple());
let sse =
translate_stream_bytes(&upstream.body, &message_id, &requested).map_err(|error| {
@@ -253,6 +262,9 @@ impl Provider for KimiProvider {
format!("Stream translation error: {error}"),
)
})?;
+ if let Some(traffic) = ctx.traffic.as_ref() {
+ traffic.write_bytes("050-anthropic-intermediate.sse", &sse);
+ }
if let Some(monitor) = ctx.monitor.as_ref() {
let (input_tokens, output_tokens) = usage_from_anthropic_sse(&sse);
monitor.stream_progress(
diff --git a/src/server.rs b/src/server.rs
index b895698..7210b48 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -779,6 +779,7 @@ async fn handler_responses(State(state): State<Arc<AppState>>, req: Request<Body
parsed.stream,
parsed.include_usage,
normalized_model.clone(),
+ traffic.clone(),
)
.await
{
@@ -1030,6 +1031,7 @@ async fn handler_chat_completions(
parsed.stream,
parsed.include_usage,
normalized_model.clone(),
+ traffic.clone(),
)
.await
{