From 86462e7b0bfd356b3c941cbaed064d02c41e45d7 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Wed, 13 May 2026 08:24:29 +0100 Subject: [PATCH] Run worker launches through OpenAI runtime --- .../src/bin/epiphany-openai-runtime.rs | 45 ++- epiphany-openai-runtime/src/lib.rs | 322 ++++++++++++++++++ notes/fresh-workspace-handoff.md | 12 +- state/ledgers.msgpack | Bin 87611 -> 88180 bytes state/map.yaml | 4 +- 5 files changed, 377 insertions(+), 6 deletions(-) diff --git a/epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs b/epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs index 0c41f79b..d45d8df5 100644 --- a/epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs +++ b/epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs @@ -11,6 +11,7 @@ use epiphany_openai_adapter::EpiphanyOpenAiModelRequest; use epiphany_openai_adapter::EpiphanyOpenAiStreamEvent; use epiphany_openai_adapter::EpiphanyOpenAiStreamPayload; use epiphany_openai_runtime::EpiphanyOpenAiRuntimeOptions; +use epiphany_openai_runtime::EpiphanyWorkerRuntimeOptions; use epiphany_openai_runtime::OPENAI_RUNTIME_ROLE; use epiphany_openai_runtime::assistant_text_from_openai_events; use epiphany_openai_runtime::default_codex_home; @@ -18,6 +19,7 @@ use epiphany_openai_runtime::default_options; use epiphany_openai_runtime::ensure_openai_runtime_ready; use epiphany_openai_runtime::record_openai_events; use epiphany_openai_runtime::run_openai_model_turn; +use epiphany_openai_runtime::run_worker_launch; use serde_json::json; use uuid::Uuid; @@ -47,6 +49,17 @@ async fn main() -> Result<()> { } print_json(&summary)?; } + "run-worker" => { + let options = parse_run_worker_options(args.collect())?; + let summary = run_worker_launch(EpiphanyWorkerRuntimeOptions { + store_path: options.store_path, + codex_home: options.codex_home, + job_id: options.job_id, + model: options.model, + }) + .await?; + print_json(&summary)?; + } "smoke" => { let options = parse_smoke_options(args.collect())?; let mut request = EpiphanyOpenAiModelRequest::new( @@ -145,6 +158,13 @@ struct SmokeCliOptions { codex_home: PathBuf, } +struct RunWorkerCliOptions { + store_path: PathBuf, + codex_home: PathBuf, + job_id: String, + model: String, +} + fn parse_model_turn_options(args: Vec) -> Result { let mut store_path = PathBuf::from(DEFAULT_STORE); let mut codex_home = default_codex_home()?; @@ -185,6 +205,29 @@ fn parse_model_turn_options(args: Vec) -> Result { }) } +fn parse_run_worker_options(args: Vec) -> Result { + let mut store_path = PathBuf::from(DEFAULT_STORE); + let mut codex_home = default_codex_home()?; + let mut job_id = None; + let mut model = "gpt-5.4".to_string(); + let mut iter = args.into_iter(); + while let Some(arg) = iter.next() { + match arg.as_str() { + "--store" => store_path = PathBuf::from(next_value(&mut iter, "--store")?), + "--codex-home" => codex_home = PathBuf::from(next_value(&mut iter, "--codex-home")?), + "--job-id" => job_id = Some(next_value(&mut iter, "--job-id")?), + "--model" | "--default-model" => model = next_value(&mut iter, "--model")?, + other => return Err(anyhow!("unknown run-worker argument: {other}")), + } + } + Ok(RunWorkerCliOptions { + store_path, + codex_home, + job_id: job_id.context("run-worker requires --job-id")?, + model, + }) +} + fn parse_smoke_options(args: Vec) -> Result { let mut store_path = PathBuf::from(format!( ".epiphany-dogfood/openai-runtime/smoke-{}.msgpack", @@ -220,5 +263,5 @@ fn now() -> String { } fn usage() -> &'static str { - "usage: epiphany-openai-runtime [--store path] [--codex-home path] [--request path] [--session-id id] [--job-id id] [--objective text] [--default-model model] [--output-last-message path]" + "usage: epiphany-openai-runtime [--store path] [--codex-home path] [--request path] [--session-id id] [--job-id id] [--objective text] [--default-model model] [--output-last-message path]" } diff --git a/epiphany-openai-runtime/src/lib.rs b/epiphany-openai-runtime/src/lib.rs index b25f984a..6b73e972 100644 --- a/epiphany-openai-runtime/src/lib.rs +++ b/epiphany-openai-runtime/src/lib.rs @@ -4,9 +4,12 @@ use std::sync::Arc; use anyhow::Context; use anyhow::Result; +use anyhow::anyhow; use chrono::SecondsFormat; use codex_login::AuthCredentialsStoreMode; use codex_login::AuthManager; +use epiphany_core::EpiphanyRuntimeWorkerLaunchRequest; +use epiphany_core::EpiphanyWorkerLaunchDocument; use epiphany_core::RuntimeSpineEventOptions; use epiphany_core::RuntimeSpineInitOptions; use epiphany_core::RuntimeSpineJobOptions; @@ -20,11 +23,13 @@ use epiphany_core::initialize_runtime_spine; 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::status_from_auth_manager; +use serde_json::Value; pub const OPENAI_RUNTIME_ROLE: &str = "openai-model-adapter"; pub const OPENAI_RUNTIME_SOURCE: &str = "epiphany-openai-runtime"; @@ -53,6 +58,27 @@ pub struct EpiphanyOpenAiRuntimeRunSummary { pub receipt_id: Option, } +#[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, @@ -113,6 +139,47 @@ pub async fn run_openai_model_turn( record_openai_events(&options.store_path, &options, &request, &events) } +pub async fn run_worker_launch( + options: EpiphanyWorkerRuntimeOptions, +) -> Result { + 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, options: &EpiphanyOpenAiRuntimeOptions, @@ -209,6 +276,102 @@ pub fn record_openai_events( }) } +pub fn load_worker_launch_request( + store_path: impl AsRef, + job_id: &str, +) -> Result { + let mut cache = runtime_spine_cache(store_path)?; + cache.pull_all_backing_stores()?; + cache + .get::(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 { + 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, + launch_request: &EpiphanyRuntimeWorkerLaunchRequest, + openai_request_id: &str, + openai_summary: &EpiphanyOpenAiRuntimeRunSummary, + assistant_text: &str, +) -> Result { + let parsed = parse_assistant_json_object(assistant_text).ok(); + let openai_failed = openai_summary.verdict != "pass"; + let verdict = if openai_failed { + "failed".to_string() + } else { + parsed + .as_ref() + .and_then(|value| { + string_field(value, "verdict").or_else(|| string_field(value, "mode")) + }) + .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(|value| string_field(value, "summary")) + .unwrap_or_else(|| "Worker completed without a structured summary.".to_string()) + }; + let next_safe_move = parsed + .as_ref() + .and_then(|value| string_field(value, "nextSafeMove")) + .unwrap_or_else(|| { + "Review the typed worker runtime result before accepting state.".to_string() + }); + let mut evidence_refs = parsed + .as_ref() + .map(|value| string_array_field(value, "evidenceIds")) + .unwrap_or_default(); + evidence_refs.push(format!("openai-request:{openai_request_id}")); + let mut artifact_refs = parsed + .as_ref() + .map(|value| string_array_field(value, "artifactRefs")) + .unwrap_or_default(); + artifact_refs.push(format!("openai-result:{}", openai_summary.result_id)); + complete_runtime_job( + store_path, + RuntimeSpineJobResultOptions { + result_id: format!("result-worker-{}", launch_request.job_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 { @@ -352,6 +515,82 @@ fn openai_event_summary(event: &EpiphanyOpenAiStreamEvent) -> String { } } +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. Use arrays for frontierNodeIds, evidenceIds, openQuestions, evidenceGaps, risks, and artifactRefs when present." + } + EpiphanyWorkerLaunchDocument::Reorient(_) => { + "Required reorient-result fields: mode, summary, nextSafeMove. Include checkpointStillValid, filesInspected, frontierNodeIds, evidenceIds, openQuestions, and continuityRisks when present." + } + } +} + +fn parse_assistant_json_object(text: &str) -> Result { + 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(); + let value: Value = serde_json::from_str(candidate).context("assistant text was not JSON")?; + if !value.is_object() { + return Err(anyhow!("assistant JSON result must be an object")); + } + Ok(value) +} + +fn string_field(value: &Value, key: &str) -> Option { + value + .get(key) + .and_then(Value::as_str) + .map(str::trim) + .filter(|value| !value.is_empty()) + .map(ToString::to_string) +} + +fn string_array_field(value: &Value, key: &str) -> Vec { + value + .get(key) + .and_then(Value::as_array) + .into_iter() + .flatten() + .filter_map(Value::as_str) + .map(str::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) } @@ -359,6 +598,9 @@ fn now() -> String { #[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; @@ -428,4 +670,84 @@ mod tests { ); 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(), + 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"]}"#, + )?; + + 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())); + assert!( + runtime_job_snapshot(&store, "worker-job-1")? + .expect("snapshot") + .result + .is_some() + ); + Ok(()) + } } diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 95bb5e96..7349fc02 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -586,9 +586,15 @@ outside-vendor `epiphany-openai-runtime` crate writes typed model-turn requests, stream events, terminal receipts, runtime sessions, jobs, job results, and runtime events into the native runtime spine. Its `model-turn` command calls the Codex-backed typed transport; its `smoke` command proves the -storage route without network. The next cut is to move live callers from -Codex app-server JSON-RPC onto this runtime route, then carve down the -`codex-api` dependency weight. +storage route without network. Its `run-worker` command now reads a durable +`EpiphanyRuntimeWorkerLaunchRequest` by runtime job id, builds a typed OpenAI +model request, calls the native runtime route, and completes the original +heartbeat/specialist runtime job without Codex worker execution. The remaining +result wound is deliberate and named: rich role/reorient output is still parsed +from model-edge JSON into generic job-result fields. The next cut is a +first-class typed runtime worker result document plus roleResult/reorientResult +readback through that document, then carving down the `codex-api` dependency +weight. The runtime-spine job-opening mechanism for heartbeat/specialist launches has also been pulled into `epiphany-core` as `open_runtime_spine_heartbeat_job`. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 06012fa3f6e1f7e44a8e5166c9ee14e0489ef31a..ae06cf800a4dec53edc731bfacd2fc71f1c2f8c5 100644 GIT binary patch delta 433 zcmYk3F)u_x5XZBUi%ufZ2*n60-Z@W@yzZjXkZ?jov-jS(H|*Pec4r+Gi7z0Lc(qI_m-lnNOgaE@Rsbx2DEIZDfIlsxB3Oi3zo z+@B5yrVU-<+<1l+li^9=9qIw&2?ka&y1LmCOV!(^7@F8yk+x&%YzhTYq^SM7_eX>@ z$Mmpz+7jbE@7X_Z9X7C#q)B(ec(1brETuVEqj1h*AVtj(5K7Mu9FtO@F{Iol>o`i4 obRknOcmJB`ykf{q>Wk3p>gNw}BVLLci_!c-s}cTC`+3CfHy-|-Bme*a delta 49 zcmeyefpzy9)(Of?VT>D9r!g`