Hare/yoi
1
1
Fork 0
Code Actions Packages Releases Activity

refactor: rename llm worker crate to engine

Browse Source
This commit is contained in:
Hare
2026-06-25 22:46:26 +09:00
parent 22598710fd
commit 292fc4ea5d
202 changed files with 1129 additions and 1125 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/pod/tests/compact_events_test.rs
+8 -8
View File
@@ -12,10 +12,10 @@ use std::sync::atomic::{AtomicUsize, Ordering};
use async_trait::async_trait;
use futures::Stream;
use llm_worker::Worker;
use llm_worker::llm_client::event::{Event as LlmEvent, ResponseStatus, StatusEvent};
use llm_worker::llm_client::types::Item;
use llm_worker::llm_client::{ClientError, LlmClient, Request};
use llm_engine::Engine;
use llm_engine::llm_client::event::{Event as LlmEvent, ResponseStatus, StatusEvent};
use llm_engine::llm_client::types::Item;
use llm_engine::llm_client::{ClientError, LlmClient, Request};
use pod_store::{CombinedStore, FsPodStore, PodMetadataStore};
use protocol::{Event, Method, RunResult};
use session_store::{FsStore, LogEntry, Store};
@@ -163,7 +163,7 @@ async fn make_pod_with_manifest(
let scope = pod::Scope::writable(&pwd).unwrap();
std::mem::forget(pwd_tmp);
let worker = Worker::new(client);
let worker = Engine::new(client);
let mut pod = Pod::new(manifest, worker, store, pwd, scope).await.unwrap();
pod.enable_pod_metadata_write_through().unwrap();
pod
@@ -189,7 +189,7 @@ fn drain(rx: &mut broadcast::Receiver<Event>) -> Vec<Event> {
/// `SegmentStart.history` carries, by reading the sink mirror directly.
fn system_texts_in_sink_session_start(
pod: &pod::Pod<
impl llm_worker::llm_client::client::LlmClient + Clone + 'static,
impl llm_engine::llm_client::client::LlmClient + Clone + 'static,
impl session_store::Store + Clone + 'static,
>,
) -> Vec<String> {
@@ -202,7 +202,7 @@ fn system_texts_in_sink_session_start(
let item: Item = logged.into();
match item {
Item::Message {
role: llm_worker::Role::System,
role: llm_engine::Role::System,
content,
..
} => Some(
@@ -462,7 +462,7 @@ async fn mid_turn_compact_success_broadcasts_start_and_done() {
pod.run_text("first").await.unwrap();
let _ = drain(&mut rx);
// Second run: pre_llm_request yields immediately, Worker returns
// Second run: pre_llm_request yields immediately, Engine returns
// Yielded, handle_worker_result routes into do_compact_and_resume.
pod.run_text("second").await.unwrap();
crates/pod/tests/consolidation_test.rs
+5 -5
View File
@@ -20,9 +20,9 @@ use std::sync::atomic::{AtomicUsize, Ordering};
use async_trait::async_trait;
use futures::Stream;
use llm_worker::Worker;
use llm_worker::llm_client::event::{Event as LlmEvent, ResponseStatus, StatusEvent};
use llm_worker::llm_client::{ClientError, LlmClient, Request};
use llm_engine::Engine;
use llm_engine::llm_client::event::{Event as LlmEvent, ResponseStatus, StatusEvent};
use llm_engine::llm_client::{ClientError, LlmClient, Request};
use memory::WorkspaceLayout;
use memory::extract::{ExtractedPayload, write_staging};
use memory::schema::SourceRef;
@@ -169,7 +169,7 @@ async fn make_pod_with(
std::mem::forget(store_tmp);
let scope = pod::Scope::writable(&pwd).unwrap();
let worker = Worker::new(client);
let worker = Engine::new(client);
Pod::new(manifest, worker, store, pwd, scope).await.unwrap()
}
@@ -388,7 +388,7 @@ async fn fires_on_threshold_and_cleans_up_consumed_entries() {
write_n_staging(&layout, 2); // threshold is 2 — fires.
// Sub-worker is given a single text-only response. The consolidation prompt
// tells it to call memory tools; the mock skips those, but `Worker::run`
// tells it to call memory tools; the mock skips those, but `Engine::run`
// returns Ok regardless once the LLM closes with a final text.
let client = MockClient::new(vec![done("ok")]);
let mut pod = make_pod_with(FILES_THRESHOLD_TOML, pwd.path().to_path_buf(), client).await;
crates/pod/tests/controller_test.rs
+38 -38
View File
@@ -4,11 +4,11 @@ use std::sync::{Arc, Mutex};
use async_trait::async_trait;
use futures::{Stream, StreamExt};
use llm_worker::Worker;
use llm_worker::llm_client::event::{ErrorEvent, Event as LlmEvent, ResponseStatus, StatusEvent};
use llm_worker::llm_client::types::Item;
use llm_worker::llm_client::{ClientError, LlmClient, Request};
use llm_worker::tool::{Tool, ToolDefinition, ToolError, ToolMeta, ToolOutput};
use llm_engine::Engine;
use llm_engine::llm_client::event::{ErrorEvent, Event as LlmEvent, ResponseStatus, StatusEvent};
use llm_engine::llm_client::types::Item;
use llm_engine::llm_client::{ClientError, LlmClient, Request};
use llm_engine::tool::{Tool, ToolDefinition, ToolError, ToolMeta, ToolOutput};
use pod_store::{CombinedStore, FsPodStore};
use session_store::{FsStore, LogEntry};
@@ -53,7 +53,7 @@ fn history_from_sink(handle: &PodHandle) -> Vec<Item> {
enum MockResponse {
/// Emit the events and let the stream terminate naturally.
Complete(Vec<LlmEvent>),
/// Emit the events and then pend forever so the Worker blocks on
/// Emit the events and then pend forever so the Engine blocks on
/// `stream.next()` — used to exercise the Cancel/Pause path while a
/// turn is actively in flight.
Hang(Vec<LlmEvent>),
@@ -183,7 +183,7 @@ async fn make_pod_with_pwd_and_manifest(
let scope = manifest::Scope::writable(&pwd).unwrap();
std::mem::forget(pwd_tmp);
let worker = Worker::new(client);
let worker = Engine::new(client);
let pod = Pod::new(manifest, worker, store, pwd.clone(), scope)
.await
.unwrap();
@@ -518,7 +518,7 @@ async fn provider_stream_error_records_run_errored() {
!entries.iter().any(|entry| matches!(
entry,
LogEntry::RunCompleted {
result: llm_worker::WorkerResult::Finished,
result: llm_engine::EngineResult::Finished,
..
}
)),
@@ -854,7 +854,7 @@ async fn run_with_paste_segment_inlines_content_and_emits_typed_user_message() {
let echoed = user_input_segments.expect("committed UserInput entry missing");
assert_eq!(echoed, segments, "typed segments must round-trip unchanged");
// The Worker received a single user message whose text is the
// The Engine received a single user message whose text is the
// flattened body — paste content inlined, no chip label.
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
let requests = client_for_assert.captured_requests();
@@ -1101,7 +1101,7 @@ async fn notify_while_idle_auto_starts_turn_and_injects_system_message() {
.collect::<Vec<_>>()
);
// The notification must also be persisted into the Worker history
// The notification must also be persisted into the Engine history
// (and therefore eventually into history.json), per
// tickets/notify-history-persist.md.
let history = history_from_sink(&handle);
@@ -1638,7 +1638,7 @@ impl Tool for HangingTool {
async fn execute(
&self,
_input: &str,
_ctx: llm_worker::tool::ToolExecutionContext,
_ctx: llm_engine::tool::ToolExecutionContext,
) -> Result<ToolOutput, ToolError> {
std::future::pending::<()>().await;
unreachable!()
@@ -1681,7 +1681,7 @@ async fn drain_until<F: FnMut(&Event) -> bool>(
#[tokio::test]
async fn pause_then_resume_transitions_and_preserves_history_consistency() {
// Response 1: hang after opening a text block (no stop / completed),
// so the Worker is parked inside the stream read and `cancel_rx`
// so the Engine is parked inside the stream read and `cancel_rx`
// races it cleanly on Method::Pause.
let hang = MockResponse::Hang(vec![
LlmEvent::text_block_start(0),
@@ -1717,7 +1717,7 @@ async fn pause_then_resume_transitions_and_preserves_history_consistency() {
handle.send(Method::Pause).await.unwrap();
// The controller emits RunEnd { Paused } when the
// WorkerError::Cancelled is translated under pause_requested.
// EngineError::Cancelled is translated under pause_requested.
assert!(
drain_until(&mut rx, std::time::Duration::from_secs(2), |e| matches!(
e,
@@ -1756,9 +1756,9 @@ async fn pause_then_resume_transitions_and_preserves_history_consistency() {
.iter()
.filter_map(|i| match i {
Item::Message { role, .. } => match role {
llm_worker::Role::User => Some("user"),
llm_worker::Role::Assistant => Some("assistant"),
llm_worker::Role::System => Some("system"),
llm_engine::Role::User => Some("user"),
llm_engine::Role::Assistant => Some("assistant"),
llm_engine::Role::System => Some("system"),
},
_ => None,
})
@@ -1772,13 +1772,13 @@ async fn pause_then_resume_transitions_and_preserves_history_consistency() {
.iter()
.find_map(|i| match i {
Item::Message {
role: llm_worker::Role::Assistant,
role: llm_engine::Role::Assistant,
content,
..
} => Some(
content
.iter()
.map(|p: &llm_worker::ContentPart| p.as_text().to_owned())
.map(|p: &llm_engine::ContentPart| p.as_text().to_owned())
.collect::<Vec<_>>()
.join(""),
),
@@ -1797,7 +1797,7 @@ async fn pause_then_resume_transitions_and_preserves_history_consistency() {
#[tokio::test]
async fn paused_then_run_closes_orphan_tool_use_for_next_request() {
// Response 1: emit a tool_use block (complete with stop) targeting
// our hanging tool. The Worker commits the ToolCall to history,
// our hanging tool. The Engine commits the ToolCall to history,
// then parks inside `execute_tools` waiting on the tool — which is
// where Method::Pause catches it.
let tool_name = "HangyTool";
@@ -1821,7 +1821,7 @@ async fn paused_then_run_closes_orphan_tool_use_for_next_request() {
let client = MockClient::sequential(vec![first, second]);
let client_for_assert = client.clone();
let mut pod = make_pod(client).await;
pod.worker_mut()
pod.engine_mut()
.register_tool(hanging_tool_definition(tool_name));
let handle = spawn_controller(pod).await;
let mut rx = handle.subscribe();
@@ -1829,7 +1829,7 @@ async fn paused_then_run_closes_orphan_tool_use_for_next_request() {
handle.send(Method::run_text("first")).await.unwrap();
// Wait for ToolCallDone — the ToolCall is committed to history
// right before the Worker enters tool execution and pends.
// right before the Engine enters tool execution and pends.
assert!(
drain_until(&mut rx, std::time::Duration::from_secs(2), |e| matches!(
e,
@@ -1882,21 +1882,21 @@ async fn paused_then_run_closes_orphan_tool_use_for_next_request() {
let mut saw_new_user = false;
for item in items {
match item {
llm_worker::Item::ToolResult {
llm_engine::Item::ToolResult {
call_id, summary, ..
} if call_id == "call_orphan" => {
assert_eq!(summary, "[Interrupted by user]");
saw_synthetic_tool_result = true;
}
llm_worker::Item::Message { role, content, .. }
if *role == llm_worker::Role::System =>
llm_engine::Item::Message { role, content, .. }
if *role == llm_engine::Role::System =>
{
let text: String = content.iter().map(|p| p.as_text()).collect();
if text.contains("interrupted by the user") {
saw_interruption_note = true;
}
}
llm_worker::Item::Message { role, content, .. } if *role == llm_worker::Role::User => {
llm_engine::Item::Message { role, content, .. } if *role == llm_engine::Role::User => {
let text: String = content.iter().map(|p| p.as_text()).collect();
if text.contains("new request") {
saw_new_user = true;
@@ -1921,13 +1921,13 @@ async fn paused_then_run_closes_orphan_tool_use_for_next_request() {
// Also confirm the closure chain is ordered: tool_result for the
// orphan precedes the system note, which precedes the new user
// message.
let idx = |pred: &dyn Fn(&llm_worker::Item) -> bool| items.iter().position(pred).unwrap();
let idx = |pred: &dyn Fn(&llm_engine::Item) -> bool| items.iter().position(pred).unwrap();
let tool_result_idx = idx(
&|i| matches!(i, llm_worker::Item::ToolResult { call_id, .. } if call_id == "call_orphan"),
&|i| matches!(i, llm_engine::Item::ToolResult { call_id, .. } if call_id == "call_orphan"),
);
let sys_idx = idx(&|i| match i {
llm_worker::Item::Message {
role: llm_worker::Role::System,
llm_engine::Item::Message {
role: llm_engine::Role::System,
content,
..
} => content
@@ -1938,8 +1938,8 @@ async fn paused_then_run_closes_orphan_tool_use_for_next_request() {
_ => false,
});
let user_idx = idx(&|i| match i {
llm_worker::Item::Message {
role: llm_worker::Role::User,
llm_engine::Item::Message {
role: llm_engine::Role::User,
content,
..
} => content
@@ -1981,7 +1981,7 @@ async fn paused_cancel_abandons_resume_and_next_input_is_fresh_run() {
let client = MockClient::sequential(vec![first, second]);
let client_for_assert = client.clone();
let mut pod = make_pod(client).await;
pod.worker_mut()
pod.engine_mut()
.register_tool(hanging_tool_definition(tool_name));
let handle = spawn_controller(pod).await;
let mut rx = handle.subscribe();
@@ -2022,7 +2022,7 @@ async fn paused_cancel_abandons_resume_and_next_input_is_fresh_run() {
!entries_after_cancel.iter().any(|entry| matches!(
entry,
LogEntry::RunCompleted {
result: llm_worker::WorkerResult::Finished,
result: llm_engine::EngineResult::Finished,
interrupted: false,
..
}
@@ -2078,7 +2078,7 @@ async fn paused_cancel_abandons_resume_and_next_input_is_fresh_run() {
assert!(
items.iter().any(|item| matches!(
item,
llm_worker::Item::ToolResult { call_id, summary, .. }
llm_engine::Item::ToolResult { call_id, summary, .. }
if call_id == "call_cancelled" && summary == "[Interrupted by user]"
)),
"paused cancel should close orphan tool_use before future requests: {items:?}"
@@ -2086,8 +2086,8 @@ async fn paused_cancel_abandons_resume_and_next_input_is_fresh_run() {
assert!(
items.iter().any(|item| matches!(
item,
llm_worker::Item::Message {
role: llm_worker::Role::System,
llm_engine::Item::Message {
role: llm_engine::Role::System,
..
} if item_text_contains(item, "interrupted by the user")
)),
@@ -2096,8 +2096,8 @@ async fn paused_cancel_abandons_resume_and_next_input_is_fresh_run() {
assert!(
items.iter().any(|item| matches!(
item,
llm_worker::Item::Message {
role: llm_worker::Role::User,
llm_engine::Item::Message {
role: llm_engine::Role::User,
..
} if item_text_contains(item, "fresh request")
)),
crates/pod/tests/pod_comm_tools_test.rs
+2 -2
View File
@@ -11,8 +11,8 @@
use std::path::{Path, PathBuf};
use std::sync::{Arc, LazyLock, Mutex};
use llm_worker::llm_client::types::{ContentPart, Item, Role};
use llm_worker::tool::ToolOutput;
use llm_engine::llm_client::types::{ContentPart, Item, Role};
use llm_engine::tool::ToolOutput;
use manifest::{Permission, Scope, ScopeRule, SharedScope};
use pod::runtime::dir::{RuntimeDir, SpawnedPodRecord};
use pod::runtime::pod_registry::{self, LockFileGuard};
crates/pod/tests/session_metrics_test.rs
+8 -8
View File
@@ -21,10 +21,10 @@ use std::sync::atomic::{AtomicUsize, Ordering};
use async_trait::async_trait;
use futures::Stream;
use llm_worker::Worker;
use llm_worker::llm_client::event::{Event as LlmEvent, ResponseStatus, StatusEvent, UsageEvent};
use llm_worker::llm_client::{ClientError, LlmClient, Request};
use llm_worker::tool::{Tool, ToolDefinition, ToolError, ToolMeta, ToolOutput};
use llm_engine::Engine;
use llm_engine::llm_client::event::{Event as LlmEvent, ResponseStatus, StatusEvent, UsageEvent};
use llm_engine::llm_client::{ClientError, LlmClient, Request};
use llm_engine::tool::{Tool, ToolDefinition, ToolError, ToolMeta, ToolOutput};
use pod_store::{CombinedStore, FsPodStore};
use session_metrics::{DOMAIN, Metric, metrics_from_extensions};
use session_store::{FsStore, LogEntry, SegmentId, SessionId, Store, StoreError, TraceEntry};
@@ -82,7 +82,7 @@ impl Tool for BigContentTool {
async fn execute(
&self,
_input: &str,
_ctx: llm_worker::tool::ToolExecutionContext,
_ctx: llm_engine::tool::ToolExecutionContext,
) -> Result<ToolOutput, ToolError> {
Ok(ToolOutput {
summary: self.summary.into(),
@@ -187,7 +187,7 @@ async fn make_pod(
let pwd = pwd_tmp.path().to_path_buf();
let scope = pod::Scope::writable(&pwd).unwrap();
let mut worker = Worker::new(client);
let mut worker = Engine::new(client);
worker.register_tool(big_content_tool_definition(tool_name));
let pod = Pod::new(manifest, worker, store, pwd, scope).await.unwrap();
@@ -448,7 +448,7 @@ async fn metric_write_failure_emits_warn_alert_and_does_not_abort_run() {
// protected token budget covers the only user message). That is enough to drive
// the failure path: at least one metric attempts to write.
let client = MockClient::new(vec![text_response_with_cache("hi", 0, 0)]);
let worker = Worker::new(client);
let worker = Engine::new(client);
let mut pod = Pod::new(manifest, worker, store.clone(), pwd, scope)
.await
.unwrap();
@@ -517,7 +517,7 @@ permission = "write"
let pwd_tmp = tempfile::tempdir().unwrap();
let pwd = pwd_tmp.path().to_path_buf();
let scope = pod::Scope::writable(&pwd).unwrap();
let worker = Worker::new(client);
let worker = Engine::new(client);
let mut pod = Pod::new(manifest, worker, store.clone(), pwd, scope)
.await
.unwrap();
crates/pod/tests/spawn_pod_test.rs
+1 -1
View File
@@ -10,7 +10,7 @@ use std::path::{Path, PathBuf};
use std::sync::{LazyLock, Mutex};
use client::PodRuntimeCommand;
use llm_worker::tool::{ToolError, ToolOutput};
use llm_engine::tool::{ToolError, ToolOutput};
use manifest::{
AuthRef, ModelManifest, Permission, PodManifest, PodManifestConfig, PodMetaConfig, SchemeKind,
Scope, ScopeConfig, ScopeRule, SharedScope,
crates/pod/tests/system_prompt_template_test.rs
+16 -16
View File
@@ -5,9 +5,9 @@ use std::sync::atomic::{AtomicUsize, Ordering};
use async_trait::async_trait;
use futures::Stream;
use llm_worker::Worker;
use llm_worker::llm_client::event::{Event as LlmEvent, ResponseStatus, StatusEvent};
use llm_worker::llm_client::{ClientError, LlmClient, Request};
use llm_engine::Engine;
use llm_engine::llm_client::event::{Event as LlmEvent, ResponseStatus, StatusEvent};
use llm_engine::llm_client::{ClientError, LlmClient, Request};
use pod_store::{CombinedStore, FsPodStore};
use session_store::{FsStore, LogEntry, Store};
@@ -122,7 +122,7 @@ async fn make_pod_with_body(
let loader = PromptLoader::new(Some(user_prompts_tmp.path().to_path_buf()), None);
std::mem::forget(user_prompts_tmp);
let worker = Worker::new(client);
let worker = Engine::new(client);
let mut pod = Pod::new(manifest, worker, store, pwd.clone(), scope).await?;
let template = SystemPromptTemplate::parse("$user/test", loader)
@@ -154,7 +154,7 @@ async fn template_is_not_materialised_before_first_run() {
let client = MockClient::new(vec![single_text_events("ok")]);
let (pod, _pwd) = make_pod_with_body("hello", client).await.unwrap();
// Before first run, worker still has no system prompt.
assert!(pod.worker().get_system_prompt().is_none());
assert!(pod.engine().get_system_prompt().is_none());
}
#[tokio::test]
@@ -168,7 +168,7 @@ async fn materialise_on_first_turn_populates_worker() {
.unwrap();
pod.run_text("hi").await.unwrap();
let rendered = pod
.worker()
.engine()
.get_system_prompt()
.expect("system prompt materialised")
.to_string();
@@ -222,9 +222,9 @@ async fn materialise_runs_only_once_across_turns() {
.await
.unwrap();
pod.run_text("one").await.unwrap();
let first = pod.worker().get_system_prompt().unwrap().to_string();
let first = pod.engine().get_system_prompt().unwrap().to_string();
pod.run_text("two").await.unwrap();
let second = pod.worker().get_system_prompt().unwrap().to_string();
let second = pod.engine().get_system_prompt().unwrap().to_string();
assert_eq!(first, second);
}
@@ -235,7 +235,7 @@ async fn agents_md_is_injected_as_trailing_section_when_present() {
std::fs::write(pwd.join("AGENTS.md"), "# project rules\nbe kind").unwrap();
pod.run_text("hi").await.unwrap();
let rendered = pod.worker().get_system_prompt().unwrap().to_string();
let rendered = pod.engine().get_system_prompt().unwrap().to_string();
assert!(rendered.starts_with("BODY"));
assert!(rendered.contains("## Project instructions (AGENTS.md)"));
assert!(rendered.contains("# project rules"));
@@ -247,7 +247,7 @@ async fn agents_md_absent_omits_trailing_section() {
let client = MockClient::new(vec![single_text_events("ok")]);
let (mut pod, _pwd) = make_pod_with_body("BODY", client).await.unwrap();
pod.run_text("hi").await.unwrap();
let rendered = pod.worker().get_system_prompt().unwrap().to_string();
let rendered = pod.engine().get_system_prompt().unwrap().to_string();
assert!(!rendered.contains("## Project instructions"));
assert!(!rendered.contains("AGENTS.md"));
}
@@ -266,7 +266,7 @@ async fn agents_md_not_reread_after_compact() {
std::fs::write(&agents_path, "original").unwrap();
pod.run_text("first").await.unwrap();
let before = pod.worker().get_system_prompt().unwrap().to_string();
let before = pod.engine().get_system_prompt().unwrap().to_string();
assert!(before.contains("original"));
pod.run_text("second").await.unwrap();
@@ -274,12 +274,12 @@ async fn agents_md_not_reread_after_compact() {
// system prompt either on a subsequent turn or across compaction.
std::fs::write(&agents_path, "mutated").unwrap();
pod.compact(0).await.unwrap();
let after_compact = pod.worker().get_system_prompt().unwrap().to_string();
let after_compact = pod.engine().get_system_prompt().unwrap().to_string();
assert!(after_compact.contains("original"));
assert!(!after_compact.contains("mutated"));
pod.run_text("third").await.unwrap();
let after_third = pod.worker().get_system_prompt().unwrap().to_string();
let after_third = pod.engine().get_system_prompt().unwrap().to_string();
assert!(after_third.contains("original"));
assert!(!after_third.contains("mutated"));
}
@@ -329,14 +329,14 @@ async fn compact_preserves_system_prompt() {
.unwrap();
pod.run_text("first").await.unwrap();
let before = pod.worker().get_system_prompt().unwrap().to_string();
let before = pod.engine().get_system_prompt().unwrap().to_string();
pod.run_text("second").await.unwrap();
pod.compact(0).await.unwrap();
let after = pod.worker().get_system_prompt().unwrap().to_string();
let after = pod.engine().get_system_prompt().unwrap().to_string();
assert_eq!(before, after);
pod.run_text("third").await.unwrap();
assert_eq!(pod.worker().get_system_prompt().unwrap(), after.as_str());
assert_eq!(pod.engine().get_system_prompt().unwrap(), after.as_str());
}