Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

refactor(ai-gateway): name command methods as verbs (#17607)

Hassieb Pakzadfaa1007edec5
diff --git a/ai-gateway/AGENTS.md b/ai-gateway/AGENTS.md
new file mode 100644
index 0000000000..ce3c804d86
--- /dev/null
+++ b/ai-gateway/AGENTS.md
@@ -0,0 +1,11 @@
+# Agent Guidelines for `ai-gateway`
+
+## Method naming
+
+- Getters stay nouns or `is_` / `has_`: `id()`, `attribution()`, `is_ready()`.
+- Constructors use `new`, `from_*`, `with_*`, or `for_*`.
+- Command methods that mutate, parse, extract, or drive a lifecycle use a
+ verb-object name: `record_response`, `push_bytes`, `capture_request`,
+ `apply_baggage`, `parse_claude_code`.
+- Do not name a mutating method after the payload it consumes (`response`,
+ `bytes`, `event`, `item`).
diff --git a/ai-gateway/CLAUDE.md b/ai-gateway/CLAUDE.md
new file mode 120000
index 0000000000..47dc3e3d86
--- /dev/null
+++ b/ai-gateway/CLAUDE.md
@@ -0,0 +1 @@
+AGENTS.md
\ No newline at end of file
diff --git a/ai-gateway/src/capture/mod.rs b/ai-gateway/src/capture/mod.rs
index d26710a8ab..cee1caf80a 100644
--- a/ai-gateway/src/capture/mod.rs
+++ b/ai-gateway/src/capture/mod.rs
@@ -27,15 +27,15 @@ enum ProtocolCapture {
}
impl ProtocolCapture {
- fn response(&mut self, headers: &HeaderMap) {
+ fn record_response(&mut self, headers: &HeaderMap) {
match self {
- Self::OpenAiResponses(capture) => capture.response(headers),
+ Self::OpenAiResponses(capture) => capture.record_response(headers),
}
}
- fn bytes(&mut self, bytes: &[u8]) -> bool {
+ fn push_bytes(&mut self, bytes: &[u8]) -> bool {
match self {
- Self::OpenAiResponses(capture) => capture.bytes(bytes),
+ Self::OpenAiResponses(capture) => capture.push_bytes(bytes),
}
}
@@ -84,7 +84,7 @@ impl ExecutionCapture {
}
}
- pub fn openai_responses(
+ pub fn for_openai_responses(
context: &ResolvedRequestContext,
headers: &HeaderMap,
body: &[u8],
@@ -144,20 +144,20 @@ impl ExecutionCapture {
));
}
- pub fn response(&mut self, status: u16, headers: &HeaderMap) {
+ pub fn record_response(&mut self, status: u16, headers: &HeaderMap) {
if let Some(protocol) = &mut self.protocol {
self.http_status = Some(status);
- protocol.response(headers);
+ protocol.record_response(headers);
}
}
- pub fn bytes(&mut self, bytes: &[u8]) {
+ pub fn push_bytes(&mut self, bytes: &[u8]) {
if let Some(protocol) = &mut self.protocol {
if !bytes.is_empty() {
self.first_byte_ms
.get_or_insert_with(|| self.started.elapsed().as_millis());
}
- if protocol.bytes(bytes) {
+ if protocol.push_bytes(bytes) {
self.completion_start_ms
.get_or_insert_with(|| self.started.elapsed().as_millis());
}
diff --git a/ai-gateway/src/capture/openai_responses.rs b/ai-gateway/src/capture/openai_responses.rs
index 5803a1ba6c..e4b16a3b41 100644
--- a/ai-gateway/src/capture/openai_responses.rs
+++ b/ai-gateway/src/capture/openai_responses.rs
@@ -44,13 +44,13 @@ impl OpenAiResponsesCapture {
&& body.len() <= MAX_CAPTURE_BYTES
&& let Ok(Value::Object(request)) = serde_json::from_slice(body)
{
- capture.request(request);
+ capture.capture_request(request);
capture.request_complete = true;
}
capture
}
- pub fn response(&mut self, headers: &HeaderMap) {
+ pub fn record_response(&mut self, headers: &HeaderMap) {
self.facts.provider_request_id = headers
.get("x-request-id")
.and_then(|v| v.to_str().ok())
@@ -77,13 +77,13 @@ impl OpenAiResponsesCapture {
}
}
- pub fn bytes(&mut self, bytes: &[u8]) -> bool {
+ pub fn push_bytes(&mut self, bytes: &[u8]) -> bool {
let mut body = std::mem::replace(&mut self.body, ResponseBody::Unavailable);
let mut completion_started = false;
match &mut body {
ResponseBody::Sse(sse) => {
sse.push(bytes, MAX_CAPTURE_BYTES, |event| {
- completion_started |= self.event(event);
+ completion_started |= self.handle_event(event);
});
}
ResponseBody::Json(buffer)
@@ -105,10 +105,10 @@ impl OpenAiResponsesCapture {
match std::mem::replace(&mut self.body, ResponseBody::Unavailable) {
ResponseBody::Json(bytes) => match serde_json::from_slice::<Value>(&bytes) {
Ok(Value::Object(response)) => {
- self.response_facts(&response);
+ self.capture_response_facts(&response);
if let Some(output) = response.get("output").and_then(Value::as_array) {
for (index, item) in output.iter().enumerate() {
- self.item(index as u64, item.clone());
+ self.store_item(index as u64, item.clone());
}
self.facts.output_complete = self.response_valid;
}
@@ -137,7 +137,7 @@ impl OpenAiResponsesCapture {
self.facts
}
- fn request(&mut self, mut request: Map<String, Value>) {
+ fn capture_request(&mut self, mut request: Map<String, Value>) {
self.facts.requested_model = request
.get("model")
.and_then(Value::as_str)
@@ -193,7 +193,7 @@ impl OpenAiResponsesCapture {
}
}
- fn event(&mut self, bytes: &[u8]) -> bool {
+ fn handle_event(&mut self, bytes: &[u8]) -> bool {
let Ok(Value::Object(mut event)) = serde_json::from_slice(bytes) else {
self.response_valid = false;
return false;
@@ -228,7 +228,7 @@ impl OpenAiResponsesCapture {
event.get("output_index").and_then(Value::as_u64),
event.remove("item").filter(Value::is_object),
) {
- self.item(index, item);
+ self.store_item(index, item);
} else {
self.response_valid = false;
}
@@ -245,7 +245,7 @@ impl OpenAiResponsesCapture {
Some("response.completed" | "response.failed" | "response.incomplete")
);
if let Some(response) = event.get("response").and_then(Value::as_object) {
- self.response_facts(response);
+ self.capture_response_facts(response);
if terminal {
self.terminal = true;
self.expected_items = response
@@ -259,14 +259,14 @@ impl OpenAiResponsesCapture {
}
Some("error") => {
self.facts.provider_status = Some("failed".to_owned());
- self.error(&event);
+ self.record_error(&event);
}
_ => {}
}
false
}
- fn item(&mut self, index: u64, item: Value) {
+ fn store_item(&mut self, index: u64, item: Value) {
if self.mode != IngestionMode::Full {
return;
}
@@ -285,9 +285,9 @@ impl OpenAiResponsesCapture {
self.items.insert(index, item);
}
- fn response_facts(&mut self, response: &Map<String, Value>) {
+ fn capture_response_facts(&mut self, response: &Map<String, Value>) {
if let Some(error) = response.get("error").and_then(Value::as_object) {
- self.error(error);
+ self.record_error(error);
}
for (key, target) in [
("id", &mut self.facts.provider_response_id),
@@ -317,7 +317,7 @@ impl OpenAiResponsesCapture {
}
}
- fn error(&mut self, error: &Map<String, Value>) {
+ fn record_error(&mut self, error: &Map<String, Value>) {
// Provider error messages may echo prompt content, so retain them only in full mode.
if self.mode != IngestionMode::Full {
return;
diff --git a/ai-gateway/src/capture/openai_responses/tests.rs b/ai-gateway/src/capture/openai_responses/tests.rs
index 7efbf55a92..c6c3a1ba05 100644
--- a/ai-gateway/src/capture/openai_responses/tests.rs
+++ b/ai-gateway/src/capture/openai_responses/tests.rs
@@ -24,17 +24,17 @@ fn captured(execution: &ExecutionCapture) -> &OpenAiResponsesCapture {
async fn observer(mode: &'static str) -> ExecutionCapture {
let context = resolved_request_context_with_mode("provider-secret", mode).await;
- ExecutionCapture::openai_responses(&context, &HeaderMap::new(), br#"{"model":"requested","instructions":"prompt-canary","input":[{"role":"user","content":"hello"}],"tools":[{"type":"function","name":"weather","parameters":{"type":"object"}}],"text":{"format":{"type":"json_schema","schema":{"description":"schema-canary"}}},"service_tier":"auto","metadata":{"label":"request-metadata-canary"},"safety_identifier":"safety-id-canary","prompt_cache_key":"cache-id-canary","user":"user-id-canary"}"#)
+ ExecutionCapture::for_openai_responses(&context, &HeaderMap::new(), br#"{"model":"requested","instructions":"prompt-canary","input":[{"role":"user","content":"hello"}],"tools":[{"type":"function","name":"weather","parameters":{"type":"object"}}],"text":{"format":{"type":"json_schema","schema":{"description":"schema-canary"}}},"service_tier":"auto","metadata":{"label":"request-metadata-canary"},"safety_identifier":"safety-id-canary","prompt_cache_key":"cache-id-canary","user":"user-id-canary"}"#)
}
-fn response(observer: &mut ExecutionCapture, content_type: &'static str) {
+fn record_response(observer: &mut ExecutionCapture, content_type: &'static str) {
let mut headers = HeaderMap::new();
headers.insert(header::CONTENT_TYPE, HeaderValue::from_static(content_type));
headers.insert(
"x-request-id",
HeaderValue::from_static("provider-request-1"),
);
- observer.response(200, &headers);
+ observer.record_response(200, &headers);
}
fn event(kind: &str, fields: Value) -> String {
@@ -60,7 +60,7 @@ fn terminal(status: &str, count: usize) -> String {
#[tokio::test]
async fn captures_completed_items_only_in_order_without_duplication() {
let mut observer = observer("full").await;
- response(&mut observer, "text/event-stream; charset=utf-8");
+ record_response(&mut observer, "text/event-stream; charset=utf-8");
let body = format!(
": ping\n\n{}{}{}{}{}",
event(
@@ -73,7 +73,7 @@ async fn captures_completed_items_only_in_order_without_duplication() {
terminal("completed", 2)
);
for byte in body.as_bytes() {
- observer.bytes(&[*byte]);
+ observer.push_bytes(&[*byte]);
}
observer.end_body();
let capture = captured(&observer);
@@ -104,9 +104,10 @@ async fn captures_completed_items_only_in_order_without_duplication() {
#[tokio::test]
async fn eof_and_item_completion_are_not_provider_completion() {
let mut observer = observer("full").await;
- response(&mut observer, "text/event-stream");
- observer.bytes(completed_item(0, "completed item").as_bytes());
- observer.bytes(event("response.output_text.delta", json!({"delta":"unfinished"})).as_bytes());
+ record_response(&mut observer, "text/event-stream");
+ observer.push_bytes(completed_item(0, "completed item").as_bytes());
+ observer
+ .push_bytes(event("response.output_text.delta", json!({"delta":"unfinished"})).as_bytes());
observer.end_body();
let capture = captured(&observer);
assert_eq!(capture.items.len(), 1);
@@ -119,8 +120,8 @@ async fn eof_and_item_completion_are_not_provider_completion() {
async fn failed_and_incomplete_responses_keep_usage_and_native_status() {
for status in ["failed", "incomplete"] {
let mut observer = observer("full").await;
- response(&mut observer, "text/event-stream");
- observer.bytes(terminal(status, 0).as_bytes());
+ record_response(&mut observer, "text/event-stream");
+ observer.push_bytes(terminal(status, 0).as_bytes());
observer.end_body();
let capture = captured(&observer);
assert_eq!(capture.facts.provider_status.as_deref(), Some(status));
@@ -136,10 +137,10 @@ async fn failed_and_incomplete_responses_keep_usage_and_native_status() {
async fn json_and_streaming_capture_equivalent_native_items_and_facts() {
let item = json!({"type":"function_call","id":"item-1","call_id":"call-1","name":"weather","arguments":"{\"city\":\"Berlin\"}"});
let mut json_observer = observer("full").await;
- response(&mut json_observer, "application/json");
+ record_response(&mut json_observer, "application/json");
let body = json!({"id":"resp-1","model":"actual","status":"completed","output":[item.clone()],"usage":{"input_tokens":5,"output_tokens":2,"total_tokens":7}}).to_string();
for chunk in body.as_bytes().chunks(3) {
- json_observer.bytes(chunk);
+ json_observer.push_bytes(chunk);
}
json_observer.end_body();
let captured = captured(&json_observer);
@@ -154,9 +155,9 @@ async fn json_and_streaming_capture_equivalent_native_items_and_facts() {
#[tokio::test]
async fn usage_mode_excludes_content_and_context_credentials() {
let mut observer = observer("usage").await;
- response(&mut observer, "text/event-stream");
- observer.bytes(completed_item(0, "output-canary").as_bytes());
- observer.bytes(terminal("completed", 1).as_bytes());
+ record_response(&mut observer, "text/event-stream");
+ observer.push_bytes(completed_item(0, "output-canary").as_bytes());
+ observer.push_bytes(terminal("completed", 1).as_bytes());
observer.end_body();
let capture = captured(&observer);
assert!(capture.facts.input.is_none());
@@ -233,36 +234,36 @@ async fn completion_time_requires_sse_generated_content_in_either_ingestion_mode
),
] {
let mut observer = observer(mode).await;
- response(&mut observer, "text/event-stream; charset=utf-8");
- observer.bytes(b": keepalive\n\n");
- observer.bytes(
+ record_response(&mut observer, "text/event-stream; charset=utf-8");
+ observer.push_bytes(b": keepalive\n\n");
+ observer.push_bytes(
event(
"response.created",
json!({"response":{"status":"in_progress"}}),
)
.as_bytes(),
);
- observer.bytes(event(kind, json!({field:""})).as_bytes());
+ observer.push_bytes(event(kind, json!({field:""})).as_bytes());
assert!(observer.first_byte_ms.is_some());
assert!(observer.completion_start_ms.is_none());
let delta = event(kind, json!({field:"hello"}));
let split = delta.len() - 1;
- observer.bytes(&delta.as_bytes()[..split]);
+ observer.push_bytes(&delta.as_bytes()[..split]);
assert!(observer.completion_start_ms.is_none());
- observer.bytes(&delta.as_bytes()[split..]);
+ observer.push_bytes(&delta.as_bytes()[split..]);
let first = observer.completion_start_ms.unwrap();
- observer.bytes(event(kind, json!({field:"later"})).as_bytes());
+ observer.push_bytes(event(kind, json!({field:"later"})).as_bytes());
assert_eq!(observer.completion_start_ms, Some(first));
}
// The upstream content type controls timing even if the request asks to stream.
let context = resolved_request_context_with_mode("provider-secret", mode).await;
- let mut observer = ExecutionCapture::openai_responses(
+ let mut observer = ExecutionCapture::for_openai_responses(
&context,
&HeaderMap::new(),
br#"{"stream":true,"input":"hello"}"#,
);
- response(&mut observer, "application/json; charset=utf-8");
- observer.bytes(br#"{"output":[],"status":"completed"}"#);
+ record_response(&mut observer, "application/json; charset=utf-8");
+ observer.push_bytes(br#"{"output":[],"status":"completed"}"#);
observer.end_body();
assert!(observer.first_byte_ms.is_some());
assert!(observer.completion_start_ms.is_none());
@@ -274,7 +275,7 @@ async fn provider_error_details_are_bounded_and_full_mode_only() {
for mode in ["full", "usage"] {
for streaming in [false, true] {
let mut observer = observer(mode).await;
- response(
+ record_response(
&mut observer,
if streaming {
"text/event-stream"
@@ -288,7 +289,7 @@ async fn provider_error_details_are_bounded_and_full_mode_only() {
} else {
json!({"error":error}).to_string()
};
- observer.bytes(body.as_bytes());
+ observer.push_bytes(body.as_bytes());
observer.end_body();
let facts = &captured(&observer).facts;
if mode == "full" {
@@ -305,10 +306,10 @@ async fn provider_error_details_are_bounded_and_full_mode_only() {
#[tokio::test]
async fn oversized_and_malformed_events_do_not_prevent_later_facts() {
let mut observer = observer("full").await;
- response(&mut observer, "text/event-stream");
- observer.bytes(b"data: malformed\n\n");
- observer.bytes(format!("data: {}\n\n", "x".repeat(MAX_CAPTURE_BYTES + 1)).as_bytes());
- observer.bytes(terminal("completed", 0).as_bytes());
+ record_response(&mut observer, "text/event-stream");
+ observer.push_bytes(b"data: malformed\n\n");
+ observer.push_bytes(format!("data: {}\n\n", "x".repeat(MAX_CAPTURE_BYTES + 1)).as_bytes());
+ observer.push_bytes(terminal("completed", 0).as_bytes());
observer.end_body();
let capture = captured(&observer);
assert!(!capture.facts.capture_complete);
@@ -323,9 +324,9 @@ async fn oversized_and_malformed_events_do_not_prevent_later_facts() {
#[tokio::test]
async fn capture_limits_and_encoded_bodies_are_explicit() {
let mut observer = observer("full").await;
- response(&mut observer, "text/event-stream");
+ record_response(&mut observer, "text/event-stream");
for index in 0..=MAX_ITEMS {
- observer.bytes(completed_item(index as u64, "x").as_bytes());
+ observer.push_bytes(completed_item(index as u64, "x").as_bytes());
}
assert_eq!(captured(&observer).items.len(), MAX_ITEMS);
assert!(!captured(&observer).facts.capture_complete);
@@ -336,8 +337,8 @@ async fn capture_limits_and_encoded_bodies_are_explicit() {
HeaderValue::from_static("application/json"),
);
headers.insert(header::CONTENT_ENCODING, HeaderValue::from_static("gzip"));
- encoded.response(200, &headers);
- encoded.bytes(b"opaque compressed bytes");
+ encoded.record_response(200, &headers);
+ encoded.push_bytes(b"opaque compressed bytes");
encoded.end_body();
assert!(matches!(captured(&encoded).body, ResponseBody::Unavailable));
assert!(!captured(&encoded).facts.output_complete);
@@ -380,9 +381,9 @@ impl<'a> tracing_subscriber::fmt::MakeWriter<'a> for LogWriter {
async fn debug_record_is_emitted_once_and_only_at_debug_level() {
for level in [tracing::Level::DEBUG, tracing::Level::INFO] {
let mut observer = observer("full").await;
- response(&mut observer, "text/event-stream");
- observer.bytes(completed_item(0, "output-canary").as_bytes());
- observer.bytes(terminal("completed", 1).as_bytes());
+ record_response(&mut observer, "text/event-stream");
+ observer.push_bytes(completed_item(0, "output-canary").as_bytes());
+ observer.push_bytes(terminal("completed", 1).as_bytes());
observer.end_body();
observer.metadata["key_metadata"] = json!({"secret": "metadata-canary"});
let ProtocolCapture::OpenAiResponses(capture) = observer.protocol.as_mut().unwrap();
@@ -724,8 +725,8 @@ async fn capture_regression_large_request_does_not_invalidate_output() {
let request = json!({"input": "x".repeat(MAX_CAPTURE_BYTES)}).to_string();
for streaming in [false, true] {
let mut observer =
- ExecutionCapture::openai_responses(&context, &HeaderMap::new(), request.as_bytes());
- response(
+ ExecutionCapture::for_openai_responses(&context, &HeaderMap::new(), request.as_bytes());
+ record_response(
&mut observer,
if streaming {
"text/event-stream"
@@ -738,7 +739,7 @@ async fn capture_regression_large_request_does_not_invalidate_output() {
} else {
json!({"status":"completed","output":[]}).to_string()
};
- observer.bytes(body.as_bytes());
+ observer.push_bytes(body.as_bytes());
observer.end_body();
let facts = &captured(&observer).facts;
assert!(!facts.input_complete);
@@ -760,12 +761,12 @@ async fn capture_regression_preserves_native_request_and_usage() {
] {
let request = json!({"model":"requested","input":input,"instructions":"be brief","future_request_field":{"enabled":true}});
for streaming in [false, true] {
- let mut execution = ExecutionCapture::openai_responses(
+ let mut execution = ExecutionCapture::for_openai_responses(
&context,
&HeaderMap::new(),
request.to_string().as_bytes(),
);
- response(
+ record_response(
&mut execution,
if streaming {
"text/event-stream"
@@ -779,7 +780,7 @@ async fn capture_regression_preserves_native_request_and_usage() {
} else {
native.to_string()
};
- execution.bytes(body.as_bytes());
+ execution.push_bytes(body.as_bytes());
execution.end_body();
let facts = &captured(&execution).facts;
let mut expected_input = request.clone();
@@ -803,7 +804,7 @@ async fn capture_regression_preserves_native_request_and_usage() {
async fn downstream_cancellation_does_not_erase_completed_capture() {
for streaming in [false, true] {
let mut execution = observer("full").await;
- response(
+ record_response(
&mut execution,
if streaming {
"text/event-stream"
@@ -816,7 +817,7 @@ async fn downstream_cancellation_does_not_erase_completed_capture() {
} else {
json!({"status":"completed","output":[]}).to_string()
};
- execution.bytes(body.as_bytes());
+ execution.push_bytes(body.as_bytes());
execution.end_body();
let writer = LogWriter::default();
let subscriber = tracing_subscriber::fmt()
diff --git a/ai-gateway/src/providers/openai.rs b/ai-gateway/src/providers/openai.rs
index 714997db0a..e268cfca82 100644
--- a/ai-gateway/src/providers/openai.rs
+++ b/ai-gateway/src/providers/openai.rs
@@ -176,7 +176,7 @@ impl OpenAiProvider {
.map_err(|_| ProviderError::Configuration)?;
authorization.set_sensitive(true);
let mut capture = if route.captures_generation() {
- let mut capture = ExecutionCapture::openai_responses(&context, headers, &body);
+ let mut capture = ExecutionCapture::for_openai_responses(&context, headers, &body);
if let Some(telemetry) = &self.telemetry {
capture.deliver_to(telemetry.clone(), &context, headers);
}
@@ -223,7 +223,7 @@ impl OpenAiProvider {
return Err(error);
}
};
- capture.response(response.status().as_u16(), response.headers());
+ capture.record_response(response.status().as_u16(), response.headers());
let mut downstream = Response::new(Body::empty());
*downstream.status_mut() = response.status();
*downstream.headers_mut() = transport::response_headers(response.headers());
diff --git a/ai-gateway/src/telemetry/context.rs b/ai-gateway/src/telemetry/context.rs
index 37f2ec7d20..ab5750b94a 100644
--- a/ai-gateway/src/telemetry/context.rs
+++ b/ai-gateway/src/telemetry/context.rs
@@ -105,13 +105,13 @@ impl GenerationContext {
result.parent_span_id = Some(parent.span_id().to_string());
result.trace_state = parent.trace_state().header();
}
- result.baggage(headers);
+ result.apply_baggage(headers);
for (header, _, attribute) in SCALARS {
if let Some(value) = single_header(headers, header).and_then(|v| decode(v, false)) {
result.attributes.insert(attribute.into(), value.into());
}
}
- result.tags(
+ result.apply_tags(
list_entries(headers, "langfuse-tags")
.filter_map(|tag| decode(tag.trim(), false))
.collect(),
@@ -124,11 +124,11 @@ impl GenerationContext {
result.metadata.insert(key, value.into());
}
}
- result.agent(headers);
+ result.apply_agent(headers);
result
}
- fn baggage(&mut self, headers: &HeaderMap) {
+ fn apply_baggage(&mut self, headers: &HeaderMap) {
// Do not use the generic baggage propagator: malformed input must never
// be logged, and Python's exporter encodes spaces with quote_plus.
for entry in list_entries(headers, "baggage") {
@@ -146,7 +146,7 @@ impl GenerationContext {
self.attributes.insert((*attribute).into(), value.into());
} else if key == "langfuse_tags" {
if let Some(tags) = parse_tags(&value) {
- self.tags(tags);
+ self.apply_tags(tags);
}
} else if let Some(key) = key.strip_prefix("langfuse_metadata_")
&& valid(key)
@@ -156,7 +156,7 @@ impl GenerationContext {
}
}
- fn tags(&mut self, tags: Vec<String>) {
+ fn apply_tags(&mut self, tags: Vec<String>) {
let mut seen = HashSet::new();
let tags: Vec<Value> = tags
.into_iter()
@@ -170,7 +170,7 @@ impl GenerationContext {
}
}
- fn agent(&mut self, headers: &HeaderMap) {
+ fn apply_agent(&mut self, headers: &HeaderMap) {
let Some(agent) = AgentContext::from_headers(headers) else {
return;
};
@@ -215,13 +215,13 @@ impl AgentContext {
if bytes > MAX_AGENT_HEADER_BYTES {
return None;
}
- Self::claude_code(headers)
- .or_else(|| Self::codex(headers))
- .or_else(|| Self::opencode(headers))
- .or_else(|| Self::pi(headers))
+ Self::parse_claude_code(headers)
+ .or_else(|| Self::parse_codex(headers))
+ .or_else(|| Self::parse_opencode(headers))
+ .or_else(|| Self::parse_pi(headers))
}
- fn claude_code(headers: &HeaderMap) -> Option<Self> {
+ fn parse_claude_code(headers: &HeaderMap) -> Option<Self> {
let session_id = agent_header(headers, "x-claude-code-session-id");
let agent_id = agent_header(headers, "x-claude-code-agent-id");
let parent_agent_id = agent_header(headers, "x-claude-code-parent-agent-id");
@@ -240,7 +240,7 @@ impl AgentContext {
})
}
- fn codex(headers: &HeaderMap) -> Option<Self> {
+ fn parse_codex(headers: &HeaderMap) -> Option<Self> {
let value = single_header(headers, "x-codex-turn-metadata")?;
if value.len() > MAX_AGENT_METADATA_BYTES {
return None;
@@ -265,7 +265,7 @@ impl AgentContext {
})
}
- fn opencode(headers: &HeaderMap) -> Option<Self> {
+ fn parse_opencode(headers: &HeaderMap) -> Option<Self> {
let project_id = agent_header(headers, "x-opencode-project");
let direct_session_id = agent_header(headers, "x-opencode-session");
let turn_id = agent_header(headers, "x-opencode-request");
@@ -297,7 +297,7 @@ impl AgentContext {
})
}
- fn pi(headers: &HeaderMap) -> Option<Self> {
+ fn parse_pi(headers: &HeaderMap) -> Option<Self> {
let identified = user_agent(headers)
.is_some_and(|value| value.starts_with("pi/") || value.starts_with("pi ("));
if !identified {
diff --git a/ai-gateway/src/transport/mod.rs b/ai-gateway/src/transport/mod.rs
index 821a7e2a2b..f99c700dcc 100644
--- a/ai-gateway/src/transport/mod.rs
+++ b/ai-gateway/src/transport/mod.rs
@@ -132,7 +132,7 @@ where
tokio::pin!(upstream);
while let Some(chunk) = upstream.next().await {
let chunk = chunk?;
- pump_resources.observe(|capture| capture.bytes(&chunk));
+ pump_resources.observe(|capture| capture.push_bytes(&chunk));
// One queued chunk plus one pending send; no per-chunk tasks.
for bytes in chunk.chunks(64 * 1024) {
if sender.send(Bytes::copy_from_slice(bytes)).await.is_err() {