Files
luxe/crates/luxe-core/tests/integration_doom_loop.rs
Evan Whittaker a0666d6c81 luxe 0.1.4: remembered models, wheel-driven lists, and a steadier phone app
- luxe starts on the model you last chose in this project, then the last one anywhere. Signing in
  opens the model picker instead of choosing for you.
- Every list in a modal takes the mouse wheel and a draggable scrollbar.
- The phone app shows reasoning in full, stays put while you read back through a long session, and
  shows a question's answer on its card.
- On Windows, luxe update replaces the running luxe, and a signed-in install no longer sees setup
  again.
- The file tree no longer shows "engine busy" in a large project, loop output is easier to follow,
  and the name is written lowercase.

The CHANGELOG has the full list.
2026-10-20 13:51:34 -05:00

175 lines
6.4 KiB
Rust

//! Doom-loop guard — a model stuck on one call is stopped, unattended, with feedback it can use.
//!
//! The guard used to raise a permission *ask*, and headless/loop runs auto-allow an ask — so it was
//! a no-op in exactly the mode where a runaway costs the most. Denying instead both stops the loop
//! and hands the model something actionable, in every mode.
#![allow(clippy::unwrap_used)]
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use futures::stream::{self, BoxStream};
use luxe_core::engine::{Action, Engine, EngineConfig};
use luxe_core::event::Event;
use luxe_core::hook::HookRegistry;
use luxe_core::provider::{
CompletionRequest, ModelInfo, Provider, ProviderError, ProviderEvent, StopReason,
};
use luxe_core::session::{JsonlSessionStore, SessionStore};
use luxe_core::tool::{Tool, ToolContext, ToolRegistry, ToolResultData};
/// A stuck model: always emits the same tool call with the same arguments.
struct StuckProvider {
calls: Arc<AtomicUsize>,
}
#[async_trait::async_trait]
impl Provider for StuckProvider {
fn name(&self) -> &str {
"stuck"
}
async fn stream(
&self,
_req: CompletionRequest,
_cancel: tokio::sync::watch::Receiver<bool>,
) -> Result<BoxStream<'static, ProviderEvent>, ProviderError> {
let round = self.calls.fetch_add(1, Ordering::SeqCst);
// After a few rounds, stop asking so the test terminates either way.
if round >= 6 {
return Ok(Box::pin(stream::iter(vec![
ProviderEvent::TextDelta { index: 0, delta: "giving up".to_string() },
ProviderEvent::Done { reason: StopReason::EndTurn },
])));
}
Ok(Box::pin(stream::iter(vec![
ProviderEvent::ToolCallStart {
index: 0,
id: format!("call-{round}"),
name: "spin".to_string(),
},
ProviderEvent::ToolCallDelta { index: 0, json_delta: r#"{"same":"args"}"#.to_string() },
ProviderEvent::ToolCallEnd { index: 0 },
ProviderEvent::Done { reason: StopReason::ToolCall },
])))
}
}
/// Counts how many times it actually ran.
struct SpinTool {
runs: Arc<AtomicUsize>,
}
#[async_trait::async_trait]
impl Tool for SpinTool {
fn name(&self) -> &str {
"spin"
}
fn schema(&self) -> luxe_core::provider::ToolSchema {
luxe_core::provider::ToolSchema {
name: "spin".to_string(),
description: "does nothing".to_string(),
parameters: serde_json::json!({"type": "object"}),
}
}
async fn run(&self, _args: serde_json::Value, _cx: &ToolContext) -> ToolResultData {
self.runs.fetch_add(1, Ordering::SeqCst);
ToolResultData {
content: vec![luxe_core::ContentBlock::Text("same result".to_string())],
is_error: false,
}
}
}
#[tokio::test]
async fn a_repeated_identical_call_is_blocked_unattended_with_actionable_feedback() {
let tmp = tempfile::tempdir().unwrap();
let mut store = JsonlSessionStore::new(tmp.path().join("sessions"));
let session_id = store.create("/tmp/test").unwrap();
let provider_calls = Arc::new(AtomicUsize::new(0));
let tool_runs = Arc::new(AtomicUsize::new(0));
let mut tools = ToolRegistry::new();
tools.register(Arc::new(SpinTool { runs: tool_runs.clone() }));
let config = EngineConfig {
session_store: std::sync::RwLock::new(Box::new(store)),
provider: Arc::new(StuckProvider { calls: provider_calls.clone() }),
providers: std::collections::HashMap::new(),
model: ModelInfo::default(),
tool_registry: tools,
hook_registry: HookRegistry::new(),
session_id,
system_prompt: None,
todo_store: None,
compaction_settings: luxe_core::compaction::CompactionSettings::default(),
// The default: permissive, with `ask` auto-allowed the way a headless run resolves it.
permission: Default::default(),
modes: Default::default(),
reviewer: None,
formatter_registry: None,
spend_sink: None,
guided_review_project_root: Some(tmp.path().to_path_buf()),
invoked_from: None,
external_work: None,
review_context_files: Vec::new(),
review_exclude: Vec::new(),
remember_choices_in: None,
cache_warming: luxe_core::cache_warming::CacheWarming::Off,
review_insight_provider: None,
github: None,
permissions_file: None,
max_tool_iterations: Some(10),
startup_notices: Vec::new(),
action_tx: None,
};
let (tx, mut rx) = Engine::spawn(config);
tx.send(Action::SubmitUserMessage {
content: "go".to_string(),
images: vec![],
remediation: None,
})
.await
.unwrap();
let mut blocked = Vec::new();
loop {
match tokio::time::timeout(std::time::Duration::from_secs(10), rx.recv()).await {
// Tool results reach the transcript as blocks on a committed message.
Ok(Some(Event::MessageCommitted { message, .. })) => {
for block in &message.content {
if let luxe_core::message::ContentBlock::ToolResult { content, .. } = block {
for output in content {
let luxe_core::message::ToolOutput::Text(text) = output else {
continue;
};
if text.contains("Blocked") {
blocked.push(text.clone());
}
}
}
}
}
Ok(Some(Event::TurnEnded { .. })) => break,
Ok(Some(_)) => {}
Ok(None) => panic!("event channel closed"),
Err(_) => panic!("timed out — the guard did not stop the loop"),
}
}
tx.send(Action::Close).await.ok();
// Two identical calls run; from the third on the guard blocks them.
assert_eq!(tool_runs.load(Ordering::SeqCst), 2, "the tool stopped running after two repeats");
assert!(!blocked.is_empty(), "the model was told the call was blocked");
let message = &blocked[0];
assert!(message.contains("spin"), "the message names the tool: {message}");
assert!(
message.contains("different approach") || message.contains("already have"),
"and says what to do instead: {message}"
);
}