This repository has been archived on 2026-10-29. You can view files and clone it, but you cannot make any changes to its state, such as pushing and creating new issues, pull requests or comments.
Epiphany/epiphany-openai-runtime/src/lib.rs
2026-05-18 04:52:01 +01:00

998 lines
38 KiB
Rust

use std::path::Path;
use std::path::PathBuf;
use anyhow::Context;
use anyhow::Result;
use anyhow::anyhow;
use chrono::SecondsFormat;
use epiphany_core::EpiphanyRuntimeReorientWorkerResult;
use epiphany_core::EpiphanyRuntimeRoleWorkerResult;
use epiphany_core::EpiphanyRuntimeWorkerLaunchRequest;
use epiphany_core::EpiphanyWorkerLaunchDocument;
use epiphany_core::RuntimeSpineEventOptions;
use epiphany_core::RuntimeSpineInitOptions;
use epiphany_core::RuntimeSpineJobOptions;
use epiphany_core::RuntimeSpineJobResultOptions;
use epiphany_core::RuntimeSpineSessionOptions;
use epiphany_core::append_runtime_event;
use epiphany_core::complete_runtime_job;
use epiphany_core::create_runtime_job;
use epiphany_core::ensure_runtime_session;
use epiphany_core::initialize_runtime_spine;
use epiphany_core::put_runtime_reorient_worker_result;
use epiphany_core::put_runtime_role_worker_result;
use epiphany_core::runtime_spine_cache;
use epiphany_core::runtime_spine_status;
use epiphany_openai_adapter::EpiphanyOpenAiAdapterStatus;
use epiphany_openai_adapter::EpiphanyOpenAiInputItem;
use epiphany_openai_adapter::EpiphanyOpenAiModelRequest;
use epiphany_openai_adapter::EpiphanyOpenAiStreamEvent;
use epiphany_openai_adapter::EpiphanyOpenAiStreamPayload;
use epiphany_openai_codex_spine::EpiphanyCodexOpenAiTransport;
use epiphany_openai_codex_spine::auth_manager;
pub use epiphany_openai_codex_spine::default_codex_home;
use epiphany_openai_codex_spine::status_from_auth_manager;
use serde::de::DeserializeOwned;
pub const OPENAI_RUNTIME_ROLE: &str = "openai-model-adapter";
pub const OPENAI_RUNTIME_SOURCE: &str = "epiphany-openai-runtime";
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EpiphanyOpenAiRuntimeOptions {
pub store_path: PathBuf,
pub codex_home: PathBuf,
pub session_id: String,
pub job_id: String,
pub objective: String,
pub coordinator_note: String,
pub default_model: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EpiphanyOpenAiRuntimeRunSummary {
pub store: String,
pub session_id: String,
pub job_id: String,
pub request_id: String,
pub event_count: usize,
pub verdict: String,
pub result_id: String,
pub receipt_id: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EpiphanyWorkerRuntimeOptions {
pub store_path: PathBuf,
pub codex_home: PathBuf,
pub job_id: String,
pub model: String,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EpiphanyWorkerRuntimeRunSummary {
pub store: String,
pub job_id: String,
pub binding_id: String,
pub role: String,
pub request_id: String,
pub openai_result_id: String,
pub worker_result_id: String,
pub verdict: String,
}
pub async fn run_openai_model_turn(
options: EpiphanyOpenAiRuntimeOptions,
request: EpiphanyOpenAiModelRequest,
) -> Result<EpiphanyOpenAiRuntimeRunSummary> {
ensure_openai_runtime_ready(&options)?;
let auth_manager = auth_manager(options.codex_home.clone());
let status = status_from_auth_manager(&auth_manager, options.default_model.clone(), true).await;
store_openai_status(&options.store_path, &status)?;
store_openai_request(&options.store_path, &request)?;
ensure_runtime_session(
&options.store_path,
RuntimeSpineSessionOptions {
session_id: options.session_id.clone(),
objective: options.objective.clone(),
created_at: now(),
coordinator_note: options.coordinator_note.clone(),
},
)?;
create_runtime_job(
&options.store_path,
RuntimeSpineJobOptions {
job_id: options.job_id.clone(),
session_id: options.session_id.clone(),
role: OPENAI_RUNTIME_ROLE.to_string(),
created_at: now(),
summary: format!("OpenAI model request {}", request.request_id),
artifact_refs: Vec::new(),
},
)?;
append_runtime_event(
&options.store_path,
RuntimeSpineEventOptions {
event_id: format!("event-openai-started-{}", options.job_id),
occurred_at: now(),
event_type: "openai.model_turn.started".to_string(),
source: OPENAI_RUNTIME_SOURCE.to_string(),
session_id: Some(options.session_id.clone()),
job_id: Some(options.job_id.clone()),
summary: format!("Started typed OpenAI request {}.", request.request_id),
},
)?;
let transport = EpiphanyCodexOpenAiTransport::openai(auth_manager);
let events = match transport.collect_model_events(request.clone()).await {
Ok(events) => events,
Err(err) => {
let failure = EpiphanyOpenAiStreamEvent {
schema_id: epiphany_openai_adapter::OPENAI_ADAPTER_EVENT_SCHEMA_ID.to_string(),
request_id: request.request_id.clone(),
sequence: 0,
payload: EpiphanyOpenAiStreamPayload::Failed {
message: err.to_string(),
},
};
vec![failure]
}
};
record_openai_events(&options.store_path, &options, &request, &events)
}
pub async fn run_worker_launch(
options: EpiphanyWorkerRuntimeOptions,
) -> Result<EpiphanyWorkerRuntimeRunSummary> {
let launch_request = load_worker_launch_request(&options.store_path, &options.job_id)?;
let model_request = build_worker_model_request(&launch_request, &options.model)?;
let openai_options = EpiphanyOpenAiRuntimeOptions {
store_path: options.store_path.clone(),
codex_home: options.codex_home,
session_id: format!("openai-worker-session-{}", launch_request.binding_id),
job_id: format!("openai-worker-{}", launch_request.job_id),
objective: format!(
"Run Epiphany worker {} for {}",
launch_request.job_id, launch_request.binding_id
),
coordinator_note: "Native worker runtime route; Codex is auth/model transport only."
.to_string(),
default_model: Some(options.model),
};
let openai_summary =
run_openai_model_turn(openai_options.clone(), model_request.clone()).await?;
let assistant_text =
assistant_text_from_openai_events(&openai_options.store_path, &model_request.request_id)?;
let worker_result = complete_worker_job_from_assistant_text(
&openai_options.store_path,
&launch_request,
&model_request.request_id,
&openai_summary,
&assistant_text,
)?;
Ok(EpiphanyWorkerRuntimeRunSummary {
store: openai_options.store_path.display().to_string(),
job_id: launch_request.job_id,
binding_id: launch_request.binding_id,
role: launch_request.role,
request_id: model_request.request_id,
openai_result_id: openai_summary.result_id,
worker_result_id: worker_result.result_id,
verdict: worker_result.verdict,
})
}
pub fn record_openai_events(
store_path: impl AsRef<Path>,
options: &EpiphanyOpenAiRuntimeOptions,
request: &EpiphanyOpenAiModelRequest,
events: &[EpiphanyOpenAiStreamEvent],
) -> Result<EpiphanyOpenAiRuntimeRunSummary> {
let store_path = store_path.as_ref();
let mut receipt = None;
let mut failure = None;
{
let mut cache = runtime_spine_cache(store_path)?;
cache.pull_all_backing_stores()?;
for event in events {
let key = openai_event_key(&event.request_id, event.sequence);
cache.put(key, event)?;
match &event.payload {
EpiphanyOpenAiStreamPayload::Completed { receipt: completed } => {
cache.put(openai_receipt_key(&completed.request_id), completed)?;
receipt = Some(completed.clone());
}
EpiphanyOpenAiStreamPayload::Failed { message } => {
failure = Some(message.clone());
}
_ => {}
}
}
}
for event in events {
append_runtime_event(
store_path,
RuntimeSpineEventOptions {
event_id: format!("event-openai-{}-{}", options.job_id, event.sequence),
occurred_at: now(),
event_type: openai_event_type(event).to_string(),
source: OPENAI_RUNTIME_SOURCE.to_string(),
session_id: Some(options.session_id.clone()),
job_id: Some(options.job_id.clone()),
summary: openai_event_summary(event),
},
)?;
}
let verdict = if failure.is_some() || receipt.is_none() {
"failed"
} else {
"pass"
};
let summary = if let Some(message) = failure {
format!(
"OpenAI model request {} failed: {message}",
request.request_id
)
} else if let Some(receipt) = &receipt {
format!(
"OpenAI model request {} completed through {}.",
request.request_id,
receipt
.transport
.clone()
.unwrap_or_else(|| "unknown transport".to_string())
)
} else {
format!(
"OpenAI model request {} ended without a terminal receipt.",
request.request_id
)
};
let result_id = format!("result-openai-{}", options.job_id);
complete_runtime_job(
store_path,
RuntimeSpineJobResultOptions {
result_id: result_id.clone(),
job_id: options.job_id.clone(),
completed_at: now(),
verdict: verdict.to_string(),
summary,
next_safe_move: "Review typed OpenAI receipt before accepting downstream state."
.to_string(),
evidence_refs: Vec::new(),
artifact_refs: Vec::new(),
},
)?;
Ok(EpiphanyOpenAiRuntimeRunSummary {
store: store_path.display().to_string(),
session_id: options.session_id.clone(),
job_id: options.job_id.clone(),
request_id: request.request_id.clone(),
event_count: events.len(),
verdict: verdict.to_string(),
result_id,
receipt_id: receipt.map(|item| openai_receipt_key(&item.request_id)),
})
}
pub fn load_worker_launch_request(
store_path: impl AsRef<Path>,
job_id: &str,
) -> Result<EpiphanyRuntimeWorkerLaunchRequest> {
let mut cache = runtime_spine_cache(store_path)?;
cache.pull_all_backing_stores()?;
cache
.get::<EpiphanyRuntimeWorkerLaunchRequest>(job_id)?
.ok_or_else(|| anyhow!("runtime worker launch request {job_id:?} does not exist"))
}
pub fn build_worker_model_request(
launch_request: &EpiphanyRuntimeWorkerLaunchRequest,
model: &str,
) -> Result<EpiphanyOpenAiModelRequest> {
let launch_document = launch_request.launch_document()?;
let request_id = format!(
"worker-{}-{}",
sanitize_request_id(&launch_request.job_id),
chrono::Utc::now().timestamp_millis()
);
let launch_document_text = serde_json::to_string_pretty(&launch_document)
.context("failed to render worker launch document for model input")?;
let mut request = EpiphanyOpenAiModelRequest::new(
request_id,
format!("worker-{}", launch_request.binding_id),
model.to_string(),
worker_instructions(launch_request, &launch_document),
);
request.input.push(EpiphanyOpenAiInputItem::UserText {
text: format!(
"Execute this Epiphany worker launch document.\n\n```json\n{launch_document_text}\n```"
),
});
request.output_contract_id = Some(launch_request.output_contract_id.clone());
Ok(request)
}
pub fn complete_worker_job_from_assistant_text(
store_path: impl AsRef<Path>,
launch_request: &EpiphanyRuntimeWorkerLaunchRequest,
openai_request_id: &str,
openai_summary: &EpiphanyOpenAiRuntimeRunSummary,
assistant_text: &str,
) -> Result<epiphany_core::EpiphanyRuntimeJobResult> {
let launch_document = launch_request.launch_document()?;
let parsed = parse_worker_result_ingress(&launch_document, assistant_text).ok();
let openai_failed = openai_summary.verdict != "pass";
let verdict = if openai_failed {
"failed".to_string()
} else {
parsed
.as_ref()
.and_then(WorkerResultIngress::verdict)
.unwrap_or_else(|| "completed".to_string())
};
let summary = if openai_failed {
format!("Worker model request {openai_request_id} failed before producing usable output.")
} else {
parsed
.as_ref()
.and_then(WorkerResultIngress::summary)
.unwrap_or_else(|| "Worker completed without a structured summary.".to_string())
};
let next_safe_move = parsed
.as_ref()
.and_then(WorkerResultIngress::next_safe_move)
.unwrap_or_else(|| {
"Review the typed worker runtime result before accepting state.".to_string()
});
let mut evidence_refs = parsed
.as_ref()
.map(WorkerResultIngress::evidence_ids)
.unwrap_or_default();
evidence_refs.push(format!("openai-request:{openai_request_id}"));
let mut artifact_refs = parsed
.as_ref()
.map(WorkerResultIngress::artifact_refs)
.unwrap_or_default();
artifact_refs.push(format!("openai-result:{}", openai_summary.result_id));
let result_id = format!("result-worker-{}", launch_request.job_id);
if let Some(parsed) = parsed.as_ref() {
match (&launch_document, parsed) {
(EpiphanyWorkerLaunchDocument::Role(document), WorkerResultIngress::Role(parsed)) => {
let typed_result = role_worker_result_from_ingress(
launch_request,
&document.role_id,
&result_id,
parsed,
artifact_refs.clone(),
);
put_runtime_role_worker_result(store_path.as_ref(), &typed_result)?;
}
(EpiphanyWorkerLaunchDocument::Reorient(_), WorkerResultIngress::Reorient(parsed)) => {
let typed_result = reorient_worker_result_from_ingress(
launch_request,
&result_id,
parsed,
artifact_refs.clone(),
);
put_runtime_reorient_worker_result(store_path.as_ref(), &typed_result)?;
}
_ => {
return Err(anyhow!(
"worker launch document and parsed result kind diverged"
));
}
}
}
complete_runtime_job(
store_path,
RuntimeSpineJobResultOptions {
result_id,
job_id: launch_request.job_id.clone(),
completed_at: now(),
verdict,
summary,
next_safe_move,
evidence_refs,
artifact_refs,
},
)
}
pub fn ensure_openai_runtime_ready(options: &EpiphanyOpenAiRuntimeOptions) -> Result<()> {
let status = runtime_spine_status(&options.store_path)?;
if status.present {
return Ok(());
}
initialize_runtime_spine(
&options.store_path,
RuntimeSpineInitOptions {
runtime_id: "epiphany-openai-runtime".to_string(),
display_name: "Epiphany OpenAI Runtime".to_string(),
created_at: now(),
},
)?;
Ok(())
}
pub fn store_openai_status(
store_path: impl AsRef<Path>,
status: &EpiphanyOpenAiAdapterStatus,
) -> Result<()> {
let mut cache = runtime_spine_cache(store_path)?;
cache.pull_all_backing_stores()?;
cache.put(status.adapter_id.clone(), status)?;
Ok(())
}
pub fn store_openai_request(
store_path: impl AsRef<Path>,
request: &EpiphanyOpenAiModelRequest,
) -> Result<()> {
let mut cache = runtime_spine_cache(store_path)?;
cache.pull_all_backing_stores()?;
cache.put(request.request_id.clone(), request)?;
Ok(())
}
pub fn assistant_text_from_openai_events(
store_path: impl AsRef<Path>,
request_id: &str,
) -> Result<String> {
let mut cache = runtime_spine_cache(store_path)?;
cache.pull_all_backing_stores()?;
let mut events = cache
.get_all::<EpiphanyOpenAiStreamEvent>()?
.into_iter()
.filter(|event| event.request_id == request_id)
.collect::<Vec<_>>();
events.sort_by_key(|event| event.sequence);
let mut text = String::new();
for event in events {
if let EpiphanyOpenAiStreamPayload::TextDelta { text: delta } = event.payload {
text.push_str(&delta);
}
}
Ok(text)
}
pub fn default_options(
store_path: PathBuf,
codex_home: PathBuf,
request: &EpiphanyOpenAiModelRequest,
) -> EpiphanyOpenAiRuntimeOptions {
EpiphanyOpenAiRuntimeOptions {
store_path,
codex_home,
session_id: format!("openai-session-{}", request.conversation_id),
job_id: format!("openai-job-{}", request.request_id),
objective: format!("Run typed OpenAI model request {}", request.request_id),
coordinator_note: "Native OpenAI runtime route; Codex is auth/model transport only."
.to_string(),
default_model: Some(request.model.clone()),
}
}
pub fn openai_event_key(request_id: &str, sequence: u64) -> String {
format!("{request_id}:{sequence:08}")
}
pub fn openai_receipt_key(request_id: &str) -> String {
request_id.to_string()
}
fn openai_event_type(event: &EpiphanyOpenAiStreamEvent) -> &'static str {
match event.payload {
EpiphanyOpenAiStreamPayload::TextDelta { .. } => "openai.model_turn.text_delta",
EpiphanyOpenAiStreamPayload::ReasoningDelta { .. } => "openai.model_turn.reasoning_delta",
EpiphanyOpenAiStreamPayload::ToolCall { .. } => "openai.model_turn.tool_call",
EpiphanyOpenAiStreamPayload::Completed { .. } => "openai.model_turn.completed",
EpiphanyOpenAiStreamPayload::Failed { .. } => "openai.model_turn.failed",
}
}
fn openai_event_summary(event: &EpiphanyOpenAiStreamEvent) -> String {
match &event.payload {
EpiphanyOpenAiStreamPayload::TextDelta { text } => {
format!(
"Text delta for {} ({} chars).",
event.request_id,
text.len()
)
}
EpiphanyOpenAiStreamPayload::ReasoningDelta { text } => {
format!(
"Reasoning delta for {} ({} chars).",
event.request_id,
text.len()
)
}
EpiphanyOpenAiStreamPayload::ToolCall { name, .. } => {
format!("Tool call {name} for {}.", event.request_id)
}
EpiphanyOpenAiStreamPayload::Completed { receipt } => {
format!(
"OpenAI request {} completed with response {:?}.",
event.request_id, receipt.response_id
)
}
EpiphanyOpenAiStreamPayload::Failed { message } => {
format!("OpenAI request {} failed: {message}", event.request_id)
}
}
}
fn worker_instructions(
launch_request: &EpiphanyRuntimeWorkerLaunchRequest,
launch_document: &EpiphanyWorkerLaunchDocument,
) -> String {
let output_contract = worker_output_contract_text(launch_document);
format!(
"{}\n\nReturn only one JSON object. No Markdown, no commentary.\n\n{}",
launch_request.instruction, output_contract
)
}
fn worker_output_contract_text(document: &EpiphanyWorkerLaunchDocument) -> &'static str {
match document {
EpiphanyWorkerLaunchDocument::Role(_) => {
"Required role-result fields: roleId, verdict, summary, nextSafeMove, filesInspected. Modeling and Imagination workers must include their required statePatch. Modeling workers must put proposed graph/memory changes in memoryPatchCandidates, never statePatch.graphs. Use arrays for frontierNodeIds, evidenceIds, openQuestions, evidenceGaps, risks, artifactRefs, and memoryPatchCandidates when present."
}
EpiphanyWorkerLaunchDocument::Reorient(_) => {
"Required reorient-result fields: mode, summary, nextSafeMove. Include checkpointStillValid, filesInspected, frontierNodeIds, evidenceIds, openQuestions, and continuityRisks when present."
}
}
}
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(rename_all = "camelCase", default)]
struct RoleWorkerResultIngress {
role_id: Option<String>,
verdict: Option<String>,
summary: Option<String>,
next_safe_move: Option<String>,
checkpoint_summary: Option<String>,
scratch_summary: Option<String>,
files_inspected: Vec<String>,
frontier_node_ids: Vec<String>,
evidence_ids: Vec<String>,
artifact_refs: Vec<String>,
open_questions: Vec<String>,
evidence_gaps: Vec<String>,
risks: Vec<String>,
state_patch: Option<epiphany_core::EpiphanyRoleStatePatchDocument>,
self_patch: Option<epiphany_core::AgentSelfPatch>,
memory_patch_candidates: Vec<epiphany_core::EpiphanyMemoryPatchCandidate>,
}
#[derive(Debug, Clone, Default, serde::Deserialize)]
#[serde(rename_all = "camelCase", default)]
struct ReorientWorkerResultIngress {
mode: Option<String>,
summary: Option<String>,
next_safe_move: Option<String>,
checkpoint_still_valid: Option<bool>,
files_inspected: Vec<String>,
frontier_node_ids: Vec<String>,
evidence_ids: Vec<String>,
artifact_refs: Vec<String>,
open_questions: Vec<String>,
continuity_risks: Vec<String>,
}
#[derive(Debug, Clone)]
enum WorkerResultIngress {
Role(RoleWorkerResultIngress),
Reorient(ReorientWorkerResultIngress),
}
impl WorkerResultIngress {
fn verdict(&self) -> Option<String> {
match self {
WorkerResultIngress::Role(result) => clean_optional_string(result.verdict.as_deref()),
WorkerResultIngress::Reorient(result) => clean_optional_string(result.mode.as_deref()),
}
}
fn summary(&self) -> Option<String> {
match self {
WorkerResultIngress::Role(result) => clean_optional_string(result.summary.as_deref()),
WorkerResultIngress::Reorient(result) => {
clean_optional_string(result.summary.as_deref())
}
}
}
fn next_safe_move(&self) -> Option<String> {
match self {
WorkerResultIngress::Role(result) => {
clean_optional_string(result.next_safe_move.as_deref())
}
WorkerResultIngress::Reorient(result) => {
clean_optional_string(result.next_safe_move.as_deref())
}
}
}
fn evidence_ids(&self) -> Vec<String> {
match self {
WorkerResultIngress::Role(result) => clean_string_vec(&result.evidence_ids),
WorkerResultIngress::Reorient(result) => clean_string_vec(&result.evidence_ids),
}
}
fn artifact_refs(&self) -> Vec<String> {
match self {
WorkerResultIngress::Role(result) => clean_string_vec(&result.artifact_refs),
WorkerResultIngress::Reorient(result) => clean_string_vec(&result.artifact_refs),
}
}
}
fn parse_worker_result_ingress(
document: &EpiphanyWorkerLaunchDocument,
assistant_text: &str,
) -> Result<WorkerResultIngress> {
match document {
EpiphanyWorkerLaunchDocument::Role(_) => {
parse_assistant_json::<RoleWorkerResultIngress>(assistant_text)
.map(WorkerResultIngress::Role)
}
EpiphanyWorkerLaunchDocument::Reorient(_) => {
parse_assistant_json::<ReorientWorkerResultIngress>(assistant_text)
.map(WorkerResultIngress::Reorient)
}
}
}
fn role_worker_result_from_ingress(
launch_request: &EpiphanyRuntimeWorkerLaunchRequest,
role_id: &str,
result_id: &str,
result: &RoleWorkerResultIngress,
artifact_refs: Vec<String>,
) -> EpiphanyRuntimeRoleWorkerResult {
let (state_patch_msgpack, state_patch_error) =
encode_optional_document(&result.state_patch, "statePatch");
let (self_patch_msgpack, self_patch_error) =
encode_optional_document(&result.self_patch, "selfPatch");
let (memory_patch_candidates_msgpack, memory_patch_candidates_error) =
encode_optional_vec_document(&result.memory_patch_candidates, "memoryPatchCandidates");
EpiphanyRuntimeRoleWorkerResult {
schema_version: epiphany_core::RUNTIME_ROLE_WORKER_RESULT_SCHEMA_VERSION.to_string(),
result_id: result_id.to_string(),
job_id: launch_request.job_id.clone(),
role_id: clean_optional_string(result.role_id.as_deref())
.unwrap_or_else(|| role_id.to_string()),
verdict: clean_optional_string(result.verdict.as_deref())
.unwrap_or_else(|| "completed".to_string()),
summary: clean_optional_string(result.summary.as_deref())
.unwrap_or_else(|| "Worker completed without a structured summary.".to_string()),
next_safe_move: clean_optional_string(result.next_safe_move.as_deref()).unwrap_or_else(
|| "Review the typed worker runtime result before accepting state.".to_string(),
),
checkpoint_summary: clean_optional_string(result.checkpoint_summary.as_deref()),
scratch_summary: clean_optional_string(result.scratch_summary.as_deref()),
files_inspected: clean_string_vec(&result.files_inspected),
frontier_node_ids: clean_string_vec(&result.frontier_node_ids),
evidence_ids: clean_string_vec(&result.evidence_ids),
artifact_refs,
open_questions: clean_string_vec(&result.open_questions),
evidence_gaps: clean_string_vec(&result.evidence_gaps),
risks: clean_string_vec(&result.risks),
state_patch_msgpack,
self_patch_msgpack,
item_error: merge_optional_errors(
merge_optional_errors(state_patch_error, self_patch_error),
memory_patch_candidates_error,
),
metadata: std::collections::BTreeMap::new(),
memory_patch_candidates_msgpack,
}
}
fn reorient_worker_result_from_ingress(
launch_request: &EpiphanyRuntimeWorkerLaunchRequest,
result_id: &str,
result: &ReorientWorkerResultIngress,
artifact_refs: Vec<String>,
) -> EpiphanyRuntimeReorientWorkerResult {
EpiphanyRuntimeReorientWorkerResult {
schema_version: epiphany_core::RUNTIME_REORIENT_WORKER_RESULT_SCHEMA_VERSION.to_string(),
result_id: result_id.to_string(),
job_id: launch_request.job_id.clone(),
mode: clean_optional_string(result.mode.as_deref())
.unwrap_or_else(|| "regather".to_string()),
summary: clean_optional_string(result.summary.as_deref()).unwrap_or_else(|| {
"Reorient worker completed without a structured summary.".to_string()
}),
next_safe_move: clean_optional_string(result.next_safe_move.as_deref()).unwrap_or_else(
|| "Review the typed reorient runtime result before accepting state.".to_string(),
),
checkpoint_still_valid: result.checkpoint_still_valid,
files_inspected: clean_string_vec(&result.files_inspected),
frontier_node_ids: clean_string_vec(&result.frontier_node_ids),
evidence_ids: clean_string_vec(&result.evidence_ids),
artifact_refs,
open_questions: clean_string_vec(&result.open_questions),
continuity_risks: clean_string_vec(&result.continuity_risks),
item_error: None,
metadata: std::collections::BTreeMap::new(),
}
}
fn encode_optional_document<T>(value: &Option<T>, key: &str) -> (Option<Vec<u8>>, Option<String>)
where
T: serde::Serialize,
{
let Some(document) = value else {
return (None, None);
};
match rmp_serde::to_vec_named(document) {
Ok(payload) => (Some(payload), None),
Err(err) => (None, Some(format!("failed to encode {key}: {err}"))),
}
}
fn encode_optional_vec_document<T>(value: &[T], key: &str) -> (Option<Vec<u8>>, Option<String>)
where
T: serde::Serialize,
{
if value.is_empty() {
return (None, None);
}
match rmp_serde::to_vec_named(value) {
Ok(payload) => (Some(payload), None),
Err(err) => (None, Some(format!("failed to encode {key}: {err}"))),
}
}
fn merge_optional_errors(left: Option<String>, right: Option<String>) -> Option<String> {
match (left, right) {
(Some(left), Some(right)) => Some(format!("{left}; {right}")),
(Some(left), None) => Some(left),
(None, Some(right)) => Some(right),
(None, None) => None,
}
}
fn parse_assistant_json<T>(text: &str) -> Result<T>
where
T: DeserializeOwned,
{
let trimmed = text.trim();
let candidate = trimmed
.strip_prefix("```json")
.and_then(|value| value.strip_suffix("```"))
.or_else(|| {
trimmed
.strip_prefix("```")
.and_then(|value| value.strip_suffix("```"))
})
.unwrap_or(trimmed)
.trim();
serde_json::from_str(candidate).context("assistant text was not typed worker-result JSON")
}
fn clean_optional_string(value: Option<&str>) -> Option<String> {
value
.map(str::trim)
.filter(|value| !value.is_empty())
.map(ToString::to_string)
}
fn clean_string_vec(values: &[String]) -> Vec<String> {
values
.iter()
.map(|value| value.trim())
.filter(|value| !value.is_empty())
.map(ToString::to_string)
.collect()
}
fn sanitize_request_id(value: &str) -> String {
value
.chars()
.map(|ch| {
if ch.is_ascii_alphanumeric() || ch == '-' || ch == '_' {
ch
} else {
'-'
}
})
.collect()
}
fn now() -> String {
chrono::Utc::now().to_rfc3339_opts(SecondsFormat::Secs, true)
}
#[cfg(test)]
mod tests {
use super::*;
use epiphany_core::EpiphanyWorkerLaunchDocument;
use epiphany_core::RuntimeSpineHeartbeatJobOptions;
use epiphany_core::open_runtime_spine_heartbeat_job;
use epiphany_core::runtime_job_snapshot;
use epiphany_openai_adapter::EpiphanyOpenAiModelReceipt;
use tempfile::tempdir;
#[test]
fn records_typed_openai_documents_in_runtime_store() -> Result<()> {
let temp = tempdir()?;
let store = temp.path().join("runtime.msgpack");
let request = EpiphanyOpenAiModelRequest::new(
"req-1",
"conversation-1",
"gpt-5.4",
"Answer plainly.",
);
let options = default_options(store.clone(), PathBuf::from(".codex"), &request);
ensure_openai_runtime_ready(&options)?;
ensure_runtime_session(
&store,
RuntimeSpineSessionOptions {
session_id: options.session_id.clone(),
objective: options.objective.clone(),
created_at: now(),
coordinator_note: options.coordinator_note.clone(),
},
)?;
create_runtime_job(
&store,
RuntimeSpineJobOptions {
job_id: options.job_id.clone(),
session_id: options.session_id.clone(),
role: OPENAI_RUNTIME_ROLE.to_string(),
created_at: now(),
summary: "test job".to_string(),
artifact_refs: Vec::new(),
},
)?;
store_openai_request(&store, &request)?;
let mut receipt = EpiphanyOpenAiModelReceipt::new("req-1", "gpt-5.4");
receipt.response_id = Some("resp-1".to_string());
receipt.transport = Some("test".to_string());
let events = vec![EpiphanyOpenAiStreamEvent {
schema_id: epiphany_openai_adapter::OPENAI_ADAPTER_EVENT_SCHEMA_ID.to_string(),
request_id: "req-1".to_string(),
sequence: 0,
payload: EpiphanyOpenAiStreamPayload::Completed { receipt },
}];
let summary = record_openai_events(&store, &options, &request, &events)?;
assert_eq!(summary.verdict, "pass");
assert_eq!(assistant_text_from_openai_events(&store, "req-1")?, "");
let mut cache = runtime_spine_cache(&store)?;
cache.pull_all_backing_stores()?;
assert!(cache.get::<EpiphanyOpenAiModelRequest>("req-1")?.is_some());
assert!(
cache
.get::<EpiphanyOpenAiStreamEvent>("req-1:00000000")?
.is_some()
);
assert!(cache.get::<EpiphanyOpenAiModelReceipt>("req-1")?.is_some());
assert_eq!(
runtime_job_snapshot(&store, &options.job_id)?
.expect("snapshot")
.job
.status,
epiphany_core::EpiphanyRuntimeJobStatus::Completed
);
Ok(())
}
#[test]
fn completes_worker_job_from_model_json_without_codex_worker_runtime() -> Result<()> {
let temp = tempdir()?;
let store = temp.path().join("runtime.msgpack");
open_runtime_spine_heartbeat_job(
&store,
RuntimeSpineHeartbeatJobOptions {
runtime_id: "epiphany-test".to_string(),
display_name: "Epiphany Test".to_string(),
session_id: "epiphany-main".to_string(),
objective: "Run typed worker.".to_string(),
coordinator_note: "test".to_string(),
job_id: "worker-job-1".to_string(),
role: "modeling".to_string(),
binding_id: "modeling-checkpoint-worker".to_string(),
authority_scope: "epiphany.role.modeling".to_string(),
instruction: "Return the required role-result JSON.".to_string(),
launch_document: EpiphanyWorkerLaunchDocument::Role(
epiphany_core::EpiphanyRoleWorkerLaunchDocument {
thread_id: "thread-1".to_string(),
role_id: "modeling".to_string(),
state_revision: 1,
objective: Some("Map the machine.".to_string()),
active_subgoal_id: None,
active_subgoals: Vec::new(),
active_graph_node_ids: Vec::new(),
memory_context: None,
investigation_checkpoint: None,
scratch: None,
invariants: Vec::new(),
graphs: None,
recent_evidence: Vec::new(),
recent_observations: Vec::new(),
graph_frontier: None,
graph_checkpoint: None,
planning: None,
churn: None,
},
),
output_contract_id: epiphany_core::ROLE_WORKER_OUTPUT_CONTRACT_ID.to_string(),
created_at: now(),
},
)?;
let launch_request = load_worker_launch_request(&store, "worker-job-1")?;
let model_request = build_worker_model_request(&launch_request, "gpt-5.4")?;
assert_eq!(
model_request.output_contract_id.as_deref(),
Some(epiphany_core::ROLE_WORKER_OUTPUT_CONTRACT_ID)
);
let openai_summary = EpiphanyOpenAiRuntimeRunSummary {
store: store.display().to_string(),
session_id: "openai-worker-session-modeling-checkpoint-worker".to_string(),
job_id: "openai-worker-worker-job-1".to_string(),
request_id: model_request.request_id.clone(),
event_count: 2,
verdict: "pass".to_string(),
result_id: "result-openai-worker-worker-job-1".to_string(),
receipt_id: Some(model_request.request_id.clone()),
};
let result = complete_worker_job_from_assistant_text(
&store,
&launch_request,
&model_request.request_id,
&openai_summary,
r#"{"roleId":"modeling","verdict":"checkpoint-ready","summary":"Mapped.","nextSafeMove":"Review the patch.","filesInspected":["src/lib.rs"],"evidenceIds":["ev-1"],"artifactRefs":["artifact:model"],"statePatch":{"scratch":{"summary":"Keep the machine mapped."}},"selfPatch":{"reason":"typed nested document"},"memoryPatchCandidates":[{"id":"mempatch-auth-spine","profile":"repo_architecture","status":"proposed","proposedNodes":[{"id":"memnode-auth-spine","domainId":"memdom-repo","profile":"repo_architecture","kind":"module","title":"Auth spine","claim":"Codex remains responsible for OpenAI authentication.","question":"","tension":"","actionImplication":"","lifecycle":"proposed"}],"reasons":["Modeling proposes typed graph growth without full graph cargo."]}]} "#,
)?;
assert_eq!(result.job_id, "worker-job-1");
assert_eq!(result.verdict, "checkpoint-ready");
assert_eq!(result.summary, "Mapped.");
assert_eq!(result.next_safe_move, "Review the patch.");
assert!(result.evidence_refs.contains(&"ev-1".to_string()));
let typed_result = epiphany_core::runtime_role_worker_result(&store, "worker-job-1")?
.expect("typed role worker result");
assert_eq!(typed_result.verdict, "checkpoint-ready");
assert_eq!(typed_result.files_inspected, vec!["src/lib.rs".to_string()]);
assert_eq!(typed_result.artifact_refs, result.artifact_refs);
assert!(typed_result.item_error.is_none());
assert_eq!(
typed_result
.state_patch()?
.expect("state patch")
.scratch
.expect("scratch patch")
.summary,
Some("Keep the machine mapped.".to_string())
);
assert_eq!(
typed_result.self_patch()?.expect("self patch").reason,
Some("typed nested document".to_string())
);
let memory_candidates = typed_result.memory_patch_candidates()?;
assert_eq!(memory_candidates.len(), 1);
assert_eq!(memory_candidates[0].id, "mempatch-auth-spine");
assert_eq!(memory_candidates[0].proposed_nodes.len(), 1);
assert_eq!(
memory_candidates[0].proposed_nodes[0].domain_id,
"memdom-repo"
);
assert!(
runtime_job_snapshot(&store, "worker-job-1")?
.expect("snapshot")
.result
.is_some()
);
Ok(())
}
}