Skip to content

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

Rust

codex: annotate rewritten read offsets

Raine Virta9f59ea2b081e
diff --git a/src/providers/codex/translate/live_stream.rs b/src/providers/codex/translate/live_stream.rs
index 49b8d0c..d3363a9 100644
--- a/src/providers/codex/translate/live_stream.rs
+++ b/src/providers/codex/translate/live_stream.rs
@@ -3,6 +3,7 @@ use std::collections::HashMap;
use crate::anthropic::sse::encode_sse_event;
use crate::traffic::TrafficCapture;
+use super::read_rewrite::sanitize_read_args;
use super::reducer::{
CodexUsage, STOP_END_TURN, STOP_MAX_TOKENS, STOP_TOOL_USE, map_codex_usage_to_anthropic,
};
@@ -16,6 +17,7 @@ enum LiveBlock {
},
Tool {
index: usize,
+ call_id: String,
name: String,
args_accum: String,
had_delta: bool,
@@ -271,6 +273,7 @@ impl LiveStreamTranslator {
output_index,
LiveBlock::Tool {
index,
+ call_id: call_id.clone(),
name: name.clone(),
args_accum: String::new(),
had_delta: false,
@@ -419,6 +422,7 @@ impl LiveStreamTranslator {
let mut repaired_read: Option<(usize, String)> = None;
let Some(LiveBlock::Tool {
index,
+ call_id,
name,
args_accum,
had_delta,
@@ -437,7 +441,9 @@ impl LiveStreamTranslator {
"Buffered {name} tool arguments exceeded safe limits"
));
}
- if let Some(repaired) = repair_whitespace_stalled_read_args(name, args_accum) {
+ if let Some(repaired) =
+ repair_whitespace_stalled_read_args(name, args_accum, Some(call_id.as_str()))
+ {
*args_accum = repaired.clone();
*emitted_args = true;
repaired_read = Some((*index, repaired));
@@ -547,6 +553,7 @@ impl LiveStreamTranslator {
LiveBlock::Tool {
index,
name,
+ call_id,
args_accum,
had_delta,
buffer_until_done,
@@ -563,7 +570,7 @@ impl LiveStreamTranslator {
*args_accum = final_args.to_string();
}
if !args_accum.is_empty() {
- *args_accum = sanitize_tool_args(name, args_accum);
+ *args_accum = sanitize_read_args(name, args_accum, Some(call_id.as_str()));
if *buffer_until_done || !*emitted_args {
*emitted_args = true;
self.emit(
@@ -725,31 +732,11 @@ fn response_is_incomplete(payload: &serde_json::Value) -> bool {
.is_some()
}
-fn sanitize_tool_args(name: &str, args: &str) -> String {
- if name != "Read" || args.is_empty() {
- return args.to_string();
- }
- let parsed: serde_json::Value = match serde_json::from_str(args) {
- Ok(v) => v,
- Err(_) => return args.to_string(),
- };
- let obj = match parsed.as_object() {
- Some(o) => o,
- None => return args.to_string(),
- };
- let has_empty_pages = obj
- .get("pages")
- .and_then(|v| v.as_str())
- .is_some_and(|s| s.is_empty());
- if !has_empty_pages {
- return args.to_string();
- }
- let mut sanitized = obj.clone();
- sanitized.remove("pages");
- serde_json::to_string(&sanitized).unwrap_or_else(|_| args.to_string())
-}
-
-fn repair_whitespace_stalled_read_args(name: &str, args: &str) -> Option<String> {
+fn repair_whitespace_stalled_read_args(
+ name: &str,
+ args: &str,
+ call_id: Option<&str>,
+) -> Option<String> {
if name != "Read" {
return None;
}
@@ -758,20 +745,21 @@ fn repair_whitespace_stalled_read_args(name: &str, args: &str) -> Option<String>
if trailing_whitespace < BUFFERED_READ_REPAIR_TRAILING_WHITESPACE_BYTES {
return None;
}
- parse_read_args_candidate(trimmed).or_else(|| {
+ parse_read_args_candidate(trimmed, call_id).or_else(|| {
let with_brace = format!("{trimmed}}}");
- parse_read_args_candidate(&with_brace)
+ parse_read_args_candidate(&with_brace, call_id)
})
}
-fn parse_read_args_candidate(args: &str) -> Option<String> {
+fn parse_read_args_candidate(args: &str, call_id: Option<&str>) -> Option<String> {
let parsed: serde_json::Value = serde_json::from_str(args).ok()?;
if !is_valid_read_args(&parsed) {
return None;
}
- Some(sanitize_tool_args(
+ Some(sanitize_read_args(
"Read",
&serde_json::to_string(&parsed).ok()?,
+ call_id,
))
}
diff --git a/src/providers/codex/translate/mod.rs b/src/providers/codex/translate/mod.rs
index b102d79..74fd510 100644
--- a/src/providers/codex/translate/mod.rs
+++ b/src/providers/codex/translate/mod.rs
@@ -1,6 +1,7 @@
pub mod accumulate;
pub mod live_stream;
pub mod model_allowlist;
+pub mod read_rewrite;
pub mod reducer;
pub mod request;
pub mod stream;
diff --git a/src/providers/codex/translate/read_rewrite.rs b/src/providers/codex/translate/read_rewrite.rs
new file mode 100644
index 0000000..dd5e397
--- /dev/null
+++ b/src/providers/codex/translate/read_rewrite.rs
@@ -0,0 +1,139 @@
+use std::collections::{HashMap, VecDeque};
+use std::sync::Mutex;
+
+use once_cell::sync::Lazy;
+use serde_json::Value;
+
+const MAX_REWRITE_NOTES: usize = 4_096;
+const READ_OFFSET_REWRITE_THRESHOLD: i64 = 1_000_000;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ReadOffsetRewrite {
+ pub offset: i64,
+ pub file_path: Option<String>,
+}
+
+#[derive(Debug, Default)]
+struct RewriteStore {
+ order: VecDeque<String>,
+ entries: HashMap<String, ReadOffsetRewrite>,
+}
+
+static READ_OFFSET_REWRITES: Lazy<Mutex<RewriteStore>> =
+ Lazy::new(|| Mutex::new(RewriteStore::default()));
+
+pub fn sanitize_read_args(name: &str, args: &str, call_id: Option<&str>) -> String {
+ if name != "Read" || args.is_empty() {
+ return args.to_string();
+ }
+
+ let parsed: Value = match serde_json::from_str(args) {
+ Ok(v) => v,
+ Err(_) => return args.to_string(),
+ };
+ let obj = match parsed.as_object() {
+ Some(o) => o,
+ None => return args.to_string(),
+ };
+
+ let mut sanitized = obj.clone();
+ let mut changed = false;
+
+ let has_empty_pages = obj
+ .get("pages")
+ .and_then(|v| v.as_str())
+ .is_some_and(|s| s.is_empty());
+ if has_empty_pages {
+ sanitized.remove("pages");
+ changed = true;
+ }
+
+ if let Some(offset) = obj.get("offset").and_then(|v| v.as_i64())
+ && offset >= READ_OFFSET_REWRITE_THRESHOLD
+ {
+ sanitized.remove("offset");
+ changed = true;
+ if let Some(call_id) = call_id.filter(|id| !id.is_empty()) {
+ record_read_offset_rewrite(
+ call_id,
+ ReadOffsetRewrite {
+ offset,
+ file_path: obj
+ .get("file_path")
+ .and_then(|v| v.as_str())
+ .map(str::to_string),
+ },
+ );
+ }
+ }
+
+ if changed {
+ serde_json::to_string(&sanitized).unwrap_or_else(|_| args.to_string())
+ } else {
+ args.to_string()
+ }
+}
+
+pub fn read_offset_rewrite(call_id: &str) -> Option<ReadOffsetRewrite> {
+ READ_OFFSET_REWRITES
+ .lock()
+ .ok()
+ .and_then(|store| store.entries.get(call_id).cloned())
+}
+
+fn record_read_offset_rewrite(call_id: &str, note: ReadOffsetRewrite) {
+ let Ok(mut store) = READ_OFFSET_REWRITES.lock() else {
+ return;
+ };
+
+ if !store.entries.contains_key(call_id) {
+ store.order.push_back(call_id.to_string());
+ }
+ store.entries.insert(call_id.to_string(), note);
+
+ while store.entries.len() > MAX_REWRITE_NOTES {
+ let Some(oldest) = store.order.pop_front() else {
+ break;
+ };
+ store.entries.remove(&oldest);
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn sanitize_read_args_removes_empty_pages() {
+ let args = r#"{"file_path":"/tmp/a","pages":""}"#;
+ let sanitized = sanitize_read_args("Read", args, None);
+ let parsed: Value = serde_json::from_str(&sanitized).unwrap();
+ assert!(parsed.get("pages").is_none());
+ assert_eq!(
+ parsed.get("file_path").and_then(|v| v.as_str()),
+ Some("/tmp/a")
+ );
+ }
+
+ #[test]
+ fn sanitize_read_args_drops_and_records_absurd_offset() {
+ let args = r#"{"file_path":"/tmp/a","offset":1300000,"limit":20}"#;
+ let sanitized = sanitize_read_args("Read", args, Some("call_rewrite_test"));
+ let parsed: Value = serde_json::from_str(&sanitized).unwrap();
+ assert!(parsed.get("offset").is_none());
+ assert_eq!(parsed.get("limit").and_then(|v| v.as_i64()), Some(20));
+
+ let note = read_offset_rewrite("call_rewrite_test").unwrap();
+ assert_eq!(note.offset, 1_300_000);
+ assert_eq!(note.file_path.as_deref(), Some("/tmp/a"));
+ }
+
+ #[test]
+ fn sanitize_read_args_keeps_normal_offset() {
+ let args = r#"{"file_path":"/tmp/a","offset":1300,"limit":20}"#;
+ let sanitized = sanitize_read_args("Read", args, Some("call_keep_test"));
+ let parsed: Value = serde_json::from_str(&sanitized).unwrap();
+ assert_eq!(parsed.get("offset").and_then(|v| v.as_i64()), Some(1_300));
+ assert!(read_offset_rewrite("call_keep_test").is_none());
+ }
+}
diff --git a/src/providers/codex/translate/reducer.rs b/src/providers/codex/translate/reducer.rs
index 11da381..295c4ed 100644
--- a/src/providers/codex/translate/reducer.rs
+++ b/src/providers/codex/translate/reducer.rs
@@ -1,5 +1,6 @@
use crate::anthropic::sse::parse_sse_events;
+use super::read_rewrite::sanitize_read_args;
use super::request::ResponsesInputItem;
#[derive(Debug, Clone)]
@@ -465,6 +466,7 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream
emitted_args,
name,
index,
+ call_id,
..
} => {
args_accum.push_str(delta);
@@ -479,9 +481,11 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream
}
if *buffer_until_done {
- if let Some(repaired) =
- repair_whitespace_stalled_read_args(name, args_accum)
- {
+ if let Some(repaired) = repair_whitespace_stalled_read_args(
+ name,
+ args_accum,
+ Some(call_id.as_str()),
+ ) {
*args_accum = repaired.clone();
*emitted_args = true;
repaired_read = Some((*index, repaired));
@@ -581,6 +585,7 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream
if let BlockState::Tool {
args_accum,
name,
+ call_id,
buffer_until_done,
emitted_args,
had_delta,
@@ -603,7 +608,8 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream
}
if !args_accum.is_empty() {
- let sanitized = sanitize_tool_args(name, args_accum);
+ let sanitized =
+ sanitize_read_args(name, args_accum, Some(call_id.as_str()));
*args_accum = sanitized;
if *buffer_until_done || !*emitted_args {
*emitted_args = true;
@@ -766,32 +772,11 @@ fn should_buffer_tool_args(name: &str) -> bool {
name == "Read"
}
-fn sanitize_tool_args(name: &str, args: &str) -> String {
- if name != "Read" || args.is_empty() {
- return args.to_string();
- }
- let parsed: serde_json::Value = match serde_json::from_str(args) {
- Ok(v) => v,
- Err(_) => return args.to_string(),
- };
- let obj = match parsed.as_object() {
- Some(o) => o,
- None => return args.to_string(),
- };
- // Remove empty "pages" field
- let has_empty_pages = obj
- .get("pages")
- .and_then(|v| v.as_str())
- .is_some_and(|s| s.is_empty());
- if !has_empty_pages {
- return args.to_string();
- }
- let mut sanitized = obj.clone();
- sanitized.remove("pages");
- serde_json::to_string(&sanitized).unwrap_or_else(|_| args.to_string())
-}
-
-fn repair_whitespace_stalled_read_args(name: &str, args: &str) -> Option<String> {
+fn repair_whitespace_stalled_read_args(
+ name: &str,
+ args: &str,
+ call_id: Option<&str>,
+) -> Option<String> {
if name != "Read" {
return None;
}
@@ -800,20 +785,21 @@ fn repair_whitespace_stalled_read_args(name: &str, args: &str) -> Option<String>
if trailing_whitespace < BUFFERED_READ_REPAIR_TRAILING_WHITESPACE_BYTES {
return None;
}
- parse_read_args_candidate(trimmed).or_else(|| {
+ parse_read_args_candidate(trimmed, call_id).or_else(|| {
let with_brace = format!("{trimmed}}}");
- parse_read_args_candidate(&with_brace)
+ parse_read_args_candidate(&with_brace, call_id)
})
}
-fn parse_read_args_candidate(args: &str) -> Option<String> {
+fn parse_read_args_candidate(args: &str, call_id: Option<&str>) -> Option<String> {
let parsed: serde_json::Value = serde_json::from_str(args).ok()?;
if !is_valid_read_args(&parsed) {
return None;
}
- Some(sanitize_tool_args(
+ Some(sanitize_read_args(
"Read",
&serde_json::to_string(&parsed).ok()?,
+ call_id,
))
}
@@ -1371,7 +1357,7 @@ mod tests {
#[test]
fn sanitize_tool_args_removes_empty_pages() {
let args = r#"{"file_path":"/tmp/a","pages":""}"#;
- let sanitized = sanitize_tool_args("Read", args);
+ let sanitized = sanitize_read_args("Read", args, None);
let parsed: serde_json::Value = serde_json::from_str(&sanitized).unwrap();
assert!(parsed.get("pages").is_none());
assert_eq!(
diff --git a/src/providers/codex/translate/request.rs b/src/providers/codex/translate/request.rs
index 8f189d5..3ec7efd 100644
--- a/src/providers/codex/translate/request.rs
+++ b/src/providers/codex/translate/request.rs
@@ -9,6 +9,8 @@ use crate::providers::translate_shared::{
ContentBlock, flatten_system_text, image_source_to_url, normalize_content, read_effort,
};
+use super::read_rewrite::{ReadOffsetRewrite, read_offset_rewrite};
+
// ---------------------------------------------------------------------------
// Types
// ---------------------------------------------------------------------------
@@ -566,6 +568,8 @@ fn build_input(req: &MessagesRequest) -> Vec<ResponsesInputItem> {
} else {
body
};
+ let output =
+ maybe_append_rewritten_read_offset_note(output, tool_use_id);
let output = maybe_append_read_offset_guidance(
output,
read_tool_uses_with_offset.contains(tool_use_id),
@@ -649,6 +653,32 @@ fn is_read_tool_use_with_offset(name: &str, input: &Value) -> bool {
name == "Read" && input.get("offset").is_some()
}
+fn maybe_append_rewritten_read_offset_note(output: String, tool_use_id: &str) -> String {
+ if output.contains("Proxy Read offset note:") {
+ return output;
+ }
+ let Some(rewrite) = read_offset_rewrite(tool_use_id) else {
+ return output;
+ };
+ format!("{output}\n\n{}", read_offset_rewrite_note(&rewrite))
+}
+
+fn read_offset_rewrite_note(rewrite: &ReadOffsetRewrite) -> String {
+ let file = rewrite
+ .file_path
+ .as_deref()
+ .map(|path| format!(" for {path}"))
+ .unwrap_or_default();
+ format!(
+ "Proxy Read offset note:\n\
+ - Requested Read offset {}{} exceeds the proxy rewrite threshold of 1000000.\n\
+ - This Read starts at the beginning of the file.\n\
+ - For continuation reads, use offset after a prior Read of the same file returned content and more lines are needed.\n\
+ - Compute offset as prior offset plus the number of lines returned by that prior Read.",
+ rewrite.offset, file
+ )
+}
+
fn maybe_append_read_offset_guidance(
output: String,
read_call_had_offset: bool,
@@ -1101,6 +1131,42 @@ mod tests {
}
}
+ #[test]
+ fn translate_rewritten_read_result_adds_proxy_note() {
+ crate::providers::codex::translate::read_rewrite::sanitize_read_args(
+ "Read",
+ r#"{"file_path":"/tmp/a","offset":1300000,"limit":20}"#,
+ Some("tu_rewritten_read"),
+ );
+ let req: MessagesRequest = serde_json::from_value(json!({
+ "model": "gpt-5.5",
+ "messages": [
+ {"role":"assistant", "content": [{
+ "type": "tool_use",
+ "id": "tu_rewritten_read",
+ "name": "Read",
+ "input": {"file_path": "/tmp/a", "limit": 20}
+ }]},
+ {"role":"user", "content": [{
+ "type": "tool_result",
+ "tool_use_id": "tu_rewritten_read",
+ "content": [{"type":"text", "text":"1\tcontent"}]
+ }]}
+ ]
+ }))
+ .unwrap();
+ let out = translate_request(&req, opts()).unwrap();
+ assert_eq!(out.input.len(), 2);
+ if let ResponsesInputItem::FunctionCallOutput { output, .. } = &out.input[1] {
+ assert!(output.contains("1\tcontent"));
+ assert!(output.contains("Proxy Read offset note:"));
+ assert!(output.contains("1300000"));
+ assert!(output.contains("/tmp/a"));
+ } else {
+ panic!("expected FunctionCallOutput");
+ }
+ }
+
#[test]
fn translate_read_success_with_offset_words_keeps_original_output() {
let req: MessagesRequest = serde_json::from_value(json!({