Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

feat(tools): error propagation, REPL timeout, edge-case validation

YeonGyu-Kim73187de6ea9a
diff --git a/rust/crates/tools/src/lib.rs b/rust/crates/tools/src/lib.rs
index 758a6b6b..22bd852f 100644
--- a/rust/crates/tools/src/lib.rs
+++ b/rust/crates/tools/src/lib.rs
@@ -169,7 +169,6 @@ impl GlobalToolRegistry {
builtin.chain(plugin).collect()
}
- #[must_use]
pub fn permission_specs(
&self,
allowed_tools: Option<&BTreeSet<String>>,
@@ -648,7 +647,7 @@ fn run_notebook_edit(input: NotebookEditInput) -> Result<String, String> {
}
fn run_sleep(input: SleepInput) -> Result<String, String> {
- to_pretty_json(execute_sleep(input))
+ to_pretty_json(execute_sleep(input)?)
}
fn run_brief(input: BriefInput) -> Result<String, String> {
@@ -660,7 +659,7 @@ fn run_config(input: ConfigInput) -> Result<String, String> {
}
fn run_structured_output(input: StructuredOutputInput) -> Result<String, String> {
- to_pretty_json(execute_structured_output(input))
+ to_pretty_json(execute_structured_output(input)?)
}
fn run_repl(input: ReplInput) -> Result<String, String> {
@@ -2347,7 +2346,8 @@ fn execute_notebook_edit(input: NotebookEditInput) -> Result<NotebookEditOutput,
let cell_id = match edit_mode {
NotebookEditMode::Insert => {
- let resolved_cell_type = resolved_cell_type.expect("insert cell type");
+ let resolved_cell_type = resolved_cell_type
+ .ok_or_else(|| String::from("insert mode requires a cell type"))?;
let new_id = make_cell_id(cells.len());
let new_cell = build_notebook_cell(&new_id, resolved_cell_type, &new_source);
let insert_at = target_index.map_or(cells.len(), |index| index + 1);
@@ -2359,16 +2359,21 @@ fn execute_notebook_edit(input: NotebookEditInput) -> Result<NotebookEditOutput,
.map(ToString::to_string)
}
NotebookEditMode::Delete => {
- let removed = cells.remove(target_index.expect("delete target index"));
+ let idx = target_index
+ .ok_or_else(|| String::from("delete mode requires a target cell index"))?;
+ let removed = cells.remove(idx);
removed
.get("id")
.and_then(serde_json::Value::as_str)
.map(ToString::to_string)
}
NotebookEditMode::Replace => {
- let resolved_cell_type = resolved_cell_type.expect("replace cell type");
+ let resolved_cell_type = resolved_cell_type
+ .ok_or_else(|| String::from("replace mode requires a cell type"))?;
+ let idx = target_index
+ .ok_or_else(|| String::from("replace mode requires a target cell index"))?;
let cell = cells
- .get_mut(target_index.expect("replace target index"))
+ .get_mut(idx)
.ok_or_else(|| String::from("Cell index out of range"))?;
cell["source"] = serde_json::Value::Array(source_lines(&new_source));
cell["cell_type"] = serde_json::Value::String(match resolved_cell_type {
@@ -2459,13 +2464,21 @@ fn cell_kind(cell: &serde_json::Value) -> Option<NotebookCellType> {
})
}
+const MAX_SLEEP_DURATION_MS: u64 = 300_000;
+
#[allow(clippy::needless_pass_by_value)]
-fn execute_sleep(input: SleepInput) -> SleepOutput {
+fn execute_sleep(input: SleepInput) -> Result<SleepOutput, String> {
+ if input.duration_ms > MAX_SLEEP_DURATION_MS {
+ return Err(format!(
+ "duration_ms {} exceeds maximum allowed sleep of {MAX_SLEEP_DURATION_MS}ms",
+ input.duration_ms,
+ ));
+ }
std::thread::sleep(Duration::from_millis(input.duration_ms));
- SleepOutput {
+ Ok(SleepOutput {
duration_ms: input.duration_ms,
message: format!("Slept for {}ms", input.duration_ms),
- }
+ })
}
fn execute_brief(input: BriefInput) -> Result<BriefOutput, String> {
@@ -2562,25 +2575,62 @@ fn execute_config(input: ConfigInput) -> Result<ConfigOutput, String> {
}
}
-fn execute_structured_output(input: StructuredOutputInput) -> StructuredOutputResult {
- StructuredOutputResult {
+fn execute_structured_output(
+ input: StructuredOutputInput,
+) -> Result<StructuredOutputResult, String> {
+ if input.0.is_empty() {
+ return Err(String::from("structured output payload must not be empty"));
+ }
+ Ok(StructuredOutputResult {
data: String::from("Structured output provided successfully"),
structured_output: input.0,
- }
+ })
}
fn execute_repl(input: ReplInput) -> Result<ReplOutput, String> {
if input.code.trim().is_empty() {
return Err(String::from("code must not be empty"));
}
- let _ = input.timeout_ms;
let runtime = resolve_repl_runtime(&input.language)?;
let started = Instant::now();
- let output = Command::new(runtime.program)
+ let mut process = Command::new(runtime.program);
+ process
.args(runtime.args)
.arg(&input.code)
- .output()
- .map_err(|error| error.to_string())?;
+ .stdin(std::process::Stdio::null())
+ .stdout(std::process::Stdio::piped())
+ .stderr(std::process::Stdio::piped());
+
+ let output = if let Some(timeout_ms) = input.timeout_ms {
+ let mut child = process.spawn().map_err(|error| error.to_string())?;
+ loop {
+ if child
+ .try_wait()
+ .map_err(|error| error.to_string())?
+ .is_some()
+ {
+ break child
+ .wait_with_output()
+ .map_err(|error| error.to_string())?;
+ }
+ if started.elapsed() >= Duration::from_millis(timeout_ms) {
+ child.kill().map_err(|error| error.to_string())?;
+ child
+ .wait_with_output()
+ .map_err(|error| error.to_string())?;
+ return Err(format!(
+ "REPL execution exceeded timeout of {timeout_ms} ms"
+ ));
+ }
+ std::thread::sleep(Duration::from_millis(10));
+ }
+ } else {
+ process
+ .spawn()
+ .map_err(|error| error.to_string())?
+ .wait_with_output()
+ .map_err(|error| error.to_string())?
+ };
Ok(ReplOutput {
language: input.language,
@@ -3157,8 +3207,8 @@ mod tests {
.expect_err("unknown plugin permission should fail");
assert!(unknown_permission.contains("unsupported plugin permission: admin"));
- let empty_permission = permission_mode_from_plugin("")
- .expect_err("empty plugin permission should fail");
+ let empty_permission =
+ permission_mode_from_plugin("").expect_err("empty plugin permission should fail");
assert!(empty_permission.contains("unsupported plugin permission: "));
}
@@ -4226,6 +4276,21 @@ mod tests {
assert!(elapsed >= Duration::from_millis(15));
}
+ #[test]
+ fn given_excessive_duration_when_sleep_then_rejects_with_error() {
+ let result = execute_tool("Sleep", &json!({"duration_ms": 999_999_999_u64}));
+ let error = result.expect_err("excessive sleep should fail");
+ assert!(error.contains("exceeds maximum allowed sleep"));
+ }
+
+ #[test]
+ fn given_zero_duration_when_sleep_then_succeeds() {
+ let result =
+ execute_tool("Sleep", &json!({"duration_ms": 0})).expect("0ms sleep should succeed");
+ let output: serde_json::Value = serde_json::from_str(&result).expect("json");
+ assert_eq!(output["duration_ms"], 0);
+ }
+
#[test]
fn brief_returns_sent_message_and_attachment_metadata() {
let attachment = std::env::temp_dir().join(format!(
@@ -4330,6 +4395,13 @@ mod tests {
assert_eq!(output["structured_output"]["items"][1], 2);
}
+ #[test]
+ fn given_empty_payload_when_structured_output_then_rejects_with_error() {
+ let result = execute_tool("StructuredOutput", &json!({}));
+ let error = result.expect_err("empty payload should fail");
+ assert!(error.contains("must not be empty"));
+ }
+
#[test]
fn repl_executes_python_code() {
let result = execute_tool(
@@ -4343,6 +4415,37 @@ mod tests {
assert!(output["stdout"].as_str().expect("stdout").contains('2'));
}
+ #[test]
+ fn given_empty_code_when_repl_then_rejects_with_error() {
+ let result = execute_tool("REPL", &json!({"language": "python", "code": " "}));
+
+ let error = result.expect_err("empty REPL code should fail");
+ assert!(error.contains("code must not be empty"));
+ }
+
+ #[test]
+ fn given_unsupported_language_when_repl_then_rejects_with_error() {
+ let result = execute_tool("REPL", &json!({"language": "ruby", "code": "puts 1"}));
+
+ let error = result.expect_err("unsupported REPL language should fail");
+ assert!(error.contains("unsupported REPL language: ruby"));
+ }
+
+ #[test]
+ fn given_timeout_ms_when_repl_blocks_then_returns_timeout_error() {
+ let result = execute_tool(
+ "REPL",
+ &json!({
+ "language": "python",
+ "code": "import time\ntime.sleep(1)",
+ "timeout_ms": 10
+ }),
+ );
+
+ let error = result.expect_err("timed out REPL execution should fail");
+ assert!(error.contains("REPL execution exceeded timeout of 10 ms"));
+ }
+
#[test]
fn powershell_runs_via_stub_shell() {
let _guard = env_lock()