Abstract mutation host out of bridge

This commit is contained in:
Meta Vens 2026-05-19 14:56:46 +01:00
commit dc6d74c37c
6 changed files with 148 additions and 111 deletions

View file

@ -13,7 +13,6 @@ path = "src/lib.rs"
anyhow = "1"
chrono = { version = "0.4", default-features = false, features = ["clock", "serde"] }
codex-app-server-protocol = { path = "../vendor/codex/codex-rs/app-server-protocol" }
codex-core = { path = "../vendor/codex/codex-rs/core" }
codex-protocol = { path = "../vendor/codex/codex-rs/protocol" }
codex-utils-absolute-path = { path = "../vendor/codex/codex-rs/utils/absolute-path" }
epiphany-core = { path = "../epiphany-core" }

View file

@ -1,6 +1,7 @@
use chrono::SecondsFormat;
use chrono::Utc;
use std::path::Path;
use std::path::PathBuf;
use codex_app_server_protocol::ThreadEpiphanyJob;
use codex_app_server_protocol::ThreadEpiphanyJobKind;
@ -12,7 +13,6 @@ use codex_app_server_protocol::ThreadEpiphanyRoleFinding;
use codex_app_server_protocol::ThreadEpiphanyRoleId;
use codex_app_server_protocol::ThreadEpiphanyStateUpdatedField;
use codex_app_server_protocol::ThreadEpiphanyUpdatePatch;
use codex_core::CodexThread;
use codex_protocol::error::CodexErr;
use codex_protocol::protocol::EpiphanyEvidenceRecord;
use codex_protocol::protocol::EpiphanyJobKind as CoreEpiphanyJobKind;
@ -56,10 +56,23 @@ use crate::reorient::map_epiphany_freshness;
use crate::reorient::map_epiphany_reorient;
use crate::runtime_results::load_completed_epiphany_reorient_finding;
use crate::runtime_results::load_completed_epiphany_role_finding;
use crate::state::client_visible_epiphany_state_for_paths;
use crate::state::thread_state_mirror_id_from_rollout_path;
use uuid::Uuid;
#[allow(async_fn_in_trait)]
pub trait EpiphanyMutationHost {
async fn epiphany_state(&self) -> Option<EpiphanyThreadState>;
async fn epiphany_reference_turn_id(&self) -> Option<String>;
async fn epiphany_persist_state(
&self,
next_state: EpiphanyThreadState,
) -> Result<EpiphanyThreadState, CodexErr>;
async fn epiphany_runtime_spine_store_path(&self) -> PathBuf;
async fn client_visible_epiphany_state(
&self,
fallback: EpiphanyThreadState,
) -> EpiphanyThreadState;
}
#[derive(Debug, Clone)]
pub struct EpiphanyThreadUpdateApplied {
pub revision: u64,
@ -127,7 +140,7 @@ pub struct EpiphanyReorientLaunchApplied {
}
pub async fn apply_epiphany_state_update_to_thread(
thread: &CodexThread,
thread: &impl EpiphanyMutationHost,
update: EpiphanyStateUpdate,
) -> Result<EpiphanyThreadState, CodexErr> {
let current_state = thread.epiphany_state().await.unwrap_or_default();
@ -171,7 +184,7 @@ pub fn apply_epiphany_state_update_to_state(
}
pub async fn launch_epiphany_job_on_thread(
thread: &CodexThread,
thread: &impl EpiphanyMutationHost,
request: EpiphanyJobLaunchRequest,
) -> Result<EpiphanyJobLaunchResult, CodexErr> {
let current_state = thread.epiphany_state().await.unwrap_or_default();
@ -244,7 +257,7 @@ pub async fn launch_epiphany_job_on_thread(
}
pub async fn interrupt_epiphany_job_on_thread(
thread: &CodexThread,
thread: &impl EpiphanyMutationHost,
request: EpiphanyJobInterruptRequest,
) -> Result<EpiphanyJobInterruptResult, CodexErr> {
if request.binding_id.trim().is_empty() {
@ -293,14 +306,14 @@ pub async fn interrupt_epiphany_job_on_thread(
}
pub async fn apply_thread_epiphany_update(
thread: &CodexThread,
thread: &impl EpiphanyMutationHost,
expected_revision: Option<u64>,
patch: ThreadEpiphanyUpdatePatch,
) -> Result<EpiphanyThreadUpdateApplied, CodexErr> {
let changed_fields = epiphany_update_patch_changed_fields(&patch);
let update = state_update_from_thread_patch(expected_revision, patch);
let epiphany_state = apply_epiphany_state_update_to_thread(thread, update).await?;
let epiphany_state = client_visible_live_thread_epiphany_state(thread, epiphany_state).await;
let epiphany_state = thread.client_visible_epiphany_state(epiphany_state).await;
Ok(EpiphanyThreadUpdateApplied {
revision: epiphany_state.revision,
changed_fields,
@ -309,7 +322,7 @@ pub async fn apply_thread_epiphany_update(
}
pub async fn apply_thread_epiphany_promote(
thread: &CodexThread,
thread: &impl EpiphanyMutationHost,
expected_revision: Option<u64>,
patch: ThreadEpiphanyUpdatePatch,
verifier_evidence: EpiphanyEvidenceRecord,
@ -339,7 +352,7 @@ pub async fn apply_thread_epiphany_promote(
patch.evidence.push(verifier_evidence);
let update = state_update_from_thread_patch(expected_revision, patch);
let epiphany_state = apply_epiphany_state_update_to_thread(thread, update).await?;
let epiphany_state = client_visible_live_thread_epiphany_state(thread, epiphany_state).await;
let epiphany_state = thread.client_visible_epiphany_state(epiphany_state).await;
Ok(EpiphanyThreadPromoteApplied::Accepted(
EpiphanyThreadUpdateApplied {
revision: epiphany_state.revision,
@ -350,7 +363,7 @@ pub async fn apply_thread_epiphany_promote(
}
pub async fn apply_thread_epiphany_role_accept(
thread: &CodexThread,
thread: &impl EpiphanyMutationHost,
role_id: ThreadEpiphanyRoleId,
expected_revision: Option<u64>,
binding_id: &str,
@ -391,7 +404,7 @@ pub async fn apply_thread_epiphany_role_accept(
state_update_from_thread_patch(expected_revision, acceptance_update.patch),
)
.await?;
let epiphany_state = client_visible_live_thread_epiphany_state(thread, epiphany_state).await;
let epiphany_state = thread.client_visible_epiphany_state(epiphany_state).await;
Ok(EpiphanyRoleAcceptApplied {
revision: epiphany_state.revision,
@ -406,7 +419,7 @@ pub async fn apply_thread_epiphany_role_accept(
}
pub async fn apply_thread_epiphany_reorient_accept(
thread: &CodexThread,
thread: &impl EpiphanyMutationHost,
expected_revision: Option<u64>,
binding_id: &str,
update_scratch: bool,
@ -451,7 +464,7 @@ pub async fn apply_thread_epiphany_reorient_accept(
let changed_fields = acceptance_update.changed_fields.clone();
let epiphany_state =
apply_epiphany_state_update_to_thread(thread, acceptance_update.state_update).await?;
let epiphany_state = client_visible_live_thread_epiphany_state(thread, epiphany_state).await;
let epiphany_state = thread.client_visible_epiphany_state(epiphany_state).await;
Ok(EpiphanyReorientAcceptApplied {
revision: epiphany_state.revision,
@ -465,7 +478,7 @@ pub async fn apply_thread_epiphany_reorient_accept(
}
pub async fn launch_thread_epiphany_role(
thread: &CodexThread,
thread: &impl EpiphanyMutationHost,
thread_id: &str,
role_id: ThreadEpiphanyRoleId,
expected_revision: Option<u64>,
@ -495,15 +508,16 @@ pub async fn launch_thread_epiphany_role(
}
pub async fn launch_thread_epiphany_job(
thread: &CodexThread,
thread: &impl EpiphanyMutationHost,
launch_request: EpiphanyJobLaunchRequest,
kind: CoreEpiphanyJobKind,
missing_projection_reason: &str,
) -> Result<EpiphanyJobLaunchApplied, CodexErr> {
let changed_fields = epiphany_job_launch_changed_fields();
let launched = launch_epiphany_job_on_thread(thread, launch_request).await?;
let epiphany_state =
client_visible_live_thread_epiphany_state(thread, launched.epiphany_state).await;
let epiphany_state = thread
.client_visible_epiphany_state(launched.epiphany_state)
.await;
let job = map_launched_epiphany_job(
&epiphany_state,
launched.binding_id.as_str(),
@ -521,7 +535,7 @@ pub async fn launch_thread_epiphany_job(
}
pub async fn interrupt_thread_epiphany_job(
thread: &CodexThread,
thread: &impl EpiphanyMutationHost,
expected_revision: Option<u64>,
binding_id: &str,
reason: Option<String>,
@ -536,8 +550,9 @@ pub async fn interrupt_thread_epiphany_job(
},
)
.await?;
let epiphany_state =
client_visible_live_thread_epiphany_state(thread, interrupted.epiphany_state).await;
let epiphany_state = thread
.client_visible_epiphany_state(interrupted.epiphany_state)
.await;
let job = map_interrupted_epiphany_job(&epiphany_state, binding_id);
Ok(EpiphanyJobInterruptApplied {
@ -551,7 +566,7 @@ pub async fn interrupt_thread_epiphany_job(
}
pub async fn launch_thread_epiphany_reorient(
thread: &CodexThread,
thread: &impl EpiphanyMutationHost,
thread_id: &str,
expected_revision: Option<u64>,
max_runtime_seconds: Option<u64>,
@ -589,8 +604,9 @@ pub async fn launch_thread_epiphany_reorient(
);
let changed_fields = epiphany_job_launch_changed_fields();
let launched = launch_epiphany_job_on_thread(thread, launch_request).await?;
let epiphany_state =
client_visible_live_thread_epiphany_state(thread, launched.epiphany_state).await;
let epiphany_state = thread
.client_visible_epiphany_state(launched.epiphany_state)
.await;
let job = map_epiphany_jobs(Some(&epiphany_state), None)
.into_iter()
.find(|job| job.id == EPIPHANY_REORIENT_LAUNCH_BINDING_ID)
@ -667,20 +683,3 @@ fn validate_expected_revision(
}
Ok(())
}
async fn client_visible_live_thread_epiphany_state(
thread: &CodexThread,
fallback: EpiphanyThreadState,
) -> EpiphanyThreadState {
let config = thread.config_snapshot().await;
let codex_home = thread.codex_home().await;
let rollout_path = thread.rollout_path();
let mirror_thread_id = thread_state_mirror_id_from_rollout_path(rollout_path.as_deref());
client_visible_epiphany_state_for_paths(
fallback,
config.cwd.as_path(),
codex_home,
Some(mirror_thread_id.as_str()),
)
.await
}

1
vendor/codex/codex-rs/Cargo.lock generated vendored
View file

@ -5084,7 +5084,6 @@ dependencies = [
"anyhow",
"chrono",
"codex-app-server-protocol",
"codex-core",
"codex-protocol",
"codex-utils-absolute-path",
"epiphany-core",

View file

@ -23,6 +23,7 @@ use epiphany_codex_bridge::retrieve::epiphany_retrieval_state_for_paths;
use tokio::sync::Mutex;
use tracing::warn;
use super::epiphany_thread_host::EpiphanyCodexThreadHost;
use super::epiphany_thread_host::client_visible_live_thread_epiphany_state;
use crate::outgoing_message::ThreadScopedOutgoingMessageSender;
use crate::thread_state::ThreadState;
@ -76,9 +77,8 @@ pub(crate) async fn maybe_run_epiphany_coordinator_automation_for_turn_boundary(
let Some(launch_request) = verdict.launch_request else {
return;
};
let launched = match launch_epiphany_job_on_thread(thread.as_ref(), launch_request)
.await
{
let host = EpiphanyCodexThreadHost::new(thread.as_ref());
let launched = match launch_epiphany_job_on_thread(&host, launch_request).await {
Ok(launched) => launched,
Err(err) => {
warn!(

View file

@ -25,6 +25,7 @@ use std::sync::Arc;
use super::CodexMessageProcessor;
use super::ConnectionRequestId;
use super::ThreadReadViewError;
use super::epiphany_thread_host::EpiphanyCodexThreadHost;
impl CodexMessageProcessor {
async fn load_epiphany_thread(
@ -96,8 +97,9 @@ impl CodexMessageProcessor {
Some(thread) => thread,
None => return,
};
let host = EpiphanyCodexThreadHost::new(loaded_thread.as_ref());
let applied = match launch_thread_epiphany_role(
loaded_thread.as_ref(),
&host,
&thread_id,
role_id,
expected_revision,
@ -170,28 +172,25 @@ impl CodexMessageProcessor {
Some(thread) => thread,
None => return,
};
let applied = match apply_thread_epiphany_role_accept(
loaded_thread.as_ref(),
role_id,
expected_revision,
&binding_id,
)
.await
{
Ok(applied) => applied,
Err(CodexErr::InvalidRequest(message)) => {
self.send_invalid_request_error(request_id, message).await;
return;
}
Err(err) => {
self.send_internal_error(
request_id,
format!("failed to apply Epiphany role finding: {err}"),
)
.await;
return;
}
};
let host = EpiphanyCodexThreadHost::new(loaded_thread.as_ref());
let applied =
match apply_thread_epiphany_role_accept(&host, role_id, expected_revision, &binding_id)
.await
{
Ok(applied) => applied,
Err(CodexErr::InvalidRequest(message)) => {
self.send_invalid_request_error(request_id, message).await;
return;
}
Err(err) => {
self.send_internal_error(
request_id,
format!("failed to apply Epiphany role finding: {err}"),
)
.await;
return;
}
};
let changed_fields = applied.changed_fields;
let epiphany_state = applied.epiphany_state;
@ -259,8 +258,9 @@ impl CodexMessageProcessor {
.snapshot(&thread_id)
.await;
let token_usage_info = loaded_thread.token_usage_info().await;
let host = EpiphanyCodexThreadHost::new(loaded_thread.as_ref());
let applied = match launch_thread_epiphany_reorient(
loaded_thread.as_ref(),
&host,
&thread_id,
expected_revision,
max_runtime_seconds,
@ -334,8 +334,9 @@ impl CodexMessageProcessor {
Some(thread) => thread,
None => return,
};
let host = EpiphanyCodexThreadHost::new(loaded_thread.as_ref());
let applied = match apply_thread_epiphany_reorient_accept(
loaded_thread.as_ref(),
&host,
expected_revision,
binding_id.as_str(),
update_scratch,
@ -439,28 +440,25 @@ impl CodexMessageProcessor {
None => return,
};
let applied = match apply_thread_epiphany_promote(
thread.as_ref(),
expected_revision,
patch,
verifier_evidence,
)
.await
{
Ok(applied) => applied,
Err(CodexErr::InvalidRequest(message)) => {
self.send_invalid_request_error(request_id, message).await;
return;
}
Err(err) => {
self.send_internal_error(
request_id,
format!("failed to promote Epiphany state update: {err}"),
)
.await;
return;
}
};
let host = EpiphanyCodexThreadHost::new(thread.as_ref());
let applied =
match apply_thread_epiphany_promote(&host, expected_revision, patch, verifier_evidence)
.await
{
Ok(applied) => applied,
Err(CodexErr::InvalidRequest(message)) => {
self.send_invalid_request_error(request_id, message).await;
return;
}
Err(err) => {
self.send_internal_error(
request_id,
format!("failed to promote Epiphany state update: {err}"),
)
.await;
return;
}
};
let applied = match applied {
EpiphanyThreadPromoteApplied::Accepted(applied) => applied,
@ -516,22 +514,22 @@ impl CodexMessageProcessor {
None => return,
};
let applied =
match apply_thread_epiphany_update(thread.as_ref(), expected_revision, patch).await {
Ok(applied) => applied,
Err(CodexErr::InvalidRequest(message)) => {
self.send_invalid_request_error(request_id, message).await;
return;
}
Err(err) => {
self.send_internal_error(
request_id,
format!("failed to update Epiphany state for {thread_uuid}: {err}"),
)
.await;
return;
}
};
let host = EpiphanyCodexThreadHost::new(thread.as_ref());
let applied = match apply_thread_epiphany_update(&host, expected_revision, patch).await {
Ok(applied) => applied,
Err(CodexErr::InvalidRequest(message)) => {
self.send_invalid_request_error(request_id, message).await;
return;
}
Err(err) => {
self.send_internal_error(
request_id,
format!("failed to update Epiphany state for {thread_uuid}: {err}"),
)
.await;
return;
}
};
let changed_fields = applied.changed_fields;
let epiphany_state = applied.epiphany_state;
let response = ThreadEpiphanyUpdateResponse {
@ -576,8 +574,9 @@ impl CodexMessageProcessor {
None => return,
};
let host = EpiphanyCodexThreadHost::new(thread.as_ref());
let applied = match launch_thread_epiphany_job(
thread.as_ref(),
&host,
build_epiphany_job_launch_request(
expected_revision,
binding_id.clone(),
@ -651,8 +650,9 @@ impl CodexMessageProcessor {
None => return,
};
let host = EpiphanyCodexThreadHost::new(thread.as_ref());
let applied = match interrupt_thread_epiphany_job(
thread.as_ref(),
&host,
expected_revision,
&binding_id,
reason,

View file

@ -3,11 +3,51 @@ use std::path::Path;
use codex_core::CodexThread;
use codex_core::RolloutRecorder;
use codex_core::latest_epiphany_state_from_rollout_items;
use codex_protocol::error::CodexErr;
use codex_protocol::protocol::EpiphanyThreadState;
use codex_protocol::protocol::InitialHistory;
use epiphany_codex_bridge::mutation_service::EpiphanyMutationHost;
use epiphany_codex_bridge::state::client_visible_epiphany_state_for_paths;
use epiphany_codex_bridge::state::thread_state_mirror_id_from_rollout_path;
pub(super) struct EpiphanyCodexThreadHost<'a> {
thread: &'a CodexThread,
}
impl<'a> EpiphanyCodexThreadHost<'a> {
pub(super) fn new(thread: &'a CodexThread) -> Self {
Self { thread }
}
}
impl EpiphanyMutationHost for EpiphanyCodexThreadHost<'_> {
async fn epiphany_state(&self) -> Option<EpiphanyThreadState> {
self.thread.epiphany_state().await
}
async fn epiphany_reference_turn_id(&self) -> Option<String> {
self.thread.epiphany_reference_turn_id().await
}
async fn epiphany_persist_state(
&self,
next_state: EpiphanyThreadState,
) -> Result<EpiphanyThreadState, CodexErr> {
self.thread.epiphany_persist_state(next_state).await
}
async fn epiphany_runtime_spine_store_path(&self) -> std::path::PathBuf {
self.thread.epiphany_runtime_spine_store_path().await
}
async fn client_visible_epiphany_state(
&self,
fallback: EpiphanyThreadState,
) -> EpiphanyThreadState {
client_visible_live_thread_epiphany_state(self.thread, fallback).await
}
}
pub(super) async fn load_epiphany_state_from_rollout_path(
rollout_path: &Path,
) -> std::result::Result<Option<EpiphanyThreadState>, String> {