An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.
Rust
fix: page large read_file results instead of returning whole files
reacechalmers4361e9899875
diff --git a/rust/crates/runtime/src/file_ops.rs b/rust/crates/runtime/src/file_ops.rsindex 7a62447a..f22c9b87 100644--- a/rust/crates/runtime/src/file_ops.rs+++ b/rust/crates/runtime/src/file_ops.rs@@ -11,8 +11,28 @@ use serde::{Deserialize, Serialize};use walkdir::{DirEntry, WalkDir};/// Maximum file size that can be read (10 MB).+///+/// This is a *process* guard — it stops us slurping a huge or binary blob into memory. It is+/// not a context guard: 10 MB is on the order of 2.5 M tokens, so it never fires on the files+/// that actually blow a model's context window. `DEFAULT_READ_LINES` / `MAX_READ_CHARS` below+/// are the context guard.const MAX_READ_SIZE: u64 = 10 * 1024 * 1024;+/// Lines returned by `read_file` when the caller does not pass an explicit `limit`.+///+/// This is a *paging* size, not a refusal. An unbounded read is the easiest way for a model to+/// destroy its own context: one 100 KB source file is ~25 k tokens, which does not fit alongside+/// a system prompt in a 32 k window. When that happens the backend rejects the whole request and+/// the session dies — so reading everything at once is what makes it stop. Returning a page plus+/// `nextOffset` means the read always succeeds and the model can keep going.+const DEFAULT_READ_LINES: usize = 2000;++/// Hard ceiling on the characters `read_file` returns, applied even when `limit` is explicit.+///+/// `DEFAULT_READ_LINES` alone does not bound the payload: minified bundles, JSON blobs and+/// generated sources routinely put megabytes on a handful of lines. ~64 KB is ~16 k tokens.+const MAX_READ_CHARS: usize = 64 * 1024;+/// Maximum file size that can be written (10 MB).const MAX_WRITE_SIZE: usize = 10 * 1024 * 1024;@@ -80,6 +100,17 @@ pub struct TextFilePayload {pub start_line: usize,#[serde(rename = "totalLines")]pub total_lines: usize,+ /// True when the file has more lines past this page. Signals the caller that it has NOT seen+ /// the whole file, so it does not silently reason over a partial view.+ #[serde(default)]+ pub truncated: bool,+ /// Line index to pass back as `offset` to continue reading. Absent once the file is exhausted.+ #[serde(+ rename = "nextOffset",+ default,+ skip_serializing_if = "Option::is_none"+ )]+ pub next_offset: Option<usize>,}/// Output envelope for the `read_file` tool.@@ -228,10 +259,27 @@ pub fn read_file(let content = fs::read_to_string(&absolute_path)?;let lines: Vec<&str> = content.lines().collect();let start_index = offset.unwrap_or(0).min(lines.len());- let end_index = limit.map_or(lines.len(), |limit| {- start_index.saturating_add(limit).min(lines.len())- });+ // An absent `limit` pages rather than reading to EOF: see DEFAULT_READ_LINES.+ let requested_end = start_index+ .saturating_add(limit.unwrap_or(DEFAULT_READ_LINES))+ .min(lines.len());++ // Apply the character ceiling on top of the line window, so a file with very long lines+ // cannot blow the budget the line cap was meant to enforce. Always yield at least one line,+ // otherwise an oversized single line would return nothing and the caller could not advance.+ let mut end_index = start_index;+ let mut chars = 0usize;+ for line in &lines[start_index..requested_end] {+ let next = chars + line.chars().count() + 1;+ if next > MAX_READ_CHARS && end_index > start_index {+ break;+ }+ chars = next;+ end_index += 1;+ }+let selected = lines[start_index..end_index].join("\n");+ let truncated = end_index < lines.len();Ok(ReadFileOutput {kind: String::from("text"),@@ -241,6 +289,8 @@ pub fn read_file(num_lines: end_index.saturating_sub(start_index),start_line: start_index.saturating_add(1),total_lines: lines.len(),+ truncated,+ next_offset: truncated.then_some(end_index),},})}@@ -810,10 +860,14 @@ mod tests {use std::path::PathBuf;use std::time::{SystemTime, UNIX_EPOCH};+ use super::{+ component_contains_glob, derive_glob_walk_root, edit_file, expand_braces, glob_search,use super::{component_contains_glob, derive_glob_walk_root, edit_file, expand_braces, glob_search,grep_search, is_symlink_escape, normalize_for_comparison, read_file,read_file_in_workspace, write_file, write_file_in_workspace, GrepSearchInput,+ DEFAULT_READ_LINES, MAX_READ_CHARS,+ };MAX_WRITE_SIZE,};@@ -837,6 +891,73 @@ mod tests {assert_eq!(read_output.file.content, "two");}+ #[test]+ fn unbounded_read_of_a_large_file_pages_instead_of_returning_everything() {+ // Regression: an unbounded read used to return the whole file, which on a small-context+ // backend overflows the window and the request is rejected outright — the session dies.+ let path = temp_path("paged-read.txt");+ let total = DEFAULT_READ_LINES + 500;+ let body = (0..total)+ .map(|i| format!("line {i}"))+ .collect::<Vec<_>>()+ .join("\n");+ write_file(path.to_string_lossy().as_ref(), &body).expect("write should succeed");++ let first = read_file(path.to_string_lossy().as_ref(), None, None).expect("first page");+ assert_eq!(first.file.num_lines, DEFAULT_READ_LINES);+ assert_eq!(first.file.total_lines, total);+ assert!(first.file.truncated, "caller must be told it is partial");+ assert_eq!(first.file.next_offset, Some(DEFAULT_READ_LINES));+ assert!(first.file.content.starts_with("line 0\n"));++ // The advertised next_offset must actually resume where the last page stopped.+ let second = read_file(+ path.to_string_lossy().as_ref(),+ first.file.next_offset,+ None,+ )+ .expect("second page");+ assert_eq!(second.file.num_lines, 500);+ assert!(!second.file.truncated, "the tail is the final page");+ assert_eq!(second.file.next_offset, None);+ assert!(second+ .file+ .content+ .starts_with(&format!("line {DEFAULT_READ_LINES}\n")));+ }++ #[test]+ fn char_ceiling_bounds_files_whose_lines_are_enormous() {+ // A line cap alone does not bound the payload: minified bundles put megabytes on a few+ // lines, so the byte ceiling has to apply too — and must still yield forward progress.+ let path = temp_path("long-lines.txt");+ let huge = "x".repeat(MAX_READ_CHARS);+ let body = format!("{huge}\n{huge}\n{huge}");+ write_file(path.to_string_lossy().as_ref(), &body).expect("write should succeed");++ let page = read_file(path.to_string_lossy().as_ref(), None, None).expect("first page");+ assert_eq!(page.file.num_lines, 1, "one oversized line still advances");+ assert!(page.file.truncated);+ assert_eq!(page.file.next_offset, Some(1));++ // An explicit limit must not be able to defeat the ceiling.+ let greedy = read_file(path.to_string_lossy().as_ref(), None, Some(3)).expect("greedy");+ assert_eq!(greedy.file.num_lines, 1);+ assert!(greedy.file.truncated);+ }++ #[test]+ fn small_files_are_returned_whole_and_not_marked_truncated() {+ let path = temp_path("small-read.txt");+ write_file(path.to_string_lossy().as_ref(), "one\ntwo\nthree").expect("write");++ let output = read_file(path.to_string_lossy().as_ref(), None, None).expect("read");+ assert_eq!(output.file.content, "one\ntwo\nthree");+ assert_eq!(output.file.num_lines, 3);+ assert!(!output.file.truncated);+ assert_eq!(output.file.next_offset, None);+ }+#[test]fn edits_file_contents() {let path = temp_path("edit.txt");diff --git a/rust/crates/runtime/src/trident.rs b/rust/crates/runtime/src/trident.rsindex 2346a4ea..07576822 100644--- a/rust/crates/runtime/src/trident.rs+++ b/rust/crates/runtime/src/trident.rs@@ -29,7 +29,7 @@ impl Default for TridentConfig {}/// Statistics from a Trident compaction run.-#[derive(Debug, Clone, PartialEq, Eq)]+#[derive(Debug, Clone, PartialEq, Eq, Default)]pub struct TridentStats {pub superseded_count: usize,pub collapsed_chains: usize,@@ -41,21 +41,6 @@ pub struct TridentStats {pub final_message_count: usize,}-impl Default for TridentStats {- fn default() -> Self {- Self {- superseded_count: 0,- collapsed_chains: 0,- messages_collapsed: 0,- clusters_found: 0,- messages_clustered: 0,- tokens_saved_estimate: 0,- original_message_count: 0,- final_message_count: 0,- }- }-}-impl TridentStats {pub fn format_report(&self) -> String {let compression = if self.final_message_count > 0 {@@ -192,7 +177,7 @@ fn stage1_supersede(messages: &[ConversationMessage]) -> (Vec<ConversationMessaglet mut obsolete_indices: BTreeSet<usize> = BTreeSet::new();- for (_path, ops) in &file_ops {+ for ops in file_ops.values() {if ops.len() < 2 {continue;}@@ -205,10 +190,8 @@ fn stage1_supersede(messages: &[ConversationMessage]) -> (Vec<ConversationMessagif let Some(last_write) = last_write_idx {for op in ops {- if op.op_type == FileOp::Read && op.index < last_write {- obsolete_indices.insert(op.index);- } else if (op.op_type == FileOp::Write || op.op_type == FileOp::Edit)- && op.index < last_write+ if op.index < last_write+ && matches!(op.op_type, FileOp::Read | FileOp::Write | FileOp::Edit){obsolete_indices.insert(op.index);}@@ -325,7 +308,7 @@ fn stage2_collapse(usage: None,});} else {- result.extend(buffer.drain(..));+ result.append(&mut buffer);}buffer.clear();result.push(msg.clone());@@ -476,7 +459,7 @@ fn stage3_cluster(}let total_clustered: usize = cluster_assignments.len();- let clusters_found = cluster_id as usize;+ let clusters_found = cluster_id;let mut result: Vec<ConversationMessage> = Vec::new();let mut cluster_buffers: BTreeMap<usize, Vec<usize>> = BTreeMap::new();@@ -677,7 +660,7 @@ fn truncate_text(text: &str, max_chars: usize) -> String {mod tests {use super::*;use crate::compact::CompactionConfig;- use crate::session::{ContentBlock, ConversationMessage, MessageRole, Session};+ use crate::session::{ContentBlock, ConversationMessage, Session};#[test]fn stage1_removes_obsolete_file_reads() {@@ -736,7 +719,7 @@ mod tests {fn stage2_collapses_chatty_messages() {let mut messages = vec![];for i in 0..6 {- messages.push(ConversationMessage::user_text(&format!("ok {i}")));+ messages.push(ConversationMessage::user_text(format!("ok {i}")));messages.push(ConversationMessage::assistant(vec![ContentBlock::Text {text: format!("got {i}"),}]));@@ -767,9 +750,9 @@ mod tests {},]));messages.push(ConversationMessage::tool_result(- &format!("read_{i}"),+ format!("read_{i}"),"read_file",- &format!(r#"{{"path":"src/{i}.rs","content":"data {i}"}}"#),+ format!(r#"{{"path":"src/{i}.rs","content":"data {i}"}}"#),false,));}diff --git a/rust/crates/tools/src/lib.rs b/rust/crates/tools/src/lib.rsindex 2ad7926a..dd90949e 100644--- a/rust/crates/tools/src/lib.rs+++ b/rust/crates/tools/src/lib.rs@@ -506,13 +506,17 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {},ToolSpec {name: "read_file",- description: "Read a text file from the workspace.",+ description: "Read a text file from the workspace. Large files come back one page at \+ a time: if the response has \"truncated\": true you have NOT seen the \+ whole file, and \"nextOffset\" is the line to pass as `offset` to \+ continue. Prefer grep_search to locate what you need over paging \+ through a big file, and never re-read a page you already have.",input_schema: json!({"type": "object","properties": {"path": { "type": "string" },- "offset": { "type": "integer", "minimum": 0 },- "limit": { "type": "integer", "minimum": 1 }+ "offset": { "type": "integer", "minimum": 0, "description": "First line to read (0-based). Pass the previous response's nextOffset to continue." },+ "limit": { "type": "integer", "minimum": 1, "description": "Maximum lines to return. Capped by a byte ceiling regardless." }},"required": ["path"],"additionalProperties": false