An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.
Rust
fix(runtime): auto-continue a turn the model stalled without a tool call
reacechalmers7c38d7875950
diff --git a/rust/crates/runtime/src/conversation.rs b/rust/crates/runtime/src/conversation.rsindex 570190bb..e79415c6 100644--- a/rust/crates/runtime/src/conversation.rs+++ b/rust/crates/runtime/src/conversation.rs@@ -18,6 +18,38 @@ use crate::usage::{TokenUsage, UsageTracker};const DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD: u32 = 100_000;const AUTO_COMPACTION_THRESHOLD_ENV_VAR: &str = "CLAUDE_CODE_AUTO_COMPACT_INPUT_TOKENS";+const DEFAULT_MAX_STALL_NUDGES: usize = 3;+const MAX_STALL_NUDGES_ENV_VAR: &str = "CLAW_MAX_STALL_NUDGES";++/// Injected when the model narrates its next step (or asks for a go-ahead mid-task)+/// instead of emitting the tool call that would perform it.+const STALL_NUDGE_PROMPT: &str = "[auto-continue] You ended the turn without calling a tool, \+ but the work is not finished. Do not describe the next step and do not ask for \+ confirmation — issue the tool call now and keep going until the task is done. If \+ everything asked for is genuinely complete, reply with a one-line summary containing \+ no forward-looking sentence.";++/// Phrases that mark text as an announcement of work the model has not performed yet.+/// Matched against the final non-empty line of the assistant's reply.+const PENDING_ACTION_MARKERS: [&str; 16] = [+ "let me ",+ "let's ",+ "lets ",+ "i'll ",+ "i will ",+ "i'm going to",+ "i am going to",+ "going to run",+ "about to ",+ "now running",+ "now checking",+ "now i",+ "next i",+ "next, i",+ "proceeding to",+ "moving on to",+];+/// Fully assembled request payload sent to the upstream model client.#[derive(Debug, Clone, PartialEq, Eq)]pub struct ApiRequest {@@ -140,6 +172,7 @@ pub struct ConversationRuntime<C, T> {hook_abort_signal: HookAbortSignal,hook_progress_reporter: Option<Box<dyn HookProgressReporter>>,session_tracer: Option<SessionTracer>,+ max_stall_nudges: usize,}impl<C, T> ConversationRuntime<C, T>@@ -194,9 +227,17 @@ wherehook_abort_signal: HookAbortSignal::default(),hook_progress_reporter: None,session_tracer: None,+ max_stall_nudges: max_stall_nudges_from_env(),}}+ /// Override how many auto-continue nudges a stalled turn may receive. `0` disables them.+ #[must_use]+ pub fn with_max_stall_nudges(mut self, max_stall_nudges: usize) -> Self {+ self.max_stall_nudges = max_stall_nudges;+ self+ }+#[must_use]pub fn with_max_iterations(mut self, max_iterations: usize) -> Self {self.max_iterations = max_iterations;@@ -355,6 +396,9 @@ wherelet mut prompt_cache_events = Vec::new();let mut iterations = 0;let mut auto_compaction = None;+ let max_stall_nudges = self.max_stall_nudges;+ let mut stall_nudges = 0;+ let mut tools_ran = false;loop {iterations += 1;@@ -434,8 +478,30 @@ where}if pending_tool_uses.is_empty() {+ // A reply with no tool call usually means the turn is done. On small local+ // models it just as often means the model narrated the next step — or asked+ // for a go-ahead mid-task — and then emitted EOS, leaving the announced work+ // undone. Nudge it back into the loop instead of dropping the user at the+ // prompt, bounded so a model that insists it is finished still gets to stop.+ let stalled = stall_nudges < max_stall_nudges+ && is_stalled_reply(+ &assistant_text(+ assistant_messages+ .last()+ .expect("assistant message pushed above"),+ ),+ tools_ran,+ );+ if stalled {+ stall_nudges += 1;+ self.session+ .push_user_text(STALL_NUDGE_PROMPT)+ .map_err(|error| RuntimeError::new(error.to_string()))?;+ continue;+ }break;}+ tools_ran = true;for (tool_use_id, tool_name, input) in pending_tool_uses {let pre_hook_result = self.run_pre_tool_use_hook(&tool_name, &input);@@ -776,6 +842,54 @@ fn parse_auto_compaction_threshold(value: Option<&str>) -> u32 {.unwrap_or(DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD)}+/// How many auto-continue nudges a single turn may inject. `0` disables the behaviour.+#[must_use]+pub fn max_stall_nudges_from_env() -> usize {+ parse_max_stall_nudges(std::env::var(MAX_STALL_NUDGES_ENV_VAR).ok().as_deref())+}++#[must_use]+fn parse_max_stall_nudges(value: Option<&str>) -> usize {+ value+ .and_then(|raw| raw.trim().parse::<usize>().ok())+ .unwrap_or(DEFAULT_MAX_STALL_NUDGES)+}++/// Concatenated text of an assistant message, ignoring thinking and tool blocks.+#[must_use]+fn assistant_text(message: &ConversationMessage) -> String {+ message+ .blocks+ .iter()+ .filter_map(|block| match block {+ ContentBlock::Text { text } => Some(text.as_str()),+ _ => None,+ })+ .collect::<Vec<_>>()+ .join("\n")+}++/// True when a tool-less reply is a stall rather than a finished turn.+///+/// Small local models routinely narrate the next tool call in prose and then emit EOS, which+/// ends the turn with the announced work never performed. `after_tool_use` additionally treats+/// a mid-task question as a stall: once tools have run in this turn, stopping to ask for a+/// go-ahead is the same failure wearing a different hat.+#[must_use]+fn is_stalled_reply(text: &str, after_tool_use: bool) -> bool {+ let Some(last_line) = text.lines().map(str::trim).rfind(|line| !line.is_empty()) else {+ return false;+ };+ let lowered = last_line.to_lowercase();++ if after_tool_use && last_line.ends_with('?') {+ return true;+ }+ PENDING_ACTION_MARKERS+ .iter()+ .any(|marker| lowered.contains(marker))+}+fn build_assistant_message(events: Vec<AssistantEvent>,) -> Result<@@ -905,9 +1019,10 @@ impl ToolExecutor for StaticToolExecutor {#[cfg(test)]mod tests {use super::{- build_assistant_message, parse_auto_compaction_threshold, ApiClient, ApiRequest,- AssistantEvent, AutoCompactionEvent, ConversationRuntime, PromptCacheEvent, RuntimeError,- StaticToolExecutor, ToolExecutor, DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD,+ build_assistant_message, is_stalled_reply, parse_auto_compaction_threshold,+ parse_max_stall_nudges, ApiClient, ApiRequest, AssistantEvent, AutoCompactionEvent,+ ConversationRuntime, PromptCacheEvent, RuntimeError, StaticToolExecutor, ToolExecutor,+ DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD, DEFAULT_MAX_STALL_NUDGES,};use crate::compact::{estimate_session_tokens, CompactionConfig};use crate::config::{RuntimeFeatureConfig, RuntimeHookConfig};@@ -2210,4 +2325,136 @@ mod tests {// thenassert_eq!(error.to_string(), "upstream failed");}++ fn text_only(text: &str) -> Vec<AssistantEvent> {+ vec![+ AssistantEvent::TextDelta(text.to_string()),+ AssistantEvent::MessageStop,+ ]+ }++ struct CountingApi {+ calls: usize,+ replies: Vec<Vec<AssistantEvent>>,+ }++ impl ApiClient for CountingApi {+ fn stream(&mut self, _request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {+ let reply = self+ .replies+ .get(self.calls)+ .cloned()+ .unwrap_or_else(|| text_only("Now running the next probe:"));+ self.calls += 1;+ Ok(reply)+ }+ }++ fn nudge_runtime(+ replies: Vec<Vec<AssistantEvent>>,+ max_stall_nudges: usize,+ ) -> ConversationRuntime<CountingApi, StaticToolExecutor> {+ ConversationRuntime::new(+ Session::new(),+ CountingApi { calls: 0, replies },+ StaticToolExecutor::new().register("probe", |_| Ok("probe output".to_string())),+ PermissionPolicy::new(PermissionMode::DangerFullAccess),+ vec!["system".to_string()],+ )+ .with_max_stall_nudges(max_stall_nudges)+ }++ #[test]+ fn announced_but_uncalled_tool_is_auto_continued() {+ // given: the model narrates the next probe instead of calling it+ let mut runtime = nudge_runtime(+ vec![+ text_only("Now running the Ford EEC-V tuner probe (ATSP1):"),+ vec![+ AssistantEvent::ToolUse {+ id: "tool-1".to_string(),+ name: "probe".to_string(),+ input: "atsp1".to_string(),+ },+ AssistantEvent::MessageStop,+ ],+ text_only("No response on ATSP1, which is expected here."),+ ],+ 3,+ );++ // when+ let summary = runtime.run_turn("run the probes", None).expect("turn runs");++ // then: the nudge pulled it back into the loop and the tool actually ran+ assert_eq!(summary.iterations, 3);+ assert_eq!(summary.tool_results.len(), 1);+ }++ #[test]+ fn nudges_are_bounded_so_a_stuck_model_still_stops() {+ // given: every reply is an announcement and nothing is ever called+ let mut runtime = nudge_runtime(Vec::new(), 2);++ // when+ let summary = runtime.run_turn("run the probes", None).expect("turn runs");++ // then: initial reply plus exactly two nudged retries+ assert_eq!(summary.iterations, 3);+ assert!(summary.tool_results.is_empty());+ }++ #[test]+ fn a_plain_completion_is_not_nudged() {+ // given+ let mut runtime = nudge_runtime(vec![text_only("The DTC scan came back clean.")], 3);++ // when+ let summary = runtime.run_turn("scan for codes", None).expect("turn runs");++ // then+ assert_eq!(summary.iterations, 1);+ }++ #[test]+ fn zero_budget_disables_auto_continue() {+ // given+ let mut runtime = nudge_runtime(vec![text_only("Let me run the DTC scan.")], 0);++ // when+ let summary = runtime.run_turn("scan for codes", None).expect("turn runs");++ // then+ assert_eq!(summary.iterations, 1);+ }++ #[test]+ fn a_question_stalls_only_after_a_tool_has_run() {+ assert!(is_stalled_reply("Should I run the DTC scan next?", true));+ assert!(!is_stalled_reply("Which port is the adapter on?", false));+ }++ #[test]+ fn stall_detection_reads_the_last_line_not_the_whole_reply() {+ // an announcement earlier in the reply does not make a finished turn look stalled+ assert!(!is_stalled_reply(+ "Let me check the port.\nThe scan finished with no codes stored.",+ true+ ));+ assert!(is_stalled_reply(+ "The scan finished.\nNext I'll read the freeze-frame data.",+ true+ ));+ }++ #[test]+ fn stall_nudge_budget_parses_from_env_value() {+ // asserted against the literal, not the constant: comparing the parser to the same+ // constant it falls back to would pass no matter what the default became+ assert_eq!(DEFAULT_MAX_STALL_NUDGES, 3);+ assert_eq!(parse_max_stall_nudges(None), 3);+ assert_eq!(parse_max_stall_nudges(Some("not a number")), 3);+ assert_eq!(parse_max_stall_nudges(Some(" 5 ")), 5);+ assert_eq!(parse_max_stall_nudges(Some("0")), 0);+ }}diff --git a/rust/crates/runtime/src/prompt.rs b/rust/crates/runtime/src/prompt.rsindex 727d673a..ae5bf66b 100644--- a/rust/crates/runtime/src/prompt.rs+++ b/rust/crates/runtime/src/prompt.rs@@ -783,6 +783,7 @@ fn get_simple_doing_tasks_section() -> String {"Do not add speculative abstractions, compatibility shims, or unrelated cleanup.".to_string(),"Do not create files unless they are required to complete the task.".to_string(),"If an approach fails, diagnose the failure before switching tactics.".to_string(),+ "Act in the turn you plan in: when the next step is a tool call, make the call. Never end a turn describing a step you have not taken, and do not stop to ask for a go-ahead on work already requested.".to_string(),"Be careful not to introduce security vulnerabilities such as command injection, XSS, or SQL injection.".to_string(),"Report outcomes faithfully: if verification fails or was not run, say so explicitly.".to_string(),]);