Files
luxe/crates/luxe-core/src/engine/nested_instructions.rs
Evan Whittaker d2129a886f Luxe 0.1.3: your sessions on your phone, joinable sessions, and nested AGENTS.md
- luxe remote puts the sessions on your computer in reach of your own phone or tablet over
  Tailscale: write, steer, answer prompts, send photos, browse files, diffs and GitHub, with a
  paired device and your own Tailscale login.
- luxe join lets another program on the same machine join a running session over the RPC protocol.
- An AGENTS.md in a subfolder reaches the model the first time it works there.
- Long sessions stay fast: no stall before each model call, lighter memory, cheaper drawing.
- A session is open in one Luxe at a time, web_search shares results across its phrasings, and a
  grep glob starting with ! excludes.

The CHANGELOG has the full list.
2026-10-20 02:40:13 -05:00

145 lines
5.4 KiB
Rust

//! Nested instructions, delivered — the engine side of [`crate::instructions::nested`].
//!
//! Runs on a finished batch, just before it commits, so a file rides on the result of the first
//! call that reached its folder and is durable history from then on. Every later request carries
//! it as part of the transcript it already appends to; the system prompt never moves.
use super::*;
use crate::instructions::nested::{self, NestedFile};
use crate::message::ToolOutput;
use std::collections::HashSet;
use std::path::PathBuf;
impl Engine {
/// Appends each nested instruction file the batch reached, and the model doesn't have yet, to
/// the result of the first call that reached it.
///
/// Args: `(leaf, calls, results, event_tx)`. `leaf` is the reply the results answer, so the
/// conversation read is the one these results join.
pub(super) async fn attach_nested_instructions(
&self,
leaf: &EntryId,
calls: &[ToolCallInfo],
results: &mut [ContentBlock],
event_tx: &mpsc::Sender<Event>,
) {
if !nested::enabled() {
return;
}
let wanted = self.nested_wanted(calls, results);
if wanted.is_empty() {
return;
}
let held = self.nested_on_path(leaf).await;
for (call_id, file) in wanted.into_iter().filter(|(_, file)| !held.contains(&file.shown)) {
attach_one(&call_id, &file, results, event_tx).await;
}
}
/// The nested files this batch's successful calls reached, each once, with the call that
/// reached it first.
fn nested_wanted(
&self,
calls: &[ToolCallInfo],
results: &[ContentBlock],
) -> Vec<(String, NestedFile)> {
let launch = self.instruction_dir();
let mut seen: HashSet<PathBuf> = HashSet::new();
let mut wanted = Vec::new();
for call in calls.iter().filter(|call| succeeded(results, &call.id)) {
for file in reached(&launch, call) {
if seen.insert(file.path.clone()) {
wanted.push((call.id.clone(), file));
}
}
}
wanted
}
/// The nested files the conversation up to `leaf` already carries, by the notes that open
/// them. Read rather than remembered, so one a rewind or a compaction took away goes again.
async fn nested_on_path(&self, leaf: &EntryId) -> HashSet<String> {
let sid = self.current_session_id().await;
let read = crate::session::with_active_path(&**self.sessions(), &sid, leaf, |entries| {
crate::compaction::context_messages(entries)
});
match read {
Ok(messages) => notes_in(&messages),
Err(error) => {
// Sending a file twice costs tokens; not sending it costs the rules
warn!(%error, "could not read which nested instructions the model has");
HashSet::new()
}
}
}
}
/// The nested files `call` reached, from Luxe launched at `launch`.
///
/// Relative paths resolve the way the tool resolved them, against where tools run.
fn reached(launch: &std::path::Path, call: &ToolCallInfo) -> Vec<NestedFile> {
let args = parse_tool_arguments(&call.arguments);
let base = ToolContext::working_dir();
let targets = nested::touched_paths(&args);
targets
.into_iter()
.flat_map(|target| nested::nested_files(launch, &base.join(target)))
.collect()
}
/// The output of the result answering `call_id`.
fn output_of<'a>(
results: &'a mut [ContentBlock],
call_id: &str,
) -> Option<&'a mut Vec<ToolOutput>> {
results.iter_mut().find_map(|block| match block {
ContentBlock::ToolResult { call_id: id, content, .. } if id == call_id => Some(content),
_ => None,
})
}
/// Whether the result answering `call_id` ran and succeeded.
fn succeeded(results: &[ContentBlock], call_id: &str) -> bool {
results.iter().any(|block| {
matches!(block, ContentBlock::ToolResult { call_id: id, is_error: false, .. } if id == call_id)
})
}
/// Every nested file named by a note in a tool result of `messages`.
fn notes_in(messages: &[Message]) -> HashSet<String> {
let outputs =
messages.iter().flat_map(|message| &message.content).filter_map(|block| match block {
ContentBlock::ToolResult { content, .. } => Some(content),
_ => None,
});
outputs
.flatten()
.filter_map(|output| match output {
ToolOutput::Text(text) => nested::noted(text).map(str::to_string),
_ => None,
})
.collect()
}
/// Reads `file` and appends it to the result answering `call_id`, telling the person it did.
async fn attach_one(
call_id: &str,
file: &NestedFile,
results: &mut [ContentBlock],
event_tx: &mpsc::Sender<Event>,
) {
let Some(injected) = super::prompt::read_context_file(&file.path) else {
return;
};
let Some(content) = output_of(results, call_id) else {
return;
};
let block = crate::redact::process_secrets().redact(&nested::note(&file.shown, &injected.text));
content.push(ToolOutput::Text(block));
debug!(file = %file.shown, "nested instructions joined the conversation");
let _ = event_tx.send(Event::Notice(format!("Following {}", file.shown))).await;
if let Some(notice) = injected.notice {
let _ = event_tx.send(Event::Notice(notice)).await;
}
}