Extract Codex transport from Epiphany

This commit is contained in:
Meta Vens 2026-08-24 17:57:06 +02:00
commit ed7357a28b
17 changed files with 2627 additions and 8314 deletions

5054
Cargo.lock generated

File diff suppressed because it is too large Load diff

View file

@ -3,7 +3,6 @@ members = [
"epiphany-core",
"epiphany-model-adapter",
"epiphany-openai-adapter",
"epiphany-openai-codex-spine",
"epiphany-openai-runtime",
"epiphany-release-construction",
"epiphany-state-model",
@ -30,8 +29,8 @@ cultnet-rs = { path = "vendor/cultnet-rs" }
epiphany-core = { path = "epiphany-core" }
epiphany-model-adapter = { path = "epiphany-model-adapter" }
epiphany-openai-adapter = { path = "epiphany-openai-adapter" }
epiphany-openai-codex-spine = { path = "epiphany-openai-codex-spine", optional = true }
epiphany-openai-runtime = { path = "epiphany-openai-runtime", optional = true }
codex-connector = { git = "https://github.com/GameCult/CodexConnector", rev = "54d8bc2525b7e7fa1b9dd26b95871247ff4c7566", default-features = false, optional = true }
epiphany-tool-adapter = { path = "epiphany-tool-adapter" }
epiphany-tool-mcp-runtime = { path = "epiphany-tool-mcp-runtime", optional = true }
rmp-serde = "1"
@ -40,10 +39,12 @@ serde_json = "1"
sha2 = "0.10"
tokio = { version = "1", features = ["io-util", "macros", "process", "rt", "rt-multi-thread", "time"] }
toml = "0.9"
ureq = { version = "3.4", default-features = false, features = ["rustls"], optional = true }
uuid = { version = "1", features = ["serde", "v4"] }
zeroize = { version = "1", optional = true }
[features]
openai-runtime = ["dep:epiphany-openai-codex-spine", "dep:epiphany-openai-runtime"]
openai-runtime = ["dep:codex-connector", "dep:epiphany-openai-runtime", "dep:ureq", "dep:zeroize"]
tool-mcp-runtime = ["dep:epiphany-tool-mcp-runtime"]
release-runtime = ["openai-runtime", "tool-mcp-runtime"]

View file

@ -11,6 +11,7 @@ use epiphany_core::HANDS_PATCH_RECEIPT_TYPE;
use epiphany_core::HandsActionIntent;
use epiphany_core::RepoFrontierHandsAuthority;
use epiphany_core::RuntimeSpineInitOptions;
use epiphany_core::coordinator_status as status_projection;
use epiphany_core::finalize_coordinator_run;
use epiphany_core::hands_action_review_for_intent;
use epiphany_core::initialize_runtime_spine;
@ -25,13 +26,13 @@ use epiphany_core::substrate_gate_coordinator_implementation_grant;
use epiphany_core::{
LaunchedCoordinator, capture_process_instance, claim_resident_self_preparation_as_child,
};
use epiphany_core::coordinator_status as status_projection;
use serde_json::Value;
use serde_json::json;
use sha2::{Digest, Sha256};
use std::collections::BTreeMap;
use std::env;
use std::fs;
use std::net::SocketAddr;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::thread;
@ -69,7 +70,7 @@ struct Args {
thread_id: Option<String>,
objective: Option<String>,
cwd: PathBuf,
codex_home: PathBuf,
model_connector_endpoint: SocketAddr,
mcp_config: PathBuf,
artifact_dir: PathBuf,
runtime_store: PathBuf,
@ -106,9 +107,7 @@ impl Args {
thread_id: None,
objective: None,
cwd: root.clone(),
codex_home: env::var_os("CODEX_HOME")
.map(PathBuf::from)
.unwrap_or_else(|| home_dir().join(".codex")),
model_connector_endpoint: "127.0.0.1:17891".parse().unwrap(),
mcp_config: root.join(".epiphany").join("mcp.toml"),
artifact_dir: root.join(".epiphany-dogfood").join("coordinator"),
runtime_store: root.join("state").join("runtime-spine.msgpack"),
@ -197,7 +196,10 @@ impl Args {
parsed.required_action = Some(take_string(&mut args, "--required-action")?)
}
"--cwd" => parsed.cwd = take_path(&mut args, "--cwd")?,
"--codex-home" => parsed.codex_home = take_path(&mut args, "--codex-home")?,
"--connector-endpoint" => {
parsed.model_connector_endpoint =
take_string(&mut args, "--connector-endpoint")?.parse()?
}
"--mcp-config" => parsed.mcp_config = take_path(&mut args, "--mcp-config")?,
"--artifact-dir" => parsed.artifact_dir = take_path(&mut args, "--artifact-dir")?,
"--runtime-store" => {
@ -283,12 +285,10 @@ fn run_coordinator(args: &Args) -> Result<Value> {
let cwd = status_projection::absolute_path(&args.cwd)?;
let model_runtime_bin = resolve_model_runtime_bin(&root, &args.model_runtime_bin)?;
let tool_adapter_bin = resolve_model_runtime_bin(&root, &args.tool_adapter_bin)?;
let codex_home = status_projection::absolute_path(&args.codex_home)?;
let mcp_config = status_projection::absolute_path(&args.mcp_config)?;
let artifact_dir = status_projection::absolute_path(&args.artifact_dir)?;
let runtime_store = status_projection::absolute_path(&args.runtime_store)?;
reset_artifact_dir(&artifact_dir)?;
fs::create_dir_all(&codex_home)?;
let telemetry_path = artifact_dir.join("agent-function-telemetry.json");
let steps_path = artifact_dir.join("coordinator-steps.jsonl");
@ -408,7 +408,7 @@ fn run_coordinator(args: &Args) -> Result<Value> {
&args.model,
args.provider_credential_path.as_deref(),
&runtime_store,
&codex_home,
args.model_connector_endpoint,
&mcp_config,
&cwd,
args.resident_state_store.as_deref(),
@ -450,7 +450,7 @@ fn run_coordinator(args: &Args) -> Result<Value> {
&args.model,
args.provider_credential_path.as_deref(),
&runtime_store,
&codex_home,
args.model_connector_endpoint,
&mcp_config,
&cwd,
args.resident_state_store.as_deref(),
@ -504,7 +504,7 @@ fn run_coordinator(args: &Args) -> Result<Value> {
&args.model,
args.provider_credential_path.as_deref(),
&runtime_store,
&codex_home,
args.model_connector_endpoint,
&mcp_config,
&cwd,
args.resident_state_store.as_deref(),
@ -549,7 +549,9 @@ fn run_coordinator(args: &Args) -> Result<Value> {
let snapshot_name = format!("step-{index:02}-{action}.txt");
fs::write(
artifact_dir.join(&snapshot_name),
status_projection::render_status(&status_projection::sanitize_for_operator(status.clone())),
status_projection::render_status(&status_projection::sanitize_for_operator(
status.clone(),
)),
)?;
snapshots.push(snapshot_name);
let mut step = json!({
@ -656,7 +658,7 @@ fn run_coordinator(args: &Args) -> Result<Value> {
&args.model,
args.provider_credential_path.as_deref(),
&runtime_store,
&codex_home,
args.model_connector_endpoint,
&mcp_config,
&cwd,
args.resident_state_store.as_deref(),
@ -706,7 +708,7 @@ fn run_coordinator(args: &Args) -> Result<Value> {
&args.model,
args.provider_credential_path.as_deref(),
&runtime_store,
&codex_home,
args.model_connector_endpoint,
&mcp_config,
&cwd,
args.resident_state_store.as_deref(),
@ -1027,7 +1029,7 @@ fn run_coordinator(args: &Args) -> Result<Value> {
&args.model,
args.provider_credential_path.as_deref(),
&runtime_store,
&codex_home,
args.model_connector_endpoint,
&mcp_config,
&cwd,
args.resident_state_store.as_deref(),
@ -1070,7 +1072,7 @@ fn run_coordinator(args: &Args) -> Result<Value> {
&args.model,
args.provider_credential_path.as_deref(),
&runtime_store,
&codex_home,
args.model_connector_endpoint,
&mcp_config,
&cwd,
args.resident_state_store.as_deref(),
@ -1186,7 +1188,7 @@ fn run_coordinator(args: &Args) -> Result<Value> {
&args.model,
args.provider_credential_path.as_deref(),
&runtime_store,
&codex_home,
args.model_connector_endpoint,
&mcp_config,
&cwd,
args.resident_state_store.as_deref(),
@ -1256,7 +1258,7 @@ fn run_coordinator(args: &Args) -> Result<Value> {
&args.model,
args.provider_credential_path.as_deref(),
&runtime_store,
&codex_home,
args.model_connector_endpoint,
&mcp_config,
&cwd,
args.resident_state_store.as_deref(),
@ -1344,7 +1346,7 @@ fn run_coordinator(args: &Args) -> Result<Value> {
"modelRuntimeBin": model_runtime_bin,
"toolAdapterBin": tool_adapter_bin,
"modelProvider": args.model_provider,
"codexHome": codex_home,
"modelConnectorEndpoint": args.model_connector_endpoint,
"mcpConfig": mcp_config,
"runtimeStore": runtime_store,
"workspace": cwd,
@ -1738,7 +1740,7 @@ fn launch_worker_runtime_detached(
model: &str,
provider_credential_path: Option<&Path>,
runtime_store: &Path,
codex_home: &Path,
model_connector_endpoint: SocketAddr,
mcp_config: &Path,
cwd: &Path,
resident_store: Option<&Path>,
@ -1767,8 +1769,8 @@ fn launch_worker_runtime_detached(
.arg(model)
.arg("--store")
.arg(runtime_store)
.arg("--codex-home")
.arg(codex_home)
.arg("--connector-endpoint")
.arg(model_connector_endpoint.to_string())
.arg("--mcp-config")
.arg(mcp_config)
.arg("--job-id")
@ -2053,7 +2055,10 @@ fn append_jsonl(path: &Path, value: &Value) -> Result<()> {
}
fn append_operator_step_jsonl(path: &Path, step: &Value) -> Result<()> {
append_jsonl(path, &status_projection::sanitize_for_operator(step.clone()))
append_jsonl(
path,
&status_projection::sanitize_for_operator(step.clone()),
)
}
fn take_string(args: &mut impl Iterator<Item = String>, name: &str) -> Result<String> {
@ -2065,13 +2070,6 @@ fn take_path(args: &mut impl Iterator<Item = String>, name: &str) -> Result<Path
Ok(PathBuf::from(take_string(args, name)?))
}
fn home_dir() -> PathBuf {
env::var_os("USERPROFILE")
.or_else(|| env::var_os("HOME"))
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from("."))
}
#[cfg(test)]
mod tests {
use super::*;
@ -2111,7 +2109,7 @@ mod tests {
thread_id: Some("error-terminalization".to_string()),
objective: Some("Exercise the coordinator error boundary.".to_string()),
cwd: cwd.clone(),
codex_home: temp.path().join("codex-home"),
model_connector_endpoint: "127.0.0.1:17891".parse().unwrap(),
mcp_config: cwd.join(".epiphany/mcp.toml"),
artifact_dir: cwd.join(".epiphany-smoke/error-terminalization"),
runtime_store: runtime_store.clone(),

View file

@ -495,7 +495,11 @@ impl Args {
runtime_store: path("--runtime-store")?,
local_verse_store: path("--local-verse-store")?,
artifact_root: path("--artifact-root")?,
codex_home: path("--codex-home")?,
model_connector_endpoint: value
.get("--connector-endpoint")
.ok_or_else(|| anyhow!("missing --connector-endpoint"))?
.parse()
.context("invalid --connector-endpoint")?,
mcp_config: path("--mcp-config")?,
model_provider: value
.get("--model-provider")
@ -776,7 +780,7 @@ mod brake_tests {
runtime_store,
local_verse_store: verse_store,
artifact_root: shared.join("artifacts"),
codex_home: shared.join("codex-home"),
model_connector_endpoint: "127.0.0.1:17891".parse().unwrap(),
mcp_config: shared.join("mcp.toml"),
model_provider: "test".into(),
model: "test-model".into(),

View file

@ -3664,7 +3664,7 @@ mod tests {
runtime_store: store.clone(),
local_verse_store: temp.path().join("local-verse.cc"),
artifact_root: temp.path().join("artifacts"),
codex_home: temp.path().join("codex-home"),
model_connector_endpoint: "127.0.0.1:17891".parse().unwrap(),
mcp_config: temp.path().join("mcp.toml"),
model_provider: "openrouter".into(),
model: "stealth/ox-alpha".into(),

View file

@ -728,20 +728,12 @@ fn directory_ready(path: &Path) -> bool {
fs::metadata(path).is_ok_and(|value| value.is_dir() && !value.permissions().readonly())
}
fn codex_credentials_ready(codex_home: &Path) -> bool {
directory_ready(codex_home) && credential_file_ready(&codex_home.join("auth.json"))
}
fn model_provider_credential_ready(policy: &ResidentSelfPolicy) -> bool {
match policy.model_provider.as_str() {
"openai-codex" | "openai" => codex_credentials_ready(&policy.codex_home),
"openrouter" => policy
"openai-codex" | "openai" | "openrouter" => policy
.provider_credential_path
.as_deref()
.is_some_and(|path| {
fs::metadata(path).is_ok_and(|metadata| metadata.is_file())
&& fs::File::open(path).is_ok()
}),
.is_some_and(credential_file_ready),
_ => false,
}
}
@ -972,30 +964,6 @@ mod tests {
Ok(())
}
#[cfg(unix)]
#[test]
fn unix_credentials_reject_group_or_other_access() -> Result<()> {
use std::os::unix::fs::PermissionsExt;
let temp = tempfile::tempdir()?;
let auth = temp.path().join("auth.json");
fs::write(&auth, b"{}")?;
fs::set_permissions(&auth, fs::Permissions::from_mode(0o400))?;
assert!(!codex_credentials_ready(temp.path()));
fs::set_permissions(&auth, fs::Permissions::from_mode(0o644))?;
assert!(!codex_credentials_ready(temp.path()));
fs::set_permissions(&auth, fs::Permissions::from_mode(0o600))?;
assert!(codex_credentials_ready(temp.path()));
Ok(())
}
#[test]
fn legacy_credentials_file_cannot_impersonate_canonical_auth() -> Result<()> {
let temp = tempfile::tempdir()?;
fs::write(temp.path().join("credentials.json"), b"{}")?;
assert!(!codex_credentials_ready(temp.path()));
Ok(())
}
#[test]
fn readiness_uses_mounted_cognitive_identity_for_projection_and_brake() -> Result<()> {
let temp = tempfile::tempdir()?;
@ -1026,7 +994,7 @@ mod tests {
runtime_store,
local_verse_store,
artifact_root: shared.join("artifacts"),
codex_home: shared.join("codex-home"),
model_connector_endpoint: "127.0.0.1:17891".parse().unwrap(),
mcp_config: shared.join("mcp.toml"),
model_provider: "test".into(),
model: "test-model".into(),

View file

@ -5,6 +5,7 @@ use cultcache_rs::{
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::collections::{BTreeSet, HashSet};
use std::net::SocketAddr;
use std::path::{Path, PathBuf};
pub const RESIDENT_SELF_STATE_KEY: &str = "resident-self";
@ -273,7 +274,7 @@ pub struct ResidentSelfPolicy {
pub runtime_store: PathBuf,
pub local_verse_store: PathBuf,
pub artifact_root: PathBuf,
pub codex_home: PathBuf,
pub model_connector_endpoint: SocketAddr,
pub mcp_config: PathBuf,
pub model_provider: String,
pub model: String,
@ -301,7 +302,6 @@ impl ResidentSelfPolicy {
("runtime store", &self.runtime_store),
("local Verse store", &self.local_verse_store),
("artifact root", &self.artifact_root),
("Codex home", &self.codex_home),
("MCP config", &self.mcp_config),
("release store", &self.release_store),
] {
@ -320,6 +320,13 @@ impl ResidentSelfPolicy {
path.display()
));
}
if !self.model_connector_endpoint.ip().is_loopback()
|| self.model_connector_endpoint.port() == 0
{
return Err(anyhow!(
"resident Self model connector must use a nonzero loopback endpoint"
));
}
if self.model_provider.trim().is_empty()
|| self.model.trim().is_empty()
|| self.max_steps == 0
@ -617,8 +624,8 @@ pub fn coordinator_argv(
turn_id.into(),
"--cwd".into(),
policy.workspace.display().to_string(),
"--codex-home".into(),
policy.codex_home.display().to_string(),
"--connector-endpoint".into(),
policy.model_connector_endpoint.to_string(),
"--mcp-config".into(),
policy.mcp_config.display().to_string(),
"--artifact-dir".into(),
@ -2762,7 +2769,7 @@ mod coordinator_launch_contract_tests {
runtime_store,
local_verse_store: root.join("local-verse.cc"),
artifact_root: root.join("artifacts"),
codex_home: root.join("codex-home"),
model_connector_endpoint: "127.0.0.1:17891".parse().unwrap(),
mcp_config: root.join("mcp.toml"),
model_provider: "openrouter".into(),
model: "stealth/ox-alpha".into(),
@ -2791,7 +2798,7 @@ mod coordinator_launch_contract_tests {
runtime_store: PathBuf::from("/epiphany/state/runtime.cc"),
local_verse_store: PathBuf::from("/epiphany/state/local-verse.cc"),
artifact_root: PathBuf::from("/epiphany/artifacts"),
codex_home: PathBuf::from("/epiphany/codex-home"),
model_connector_endpoint: "127.0.0.1:17891".parse().unwrap(),
mcp_config: PathBuf::from("/epiphany/mcp.toml"),
model_provider: "openrouter".into(),
model: "stealth/ox-alpha".into(),

View file

@ -55,7 +55,7 @@ pub const COORDINATOR_RUN_RECEIPT_TYPE: &str = "epiphany.coordinator_run_receipt
pub const RUNTIME_IDENTITY_KEY: &str = "self";
pub const RUNTIME_SWARM_BINDING_KEY: &str = "runtime-swarm-binding";
pub const RUNTIME_SWARM_BINDING_SCHEMA_VERSION: &str = "epiphany.runtime.swarm_binding.v1";
pub const RUNTIME_SPINE_SCHEMA_VERSION: &str = "epiphany.runtime_spine.v37";
pub const RUNTIME_SPINE_SCHEMA_VERSION: &str = "epiphany.runtime_spine.v38";
pub const EPIPHANY_RUNTIME_ROOT_SESSION_ID: &str = "epiphany-main";
#[derive(Clone, Debug, PartialEq, DatabaseEntry)]
#[cultcache(type = "epiphany.runtime.identity", schema = "EpiphanyRuntimeIdentity")]
@ -1936,7 +1936,8 @@ fn archive_completed_model_session(
}
match &native_terminals[0].payload {
EpiphanyModelStreamPayload::Completed { receipt } => {
if cache.get::<EpiphanyModelReceipt>(request_id)?.as_ref() != Some(receipt) {
if cache.get::<EpiphanyModelReceipt>(request_id)?.as_ref() != Some(receipt.as_ref())
{
return Err(anyhow!(
"runtime session archive found inconsistent native model receipt"
));

View file

@ -4,7 +4,7 @@ use serde::Serialize;
pub const MODEL_ADAPTER_REQUEST_SCHEMA_ID: &str = "epiphany.model_request.v0";
pub const MODEL_ADAPTER_EVENT_SCHEMA_ID: &str = "epiphany.model_stream_event.v0";
pub const MODEL_ADAPTER_RECEIPT_SCHEMA_ID: &str = "epiphany.model_receipt.v0";
pub const MODEL_ADAPTER_RECEIPT_SCHEMA_ID: &str = "epiphany.model_receipt.v1";
#[derive(Debug, Clone, PartialEq, DatabaseEntry)]
#[cultcache(type = "epiphany.model_request.v0", schema = "EpiphanyModelRequest")]
pub struct EpiphanyModelRequest {
@ -129,7 +129,7 @@ pub enum EpiphanyModelStreamPayload {
arguments: String,
},
Completed {
receipt: EpiphanyModelReceipt,
receipt: Box<EpiphanyModelReceipt>,
},
Failed {
message: String,
@ -137,7 +137,7 @@ pub enum EpiphanyModelStreamPayload {
}
#[derive(Debug, Clone, PartialEq, Eq, DatabaseEntry)]
#[cultcache(type = "epiphany.model_receipt.v0", schema = "EpiphanyModelReceipt")]
#[cultcache(type = "epiphany.model_receipt.v1", schema = "EpiphanyModelReceipt")]
pub struct EpiphanyModelReceipt {
#[cultcache(key = 0)]
pub schema_id: String,
@ -157,6 +157,14 @@ pub struct EpiphanyModelReceipt {
pub reasoning_output_tokens: Option<u64>,
#[cultcache(key = 8, default)]
pub transport: Option<String>,
#[cultcache(key = 9, default)]
pub caller_runtime_id: Option<String>,
#[cultcache(key = 10, default)]
pub native_request_sha256: Option<String>,
#[cultcache(key = 11, default)]
pub provider_request_sha256: Option<String>,
#[cultcache(key = 12, default)]
pub cached_input_tokens: Option<u64>,
}
impl EpiphanyModelReceipt {
@ -175,6 +183,10 @@ impl EpiphanyModelReceipt {
output_tokens: None,
reasoning_output_tokens: None,
transport: None,
caller_runtime_id: None,
native_request_sha256: None,
provider_request_sha256: None,
cached_input_tokens: None,
}
}
}

View file

@ -10,6 +10,9 @@ name = "epiphany_openai_adapter"
path = "src/lib.rs"
[dependencies]
anyhow = "1"
cultcache-rs = { path = "../vendor/cultcache-rs" }
epiphany-model-adapter = { path = "../epiphany-model-adapter" }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
sha2 = "0.10"

View file

@ -2,6 +2,7 @@ use cultcache_rs::DatabaseEntry;
use epiphany_model_adapter::{EpiphanyModelInputItem, EpiphanyModelRequest};
use serde::Deserialize;
use serde::Serialize;
use sha2::{Digest, Sha256};
pub const OPENAI_ADAPTER_REQUEST_SCHEMA_ID: &str = "epiphany.openai_model_request.v1";
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@ -183,7 +184,7 @@ pub enum EpiphanyOpenAiStreamPayload {
arguments: String,
},
Completed {
receipt: EpiphanyOpenAiModelReceipt,
receipt: Box<EpiphanyOpenAiModelReceipt>,
},
Failed {
message: String,
@ -199,6 +200,10 @@ pub struct EpiphanyOpenAiModelReceipt {
pub output_tokens: Option<u64>,
pub reasoning_output_tokens: Option<u64>,
pub transport: Option<String>,
pub caller_runtime_id: Option<String>,
pub native_request_sha256: Option<String>,
pub provider_request_sha256: Option<String>,
pub cached_input_tokens: Option<u64>,
}
impl EpiphanyOpenAiModelReceipt {
@ -211,6 +216,615 @@ impl EpiphanyOpenAiModelReceipt {
output_tokens: None,
reasoning_output_tokens: None,
transport: None,
caller_runtime_id: None,
native_request_sha256: None,
provider_request_sha256: None,
cached_input_tokens: None,
}
}
}
/// Project Epiphany's canonical JSON Schema into the strict subset accepted by
/// model providers. Native decoding remains the final validation authority.
pub fn strict_provider_schema(schema_json: &str) -> anyhow::Result<serde_json::Value> {
let mut schema = serde_json::from_str(schema_json)
.map_err(|error| anyhow::anyhow!("provider schema is not valid JSON Schema: {error}"))?;
lower_provider_schema(&mut schema);
close_provider_objects(&mut schema, "$")?;
if !provider_schema_is_strict(&schema) {
return Err(anyhow::anyhow!(
"projected provider output schema is not strict"
));
}
Ok(schema)
}
/// Provider-safe output-format identity derived from the native contract.
pub fn provider_format_name(value: &str) -> String {
let mut name = value
.chars()
.map(|ch| {
if ch.is_ascii_alphanumeric() || matches!(ch, '_' | '-') {
ch
} else {
'_'
}
})
.take(64)
.collect::<String>();
if name.is_empty() {
name.push_str("epiphany_worker_result");
}
name
}
/// Responses call IDs have a narrow alphabet and byte bound. Preserve already
/// legal IDs and derive a stable identity for every other native call ID.
pub fn provider_call_id(value: &str) -> String {
if !value.is_empty()
&& value.len() <= 64
&& value
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-'))
{
return value.to_string();
}
let digest = Sha256::digest(value.as_bytes());
let mut projected = String::with_capacity(64);
for byte in digest {
use std::fmt::Write as _;
write!(&mut projected, "{byte:02x}").expect("writing to a String cannot fail");
}
projected
}
pub const OPENROUTER_TERMINAL_TOOL_NAME: &str = "epiphany_submit_typed_result";
/// Lower one typed Epiphany request to OpenRouter's terminal-tool dialect.
pub fn openrouter_request_body(
request: &EpiphanyOpenAiModelRequest,
) -> anyhow::Result<serde_json::Value> {
if request.provider_id != "openrouter"
|| request.wire_dialect != EpiphanyOpenAiWireDialect::ChatCompletionsTerminalTool
{
return Err(anyhow::anyhow!(
"OpenRouter requires its exact provider identity and terminal-tool dialect"
));
}
let has_tool_result = request
.input
.iter()
.any(|item| matches!(item, EpiphanyOpenAiInputItem::ToolResult { .. }));
let output_schema = request
.output_schema_json
.as_deref()
.map(strict_provider_schema)
.transpose()?;
let include_terminal_tool =
output_schema.is_some() && (request.tools.is_empty() || has_tool_result);
if request
.tools
.iter()
.any(|tool| tool.name == OPENROUTER_TERMINAL_TOOL_NAME)
{
return Err(anyhow::anyhow!(
"native tool name collides with the OpenRouter terminal decision tool"
));
}
let mut messages = vec![serde_json::json!({
"role": "system",
"content": request.instructions,
})];
for item in &request.input {
messages.push(match item {
EpiphanyOpenAiInputItem::UserText { text } => {
serde_json::json!({"role": "user", "content": text})
}
EpiphanyOpenAiInputItem::AssistantText { text } => {
serde_json::json!({"role": "assistant", "content": text})
}
EpiphanyOpenAiInputItem::ToolCall {
call_id,
name,
arguments,
} => serde_json::json!({
"role": "assistant",
"tool_calls": [{
"id": call_id,
"type": "function",
"function": {"name": name, "arguments": arguments},
}],
}),
EpiphanyOpenAiInputItem::ToolResult { call_id, output } => serde_json::json!({
"role": "tool",
"tool_call_id": call_id,
"content": output,
}),
});
}
let mut tools = request
.tools
.iter()
.map(|tool| {
Ok(serde_json::json!({
"type": "function",
"function": {
"name": tool.name,
"description": tool.description,
"strict": true,
"parameters": strict_provider_schema(&tool.parameters_json)?,
},
}))
})
.collect::<anyhow::Result<Vec<_>>>()?;
if include_terminal_tool {
tools.push(serde_json::json!({
"type": "function",
"function": {
"name": OPENROUTER_TERMINAL_TOOL_NAME,
"description": "Submit the final typed Epiphany decision. Call this only when the pass is complete.",
"strict": true,
"parameters": output_schema.expect("terminal schema exists"),
},
}));
}
let mut body = serde_json::json!({
"model": request.model,
"messages": messages,
"stream": false,
"parallel_tool_calls": false,
});
if !tools.is_empty() {
body["tools"] = serde_json::Value::Array(tools);
body["tool_choice"] = serde_json::Value::String(
if include_terminal_tool || (!request.tools.is_empty() && !has_tool_result) {
"required"
} else {
"auto"
}
.into(),
);
}
if let Some(effort) = request.reasoning_effort.as_deref() {
body["reasoning"] = serde_json::json!({"effort": effort});
}
Ok(body)
}
/// Interpret one non-streaming OpenRouter response into Epiphany's transient
/// event family. The model transcript remains optional; the terminal receipt
/// is authoritative transport evidence.
pub fn openrouter_events_from_response(
request: &EpiphanyOpenAiModelRequest,
response_bytes: &[u8],
) -> anyhow::Result<Vec<EpiphanyOpenAiStreamEvent>> {
let response: OpenRouterResponse = serde_json::from_slice(response_bytes)
.map_err(|error| anyhow::anyhow!("OpenRouter returned an invalid response: {error}"))?;
let choice = response
.choices
.into_iter()
.next()
.ok_or_else(|| anyhow::anyhow!("OpenRouter response contained no completion choice"))?;
let mut events = Vec::new();
if let Some(reasoning) = choice.message.reasoning.filter(|value| !value.is_empty()) {
push_openrouter_event(
&mut events,
&request.request_id,
EpiphanyOpenAiStreamPayload::ReasoningDelta { text: reasoning },
);
}
let terminal_calls = choice
.message
.tool_calls
.iter()
.filter(|call| call.function.name == OPENROUTER_TERMINAL_TOOL_NAME)
.collect::<Vec<_>>();
if !terminal_calls.is_empty() {
if terminal_calls.len() != 1 || choice.message.tool_calls.len() != 1 {
return Err(anyhow::anyhow!(
"OpenRouter mixed the terminal decision tool with another tool call"
));
}
let arguments = &terminal_calls[0].function.arguments;
if !matches!(
serde_json::from_str::<serde_json::Value>(arguments),
Ok(serde_json::Value::Object(_))
) {
return Err(anyhow::anyhow!(
"OpenRouter terminal decision tool returned non-object arguments"
));
}
push_openrouter_event(
&mut events,
&request.request_id,
EpiphanyOpenAiStreamPayload::TextDelta {
text: arguments.clone(),
},
);
} else {
if let Some(content) = choice.message.content.filter(|value| !value.is_empty()) {
push_openrouter_event(
&mut events,
&request.request_id,
EpiphanyOpenAiStreamPayload::TextDelta { text: content },
);
}
for call in choice.message.tool_calls {
push_openrouter_event(
&mut events,
&request.request_id,
EpiphanyOpenAiStreamPayload::ToolCall {
call_id: call.id,
name: call.function.name,
arguments: call.function.arguments,
},
);
}
}
if events.is_empty() {
return Err(anyhow::anyhow!(
"OpenRouter response contained neither text nor tool calls"
));
}
let usage = response.usage;
let mut receipt = EpiphanyOpenAiModelReceipt::new(
&request.request_id,
response.model.unwrap_or_else(|| request.model.clone()),
);
receipt.response_id = response.id;
receipt.input_tokens = usage.as_ref().and_then(|usage| usage.prompt_tokens);
receipt.output_tokens = usage.as_ref().and_then(|usage| usage.completion_tokens);
receipt.reasoning_output_tokens = usage
.as_ref()
.and_then(|usage| usage.completion_tokens_details.as_ref())
.and_then(|details| details.reasoning_tokens);
receipt.transport = Some("openrouter-chat-completions".into());
push_openrouter_event(
&mut events,
&request.request_id,
EpiphanyOpenAiStreamPayload::Completed {
receipt: Box::new(receipt),
},
);
Ok(events)
}
#[derive(Debug, Deserialize)]
struct OpenRouterResponse {
id: Option<String>,
model: Option<String>,
choices: Vec<OpenRouterChoice>,
usage: Option<OpenRouterUsage>,
}
#[derive(Debug, Deserialize)]
struct OpenRouterChoice {
message: OpenRouterMessage,
}
#[derive(Debug, Deserialize)]
struct OpenRouterMessage {
content: Option<String>,
#[serde(default)]
reasoning: Option<String>,
#[serde(default)]
tool_calls: Vec<OpenRouterToolCall>,
}
#[derive(Debug, Deserialize)]
struct OpenRouterToolCall {
id: String,
function: OpenRouterFunctionCall,
}
#[derive(Debug, Deserialize)]
struct OpenRouterFunctionCall {
name: String,
arguments: String,
}
#[derive(Debug, Deserialize)]
struct OpenRouterUsage {
prompt_tokens: Option<u64>,
completion_tokens: Option<u64>,
completion_tokens_details: Option<OpenRouterCompletionTokenDetails>,
}
#[derive(Debug, Deserialize)]
struct OpenRouterCompletionTokenDetails {
reasoning_tokens: Option<u64>,
}
fn push_openrouter_event(
events: &mut Vec<EpiphanyOpenAiStreamEvent>,
request_id: &str,
payload: EpiphanyOpenAiStreamPayload,
) {
events.push(EpiphanyOpenAiStreamEvent {
request_id: request_id.into(),
sequence: events.len() as u64,
payload,
});
}
fn provider_schema_is_strict(schema: &serde_json::Value) -> bool {
match schema {
serde_json::Value::Object(map) => {
if (map.contains_key("const") || map.contains_key("enum")) && !map.contains_key("type")
{
return false;
}
if schema_map_describes_object(map) {
if map.get("additionalProperties") != Some(&serde_json::Value::Bool(false)) {
return false;
}
let Some(properties) = map.get("properties").and_then(serde_json::Value::as_object)
else {
return false;
};
let Some(required) = map.get("required").and_then(serde_json::Value::as_array)
else {
return false;
};
if properties
.keys()
.any(|key| !required.iter().any(|item| item.as_str() == Some(key)))
{
return false;
}
}
map.values().all(provider_schema_is_strict)
}
serde_json::Value::Array(values) => values.iter().all(provider_schema_is_strict),
_ => true,
}
}
fn close_provider_objects(schema: &mut serde_json::Value, path: &str) -> anyhow::Result<()> {
match schema {
serde_json::Value::Object(map) => {
let describes_object = schema_map_describes_object(map);
if describes_object {
map.insert("type".into(), serde_json::Value::String("object".into()));
let properties = map
.get("properties")
.and_then(serde_json::Value::as_object)
.cloned()
.unwrap_or_default();
let canonical_required = map
.get("required")
.and_then(serde_json::Value::as_array)
.cloned()
.unwrap_or_default();
for required in &canonical_required {
let required = required.as_str().ok_or_else(|| {
anyhow::anyhow!("provider schema {path} has a non-string required key")
})?;
if !properties.contains_key(required) {
return Err(anyhow::anyhow!(
"provider schema {path} requires undeclared property {required:?}"
));
}
}
let canonical_required = canonical_required
.into_iter()
.filter_map(|value| value.as_str().map(ToOwned::to_owned))
.collect::<std::collections::BTreeSet<_>>();
let mut projected = serde_json::Map::new();
for (name, mut property) in properties {
close_provider_objects(&mut property, &format!("{path}.properties.{name}"))?;
if !canonical_required.contains(&name) {
property = nullable_provider_property(property);
}
projected.insert(name, property);
}
let required = projected
.keys()
.cloned()
.map(serde_json::Value::String)
.collect();
map.insert("properties".into(), serde_json::Value::Object(projected));
map.insert("required".into(), serde_json::Value::Array(required));
map.insert(
"additionalProperties".into(),
serde_json::Value::Bool(false),
);
}
for (name, value) in map.iter_mut() {
if name != "properties" || !describes_object {
close_provider_objects(value, &format!("{path}.{name}"))?;
}
}
Ok(())
}
serde_json::Value::Array(values) => {
for (index, value) in values.iter_mut().enumerate() {
close_provider_objects(value, &format!("{path}[{index}]"))?;
}
Ok(())
}
_ => Ok(()),
}
}
fn schema_map_describes_object(map: &serde_json::Map<String, serde_json::Value>) -> bool {
map.get("type").and_then(serde_json::Value::as_str) == Some("object")
|| [
"properties",
"required",
"additionalProperties",
"patternProperties",
"propertyNames",
"minProperties",
"maxProperties",
]
.iter()
.any(|keyword| map.contains_key(*keyword))
}
fn parent_relative_object_alternatives(value: &serde_json::Value) -> bool {
let Some(alternatives) = value.as_array() else {
return false;
};
!alternatives.is_empty()
&& alternatives.iter().all(|alternative| {
let Some(map) = alternative.as_object() else {
return false;
};
!map.contains_key("type")
&& !map.contains_key("$ref")
&& map
.keys()
.any(|key| matches!(key.as_str(), "properties" | "required"))
&& map.keys().all(|key| {
matches!(
key.as_str(),
"properties" | "required" | "title" | "description" | "$comment"
)
})
})
}
fn infer_literal_type(map: &mut serde_json::Map<String, serde_json::Value>) {
if map.contains_key("type") {
return;
}
let mut types = std::collections::BTreeSet::new();
if let Some(value) = map.get("const") {
types.insert(json_type(value));
} else if let Some(values) = map.get("enum").and_then(serde_json::Value::as_array) {
types.extend(values.iter().map(json_type));
}
match types.len() {
0 => {}
1 => {
map.insert(
"type".into(),
serde_json::Value::String(types.into_iter().next().expect("one type").into()),
);
}
_ => {
map.insert(
"type".into(),
serde_json::Value::Array(
types
.into_iter()
.map(|value| serde_json::Value::String(value.into()))
.collect(),
),
);
}
}
}
fn json_type(value: &serde_json::Value) -> &'static str {
match value {
serde_json::Value::Null => "null",
serde_json::Value::Bool(_) => "boolean",
serde_json::Value::Number(number) if number.is_i64() || number.is_u64() => "integer",
serde_json::Value::Number(_) => "number",
serde_json::Value::String(_) => "string",
serde_json::Value::Array(_) => "array",
serde_json::Value::Object(_) => "object",
}
}
fn nullable_provider_property(property: serde_json::Value) -> serde_json::Value {
if property
.get("anyOf")
.and_then(serde_json::Value::as_array)
.is_some_and(|variants| {
variants.iter().any(|variant| {
variant.get("type").and_then(serde_json::Value::as_str) == Some("null")
})
})
{
property
} else {
serde_json::json!({"anyOf": [property, {"type": "null"}]})
}
}
const UNSUPPORTED_PROVIDER_SCHEMA_KEYWORDS: &[&str] = &[
"allOf",
"not",
"dependentRequired",
"dependentSchemas",
"if",
"then",
"else",
"patternProperties",
"propertyNames",
"minProperties",
"maxProperties",
"unevaluatedProperties",
"uniqueItems",
"contains",
"minContains",
"maxContains",
"prefixItems",
"unevaluatedItems",
"default",
"examples",
"readOnly",
"writeOnly",
"$schema",
"$id",
"$anchor",
"$dynamicAnchor",
"$dynamicRef",
"$vocabulary",
];
fn lower_provider_schema(schema: &mut serde_json::Value) {
let serde_json::Value::Object(map) = schema else {
return;
};
infer_literal_type(map);
if map.get("format").and_then(serde_json::Value::as_str) == Some("uuid") {
map.remove("format");
map.entry("pattern").or_insert_with(|| {
serde_json::Value::String(
"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
.into(),
)
});
}
for keyword in UNSUPPORTED_PROVIDER_SCHEMA_KEYWORDS {
map.remove(*keyword);
}
if let Some(one_of) = map.remove("oneOf") {
map.insert("anyOf".into(), one_of);
}
if map
.get("anyOf")
.is_some_and(parent_relative_object_alternatives)
{
map.remove("anyOf");
}
for collection in ["properties", "$defs", "definitions"] {
if let Some(serde_json::Value::Object(children)) = map.get_mut(collection) {
for child in children.values_mut() {
lower_provider_schema(child);
}
}
}
if let Some(items) = map.get_mut("items") {
match items {
serde_json::Value::Array(items) => {
for item in items {
lower_provider_schema(item);
}
}
item => lower_provider_schema(item),
}
}
if let Some(serde_json::Value::Array(alternatives)) = map.get_mut("anyOf") {
for alternative in alternatives {
lower_provider_schema(alternative);
}
}
}
@ -247,4 +861,94 @@ mod tests {
);
assert_ne!(openai.schema_id, "epiphany.openai_model_request.v0");
}
#[test]
fn provider_projection_closes_objects_without_keeping_parent_conditions() {
let schema = strict_provider_schema(
r#"{
"type":"object",
"properties":{"choice":{"type":"string"},"note":{"type":"string"}},
"required":["choice"],
"allOf":[{"if":{"properties":{"choice":{"const":"x"}}}}],
"anyOf":[{"required":["choice"]},{"required":["note"]}]
}"#,
)
.unwrap();
assert_eq!(schema["additionalProperties"], false);
assert_eq!(schema["required"], serde_json::json!(["choice", "note"]));
assert!(schema.get("allOf").is_none());
assert!(schema.get("anyOf").is_none());
assert_eq!(schema["properties"]["note"]["anyOf"][1]["type"], "null");
}
#[test]
fn provider_projection_types_literals_and_lowers_uuid() {
let schema = strict_provider_schema(
r#"{
"type":"object",
"properties":{
"kind":{"const":"ready"},
"id":{"type":"string","format":"uuid"},
"items":{"type":"array","uniqueItems":true,"items":{"enum":[1,2]}}
},
"required":["kind","id","items"]
}"#,
)
.unwrap();
assert_eq!(schema["properties"]["kind"]["type"], "string");
assert!(schema["properties"]["id"].get("format").is_none());
assert!(schema["properties"]["id"]["pattern"].is_string());
assert!(schema["properties"]["items"].get("uniqueItems").is_none());
assert_eq!(schema["properties"]["items"]["items"]["type"], "integer");
}
#[test]
fn provider_identities_are_stable_and_bounded() {
assert_eq!(provider_format_name("role/result.v1"), "role_result_v1");
assert_eq!(provider_call_id("already-safe_1"), "already-safe_1");
let first = provider_call_id("unsafe/call identity");
assert_eq!(first, provider_call_id("unsafe/call identity"));
assert_eq!(first.len(), 64);
assert!(first.bytes().all(|byte| byte.is_ascii_hexdigit()));
}
#[test]
fn openrouter_terminal_tool_preserves_structured_decision() {
let mut request =
EpiphanyOpenAiModelRequest::new("request", "conversation", "ox", "decide");
request.provider_id = "openrouter".into();
request.wire_dialect = EpiphanyOpenAiWireDialect::ChatCompletionsTerminalTool;
request.output_schema_json = Some(
r#"{"type":"object","properties":{"verdict":{"type":"string"}},"required":["verdict"]}"#.into(),
);
let body = openrouter_request_body(&request).unwrap();
assert_eq!(body["tool_choice"], "required");
assert_eq!(
body["tools"][0]["function"]["name"],
OPENROUTER_TERMINAL_TOOL_NAME
);
let response = serde_json::json!({
"id": "response",
"model": "ox",
"choices": [{"message": {"tool_calls": [{
"id": "terminal",
"function": {"name": OPENROUTER_TERMINAL_TOOL_NAME, "arguments": "{\"verdict\":\"pass\"}"}
}]}}]
});
let events =
openrouter_events_from_response(&request, &serde_json::to_vec(&response).unwrap())
.unwrap();
assert!(matches!(
&events[0].payload,
EpiphanyOpenAiStreamPayload::TextDelta { text } if text == "{\"verdict\":\"pass\"}"
));
assert!(matches!(
&events[1].payload,
EpiphanyOpenAiStreamPayload::Completed { receipt }
if receipt.transport.as_deref() == Some("openrouter-chat-completions")
));
}
}

View file

@ -1,21 +0,0 @@
[package]
name = "epiphany-openai-codex-spine"
version = "0.1.0"
edition = "2024"
publish = false
license-file = "../LICENSE"
[lib]
name = "epiphany_openai_codex_spine"
path = "src/lib.rs"
[dependencies]
anyhow = "1"
codex-client = { path = "../vendor/codex/codex-rs/codex-client" }
codex-login = { path = "../vendor/codex/codex-rs/login" }
epiphany-openai-adapter = { path = "../epiphany-openai-adapter" }
http = "1"
serde = "1"
serde_json = "1"
sha2 = "0.10"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

File diff suppressed because it is too large Load diff

View file

@ -1,5 +1,6 @@
use std::env;
use std::fs;
use std::net::SocketAddr;
use std::path::Path;
use std::path::PathBuf;
use std::process;
@ -20,7 +21,7 @@ use epiphany_openai_adapter::{
EpiphanyOpenAiModelReceipt, EpiphanyOpenAiModelRequest, EpiphanyOpenAiStreamEvent,
EpiphanyOpenAiStreamPayload,
};
use epiphany_openai_codex_spine::default_codex_home;
use epiphany_openai_runtime::DEFAULT_CODEX_CONNECTOR_ENDPOINT;
use epiphany_openai_runtime::DEFAULT_PROVIDER_REQUEST_TIMEOUT;
use epiphany_openai_runtime::EpiphanyOpenAiRuntimeOptions;
#[cfg(test)]
@ -179,8 +180,9 @@ async fn main() -> Result<()> {
struct RunWorkerCliOptions {
provider: String,
store_path: PathBuf,
codex_home: PathBuf,
provider_credential_path: Option<PathBuf>,
connector_endpoint: SocketAddr,
caller_runtime_id: String,
mcp_config: Option<PathBuf>,
job_id: String,
model: String,
@ -195,8 +197,9 @@ struct RunWorkerCliOptions {
fn parse_run_worker_options(args: Vec<String>) -> Result<RunWorkerCliOptions> {
let mut provider = DEFAULT_PROVIDER.to_string();
let mut store_path = PathBuf::from(DEFAULT_STORE);
let mut codex_home = default_codex_home()?;
let mut provider_credential_path = None;
let mut connector_endpoint = DEFAULT_CODEX_CONNECTOR_ENDPOINT;
let mut caller_runtime_id = "epiphany-model-runtime".to_string();
let mut mcp_config = None;
let mut job_id = None;
let mut model = default_worker_model();
@ -211,13 +214,18 @@ fn parse_run_worker_options(args: Vec<String>) -> Result<RunWorkerCliOptions> {
match arg.as_str() {
"--provider" => provider = next_value(&mut iter, "--provider")?,
"--store" => store_path = PathBuf::from(next_value(&mut iter, "--store")?),
"--codex-home" => codex_home = PathBuf::from(next_value(&mut iter, "--codex-home")?),
"--provider-credential" => {
provider_credential_path = Some(PathBuf::from(next_value(
&mut iter,
"--provider-credential",
)?))
}
"--connector-endpoint" => {
connector_endpoint = next_value(&mut iter, "--connector-endpoint")?.parse()?
}
"--caller-runtime-id" => {
caller_runtime_id = next_value(&mut iter, "--caller-runtime-id")?
}
"--mcp-config" => {
mcp_config = Some(PathBuf::from(next_value(&mut iter, "--mcp-config")?))
}
@ -245,8 +253,9 @@ fn parse_run_worker_options(args: Vec<String>) -> Result<RunWorkerCliOptions> {
Ok(RunWorkerCliOptions {
provider,
store_path,
codex_home,
provider_credential_path,
connector_endpoint,
caller_runtime_id,
mcp_config,
job_id: job_id.context("run-worker requires --job-id")?,
model,
@ -482,8 +491,9 @@ async fn run_worker_launch(
)?;
let openai_options = EpiphanyOpenAiRuntimeOptions {
store_path: options.store_path.clone(),
codex_home: options.codex_home.clone(),
provider_credential_path: options.provider_credential_path.clone(),
connector_endpoint: Some(options.connector_endpoint),
caller_runtime_id: options.caller_runtime_id.clone(),
session_id: worker_model_session_id(&launch_request.job_id),
job_id: format!("openai-worker-{}", launch_request.job_id),
objective: format!(
@ -910,6 +920,121 @@ mod tests {
Ok(())
}
#[test]
fn codex_connector_projection_is_one_strict_deterministic_request() -> Result<()> {
let mut request = EpiphanyOpenAiModelRequest::new(
"connector-request",
"connector-conversation",
"gpt-test",
"Decide.",
);
request.output_contract_id = Some("role/result.v1".into());
request.output_schema_json = Some(
r#"{"type":"object","properties":{"verdict":{"const":"pass"}},"required":["verdict"]}"#
.into(),
);
request
.tools
.push(epiphany_openai_adapter::EpiphanyOpenAiToolDefinition {
name: "inspect_body".into(),
description: "Inspect the typed Body.".into(),
parameters_json:
r#"{"type":"object","properties":{"path":{"type":"string"}},"required":["path"]}"#
.into(),
});
request
.input
.push(epiphany_openai_adapter::EpiphanyOpenAiInputItem::ToolCall {
call_id: "native/call".into(),
name: "inspect_body".into(),
arguments: r#"{"path":"src/lib.rs"}"#.into(),
});
request.input.push(
epiphany_openai_adapter::EpiphanyOpenAiInputItem::ToolResult {
call_id: "native/call".into(),
output: r#"{"ok":true}"#.into(),
},
);
let projected = provider_transport::codex_request_from_epiphany(request)?;
assert_eq!(
projected.output_format_name.as_deref(),
Some("role_result_v1")
);
assert_eq!(
projected.tool_choice,
codex_connector::CodexToolChoice::Auto
);
let (call, result) = (&projected.input[0], &projected.input[1]);
let codex_connector::CodexInputItem::ToolCall { call_id, .. } = call else {
panic!("first input must remain a tool call")
};
let codex_connector::CodexInputItem::ToolResult {
call_id: result_id, ..
} = result
else {
panic!("second input must remain a tool result")
};
assert_eq!(call_id, result_id);
assert_ne!(call_id, "native/call");
assert_eq!(call_id.len(), 64);
assert_eq!(
serde_json::from_str::<serde_json::Value>(
projected.output_schema_json.as_deref().unwrap()
)?["properties"]["verdict"]["type"],
"string"
);
Ok(())
}
#[test]
fn connector_receipt_digests_survive_without_transport_transcript() -> Result<()> {
let result = codex_connector::CodexTransportResult {
schema_id: codex_connector::RESULT_SCHEMA_ID.into(),
request_id: "connector-request".into(),
caller_runtime_id: "epiphany-test".into(),
disposition: codex_connector::CodexTransportDisposition::Transported {
events: Vec::new(),
receipt: Box::new(codex_connector::CodexTransportReceipt {
schema_id: codex_connector::RECEIPT_SCHEMA_ID.into(),
request_id: "connector-request".into(),
caller_runtime_id: "epiphany-test".into(),
native_request_sha256: [0x11; 32],
provider_request_sha256: [0x22; 32],
model: "gpt-test".into(),
transport: "fake-connector".into(),
outcome: codex_connector::CodexTransportOutcome::Completed {
provider_response_id: Some("response".into()),
input_tokens: Some(10),
output_tokens: Some(4),
reasoning_output_tokens: Some(2),
cached_input_tokens: Some(6),
},
}),
},
};
let events = provider_transport::events_from_connector_result(result)?;
assert_eq!(events.len(), 1);
let EpiphanyOpenAiStreamPayload::Completed { receipt } = &events[0].payload else {
panic!("connector result must produce one terminal receipt")
};
let native_digest = "11".repeat(32);
let provider_digest = "22".repeat(32);
assert_eq!(receipt.caller_runtime_id.as_deref(), Some("epiphany-test"));
assert_eq!(
receipt.native_request_sha256.as_deref(),
Some(native_digest.as_str())
);
assert_eq!(
receipt.provider_request_sha256.as_deref(),
Some(provider_digest.as_str())
);
assert_eq!(receipt.cached_input_tokens, Some(6));
assert_eq!(receipt.transport.as_deref(), Some("fake-connector"));
Ok(())
}
#[test]
fn every_static_worker_contract_projects_to_one_strict_provider_shape() -> Result<()> {
let schemas = vec![
@ -942,8 +1067,10 @@ mod tests {
);
request.output_contract_id = Some(format!("worker-schema-{index}"));
request.output_schema_json = Some(serde_json::to_string(&schema)?);
let body = epiphany_openai_codex_spine::responses_body_from_epiphany(request)?;
assert_eq!(body["text"]["format"]["strict"], true);
let projected = epiphany_openai_adapter::strict_provider_schema(
request.output_schema_json.as_deref().unwrap(),
)?;
assert_eq!(projected["additionalProperties"], false);
}
Ok(())
}
@ -964,8 +1091,10 @@ mod tests {
),
)?);
let body = epiphany_openai_codex_spine::responses_body_from_epiphany(request)?;
let decision = &body["text"]["format"]["schema"]["properties"]["researchDecision"];
let projected = epiphany_openai_adapter::strict_provider_schema(
request.output_schema_json.as_deref().unwrap(),
)?;
let decision = &projected["properties"]["researchDecision"];
assert!(decision.get("anyOf").is_none());
assert_eq!(decision["additionalProperties"], false);
assert_eq!(
@ -1034,8 +1163,9 @@ mod tests {
store,
&EpiphanyOpenAiRuntimeOptions {
store_path: store.to_path_buf(),
codex_home: PathBuf::from(".codex"),
provider_credential_path: None,
connector_endpoint: Some(DEFAULT_CODEX_CONNECTOR_ENDPOINT),
caller_runtime_id: "epiphany-model-runtime-test".to_string(),
session_id,
job_id,
objective: format!("Run model execution for {worker_job_id}."),
@ -1057,7 +1187,9 @@ mod tests {
EpiphanyOpenAiStreamEvent {
request_id: request_id.to_string(),
sequence: 1,
payload: EpiphanyOpenAiStreamPayload::Completed { receipt },
payload: EpiphanyOpenAiStreamPayload::Completed {
receipt: Box::new(receipt),
},
},
],
)
@ -1542,5 +1674,5 @@ fn now() -> String {
}
fn usage() -> &'static str {
"usage: epiphany-model-runtime <list-decisions|audit-decision|run-worker> [--provider openai-codex|openrouter] [--provider-credential path] [--store path] [--codex-home path] [--context-id id] [--output path] [--job-id id] [--activation-token-sha256 hex] [--default-model model] --tool-adapter-bin path [--mcp-config path] [--cwd path] [--max-tool-rounds n]"
"usage: epiphany-model-runtime <list-decisions|audit-decision|run-worker> [--provider openai-codex|openrouter] [--provider-credential path] [--connector-endpoint 127.0.0.1:17891] [--caller-runtime-id id] [--store path] [--context-id id] [--output path] [--job-id id] [--activation-token-sha256 hex] [--default-model model] --tool-adapter-bin path [--mcp-config path] [--cwd path] [--max-tool-rounds n]"
}

View file

@ -19,8 +19,8 @@ use epiphany_core::{
};
use epiphany_model_adapter::EpiphanyModelRequest;
use epiphany_openai_runtime::{
EpiphanyOpenAiRuntimeOptions, PersonaModelExecutionPlan, PersonaModelRunner,
assistant_text_from_model_events, execute_persona_model_turn,
DEFAULT_CODEX_CONNECTOR_ENDPOINT, EpiphanyOpenAiRuntimeOptions, PersonaModelExecutionPlan,
PersonaModelRunner, assistant_text_from_model_events, execute_persona_model_turn,
};
#[path = "../provider_transport.rs"]
@ -29,8 +29,9 @@ mod provider_transport;
#[derive(Clone, Debug)]
struct NativePersonaModelRunner {
store_path: PathBuf,
codex_home: PathBuf,
provider_credential_path: Option<PathBuf>,
connector_endpoint: SocketAddr,
caller_runtime_id: String,
provider: String,
model: String,
turn_timeout: Duration,
@ -54,8 +55,9 @@ impl PersonaModelRunner for NativePersonaModelRunner {
}
let options = EpiphanyOpenAiRuntimeOptions {
store_path: self.store_path.clone(),
codex_home: self.codex_home.clone(),
provider_credential_path: self.provider_credential_path.clone(),
connector_endpoint: Some(self.connector_endpoint),
caller_runtime_id: self.caller_runtime_id.clone(),
session_id: format!("persona-turn-{turn_id}"),
job_id: format!("persona-{stage}-{turn_id}"),
objective: format!("Run Persona {stage} stage for {turn_id}"),
@ -173,8 +175,9 @@ async fn poll_once(options: &Options) -> Result<bool> {
)?;
let mut runner = NativePersonaModelRunner {
store_path: options.runtime_store.clone(),
codex_home: options.codex_home.clone(),
provider_credential_path: options.provider_credential_path.clone(),
connector_endpoint: options.connector_endpoint,
caller_runtime_id: options.runtime_id.clone(),
provider: options.provider.clone(),
model: options.model.clone(),
turn_timeout: Duration::from_secs(options.turn_timeout_seconds),
@ -365,8 +368,8 @@ struct Options {
runtime_store: PathBuf,
social_store: PathBuf,
cultmesh_store: PathBuf,
codex_home: PathBuf,
provider_credential_path: Option<PathBuf>,
connector_endpoint: SocketAddr,
runtime_id: String,
provider: String,
model: String,
@ -412,8 +415,14 @@ impl Options {
runtime_store: path("--runtime-store")?,
social_store: path("--persona-social-store")?,
cultmesh_store: path("--cultmesh-store")?,
codex_home: path("--codex-home")?,
provider_credential_path: values.get("--provider-credential").map(PathBuf::from),
connector_endpoint: value(
&values,
"--connector-endpoint",
&DEFAULT_CODEX_CONNECTOR_ENDPOINT.to_string(),
)
.parse()
.context("--connector-endpoint must be an IP:port socket address")?,
_repo_root: path("--repo-root")?,
mouth_request_store: path("--mouth-request-store")?,
mouth_receipt_store: path("--mouth-receipt-store")?,
@ -511,8 +520,8 @@ mod tests {
runtime_store: runtime_store.clone(),
social_store: absent.join("persona-social.cc"),
cultmesh_store: absent.join("cultmesh.cc"),
codex_home: absent.join("codex-home"),
provider_credential_path: None,
connector_endpoint: DEFAULT_CODEX_CONNECTOR_ENDPOINT,
runtime_id: "persona-reentry".into(),
provider: "test".into(),
model: "test-model".into(),

View file

@ -1,4 +1,5 @@
use std::collections::{BTreeMap, BTreeSet};
use std::net::SocketAddr;
use std::path::Path;
use std::path::PathBuf;
use std::time::Duration;
@ -51,6 +52,8 @@ pub const OPENAI_RUNTIME_ROLE: &str = "openai-model-adapter";
pub const DEFAULT_PROVIDER_REQUEST_TIMEOUT: Duration = Duration::from_secs(90);
pub const DEFAULT_MODEL_PROVIDER: &str = "openai-codex";
pub const OPENROUTER_MODEL_PROVIDER: &str = "openrouter";
pub const DEFAULT_CODEX_CONNECTOR_ENDPOINT: SocketAddr =
SocketAddr::new(std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST), 17891);
fn validate_model_provider(provider: &str) -> Result<()> {
match provider {
@ -68,8 +71,9 @@ pub fn worker_model_session_id(worker_job_id: &str) -> String {
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EpiphanyOpenAiRuntimeOptions {
pub store_path: PathBuf,
pub codex_home: PathBuf,
pub provider_credential_path: Option<PathBuf>,
pub connector_endpoint: Option<SocketAddr>,
pub caller_runtime_id: String,
pub session_id: String,
pub job_id: String,
pub objective: String,
@ -158,11 +162,11 @@ pub fn record_model_turn_events(
&model_event,
)?;
if let EpiphanyModelStreamPayload::Completed { receipt } = &model_event.payload {
cache.put(model_receipt_key(&receipt.request_id), receipt)?;
cache.put(model_receipt_key(&receipt.request_id), receipt.as_ref())?;
}
match &event.payload {
EpiphanyOpenAiStreamPayload::Completed { receipt: completed } => {
receipt = Some(completed.clone());
receipt = Some(completed.as_ref().clone());
}
EpiphanyOpenAiStreamPayload::Failed { message } => {
failure = Some(message.clone());
@ -821,13 +825,13 @@ pub fn append_requested_public_source_receipts(
pub fn default_options(
store_path: PathBuf,
codex_home: PathBuf,
request: &EpiphanyOpenAiModelRequest,
) -> EpiphanyOpenAiRuntimeOptions {
EpiphanyOpenAiRuntimeOptions {
store_path,
codex_home,
provider_credential_path: None,
connector_endpoint: Some(DEFAULT_CODEX_CONNECTOR_ENDPOINT),
caller_runtime_id: "epiphany-model-runtime".to_string(),
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),
@ -961,7 +965,7 @@ pub fn model_event_from_openai_event(
},
EpiphanyOpenAiStreamPayload::Completed { receipt } => {
EpiphanyModelStreamPayload::Completed {
receipt: model_receipt_from_openai_receipt(provider, receipt),
receipt: Box::new(model_receipt_from_openai_receipt(provider, receipt)),
}
}
EpiphanyOpenAiStreamPayload::Failed { message } => EpiphanyModelStreamPayload::Failed {
@ -985,6 +989,10 @@ pub fn model_receipt_from_openai_receipt(
output_tokens: receipt.output_tokens,
reasoning_output_tokens: receipt.reasoning_output_tokens,
transport: receipt.transport.clone(),
caller_runtime_id: receipt.caller_runtime_id.clone(),
native_request_sha256: receipt.native_request_sha256.clone(),
provider_request_sha256: receipt.provider_request_sha256.clone(),
cached_input_tokens: receipt.cached_input_tokens,
}
}
@ -1591,48 +1599,47 @@ fn role_worker_result_from_ingress(
} else {
(None, None)
};
let (frontier_plan_candidate_msgpack, frontier_plan_candidate_error) = if let Some(ingress) =
result.frontier_plan_candidate.as_ref()
{
let mut safe_paths = clean_string_vec(&ingress.safe_paths);
safe_paths.sort();
safe_paths.dedup();
let mut candidate = epiphany_core::RepoFrontierPlanCandidate {
candidate_id: String::new(),
planning_request_id: frontier_planning_context
.map(|context| context.request_id.clone())
.unwrap_or_default(),
model_projection_digest: frontier_planning_context
.map(|context| context.model_projection_digest.clone())
.unwrap_or_default(),
model_source_documents: frontier_planning_context
.map(|context| context.model_source_documents.clone())
.unwrap_or_default(),
frontier_item_id: frontier_planning_context
.map(|context| context.frontier_item_id.clone())
.unwrap_or_default(),
frontier_item_hash: frontier_planning_context
.map(|context| context.frontier_item_hash.clone())
.unwrap_or_default(),
safe_paths,
action: ingress.action.trim().to_string(),
command: ingress.command.trim().to_string(),
checks: clean_string_vec(&ingress.checks),
stop_conditions: clean_string_vec(&ingress.stop_conditions),
rollback_steps: clean_string_vec(&ingress.rollback_steps),
commit_message: ingress.commit_message.trim().to_string(),
proposed_at: completed_at.to_string(),
};
match epiphany_core::canonical_repo_frontier_plan_candidate_id(&candidate) {
Ok(candidate_id) => {
candidate.candidate_id = candidate_id;
encode_optional_document(&Some(candidate), "frontierPlanCandidate")
let (frontier_plan_candidate_msgpack, frontier_plan_candidate_error) =
if let Some(ingress) = result.frontier_plan_candidate.as_ref() {
let mut safe_paths = clean_string_vec(&ingress.safe_paths);
safe_paths.sort();
safe_paths.dedup();
let mut candidate = epiphany_core::RepoFrontierPlanCandidate {
candidate_id: String::new(),
planning_request_id: frontier_planning_context
.map(|context| context.request_id.clone())
.unwrap_or_default(),
model_projection_digest: frontier_planning_context
.map(|context| context.model_projection_digest.clone())
.unwrap_or_default(),
model_source_documents: frontier_planning_context
.map(|context| context.model_source_documents.clone())
.unwrap_or_default(),
frontier_item_id: frontier_planning_context
.map(|context| context.frontier_item_id.clone())
.unwrap_or_default(),
frontier_item_hash: frontier_planning_context
.map(|context| context.frontier_item_hash.clone())
.unwrap_or_default(),
safe_paths,
action: ingress.action.trim().to_string(),
command: ingress.command.trim().to_string(),
checks: clean_string_vec(&ingress.checks),
stop_conditions: clean_string_vec(&ingress.stop_conditions),
rollback_steps: clean_string_vec(&ingress.rollback_steps),
commit_message: ingress.commit_message.trim().to_string(),
proposed_at: completed_at.to_string(),
};
match epiphany_core::canonical_repo_frontier_plan_candidate_id(&candidate) {
Ok(candidate_id) => {
candidate.candidate_id = candidate_id;
encode_optional_document(&Some(candidate), "frontierPlanCandidate")
}
Err(error) => (None, Some(format!("frontierPlanCandidate: {error}"))),
}
Err(error) => (None, Some(format!("frontierPlanCandidate: {error}"))),
}
} else {
(None, None)
};
} else {
(None, None)
};
let (frontier_plan_mind_decision_msgpack, frontier_plan_mind_decision_error) =
if let Some(ingress) = result.frontier_plan_mind_decision.as_ref() {
if let Some(decision) = ingress.decision {
@ -3038,7 +3045,7 @@ mod tests {
"req-1",
4,
EpiphanyOpenAiStreamPayload::Completed {
receipt: EpiphanyOpenAiModelReceipt::new("req-1", "gpt-5.4"),
receipt: Box::new(EpiphanyOpenAiModelReceipt::new("req-1", "gpt-5.4")),
},
),
];
@ -3073,7 +3080,7 @@ mod tests {
"Answer plainly.",
);
let request = epiphany_openai_adapter::request_from_native(&native_request);
let options = default_options(store.clone(), PathBuf::from(".codex"), &request);
let options = default_options(store.clone(), &request);
ensure_openai_runtime_ready(&options)?;
open_runtime_model_execution(
&store,
@ -3097,7 +3104,9 @@ mod tests {
let events = vec![EpiphanyOpenAiStreamEvent {
request_id: "req-1".to_string(),
sequence: 0,
payload: EpiphanyOpenAiStreamPayload::Completed { receipt },
payload: EpiphanyOpenAiStreamPayload::Completed {
receipt: Box::new(receipt),
},
}];
let summary = record_model_turn_events(&store, &options, &native_request, &events)?;
@ -3554,7 +3563,7 @@ mod tests {
native_request.output_schema_json =
Some(r#"{"type":"object","required":["researchDecision"]}"#.to_string());
let request = epiphany_openai_adapter::request_from_native(&native_request);
let options = default_options(store.clone(), PathBuf::from(".codex"), &request);
let options = default_options(store.clone(), &request);
ensure_openai_runtime_ready(&options)?;
open_runtime_model_execution(
&store,
@ -3588,7 +3597,9 @@ mod tests {
EpiphanyOpenAiStreamEvent {
request_id: "req-tools".to_string(),
sequence: 1,
payload: EpiphanyOpenAiStreamPayload::Completed { receipt },
payload: EpiphanyOpenAiStreamPayload::Completed {
receipt: Box::new(receipt),
},
},
];
let summary = record_model_turn_events(&store, &options, &native_request, &events)?;

View file

@ -1,15 +1,31 @@
use std::io::Read;
use std::path::Path;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use anyhow::{Context, Result, anyhow};
use codex_connector::{
CodexConnectorClient, CodexInputItem, CodexProviderRequest, CodexToolChoice,
CodexToolDefinition, CodexTransportDisposition, CodexTransportEventPayload,
CodexTransportInvocation, CodexTransportOutcome,
};
use epiphany_model_adapter::EpiphanyModelRequest;
use epiphany_openai_adapter::{EpiphanyOpenAiStreamEvent, EpiphanyOpenAiStreamPayload};
use epiphany_openai_codex_spine::{
EpiphanyCodexOpenAiTransport, EpiphanyOpenRouterTransport, auth_manager,
use epiphany_openai_adapter::{
EpiphanyOpenAiInputItem, EpiphanyOpenAiModelReceipt, EpiphanyOpenAiModelRequest,
EpiphanyOpenAiStreamEvent, EpiphanyOpenAiStreamPayload, EpiphanyOpenAiWireDialect,
openrouter_events_from_response, openrouter_request_body, provider_call_id,
provider_format_name, strict_provider_schema,
};
use epiphany_openai_runtime::{
EpiphanyOpenAiRuntimeOptions, EpiphanyOpenAiRuntimeRunSummary, OPENROUTER_MODEL_PROVIDER,
open_model_turn, record_model_turn_events,
};
use sha2::{Digest, Sha256};
use zeroize::Zeroizing;
const OPENROUTER_COMPLETIONS_URL: &str = "https://openrouter.ai/api/v1/chat/completions";
const MAX_CONNECTOR_FRAME_BYTES: usize = 32 * 1024 * 1024;
const MAX_OPENROUTER_RESPONSE_BYTES: u64 = 16 * 1024 * 1024;
const INVOCATION_ADMISSION_WINDOW: Duration = Duration::from_secs(60);
pub async fn run_model_turn(
provider: &str,
@ -17,33 +33,273 @@ pub async fn run_model_turn(
request: EpiphanyModelRequest,
) -> Result<EpiphanyOpenAiRuntimeRunSummary> {
let provider_request = open_model_turn(provider, &options, &request)?;
let request_id = request.request_id.clone();
let events = match provider {
"openai-codex" | "openai" => {
let transport =
EpiphanyCodexOpenAiTransport::openai(auth_manager(options.codex_home.clone()));
collect_transport_events(
transport.collect_model_events(provider_request),
&request.request_id,
execute_codex_connector(&options, &request, provider_request),
&request_id,
)
.await
}
OPENROUTER_MODEL_PROVIDER => {
let credential = read_static_provider_credential(
options.provider_credential_path.as_deref(),
OPENROUTER_MODEL_PROVIDER,
)?;
let transport = EpiphanyOpenRouterTransport::new(credential, options.request_timeout)?;
collect_transport_events(
transport.collect_model_events(provider_request),
&request.request_id,
)
.await
collect_transport_events(execute_openrouter(&options, provider_request), &request_id)
.await
}
_ => unreachable!("open_model_turn validates provider identity"),
};
record_model_turn_events(&options.store_path, &options, &request, &events)
}
async fn execute_codex_connector(
options: &EpiphanyOpenAiRuntimeOptions,
native_request: &EpiphanyModelRequest,
request: EpiphanyOpenAiModelRequest,
) -> Result<Vec<EpiphanyOpenAiStreamEvent>> {
let endpoint = options
.connector_endpoint
.ok_or_else(|| anyhow!("Codex provider requires an explicit connector endpoint"))?;
let caller_runtime_id = options.caller_runtime_id.clone();
if caller_runtime_id.trim().is_empty() || caller_runtime_id.trim() != caller_runtime_id {
return Err(anyhow!(
"Codex connector caller runtime identity is invalid"
));
}
let connection_key = Zeroizing::new(read_static_provider_credential(
options.provider_credential_path.as_deref(),
"codex-connector",
)?);
let native_request_sha256: [u8; 32] = Sha256::digest(rmp_serde::to_vec(native_request)?).into();
let provider_request = codex_request_from_epiphany(request)?;
let expires_at_unix_ms = unix_time_ms()?
.checked_add(INVOCATION_ADMISSION_WINDOW.as_millis() as u64)
.ok_or_else(|| anyhow!("Codex connector invocation expiry overflowed"))?;
let invocation = CodexTransportInvocation::new(
caller_runtime_id,
expires_at_unix_ms,
native_request_sha256,
provider_request,
)?;
let client = CodexConnectorClient::new(
endpoint,
connection_key.as_str().to_string(),
MAX_CONNECTOR_FRAME_BYTES,
options.request_timeout,
)?;
tokio::task::spawn_blocking(move || {
let result = client.execute(&invocation)?;
events_from_connector_result(result)
})
.await
.context("Codex connector client task failed")?
}
pub(super) fn codex_request_from_epiphany(
request: EpiphanyOpenAiModelRequest,
) -> Result<CodexProviderRequest> {
if !matches!(request.provider_id.as_str(), "openai-codex" | "openai")
|| request.wire_dialect != EpiphanyOpenAiWireDialect::Responses
{
return Err(anyhow!(
"Codex connector requires an OpenAI provider identity and Responses dialect"
));
}
let has_tool_result = request
.input
.iter()
.any(|item| matches!(item, EpiphanyOpenAiInputItem::ToolResult { .. }));
let output_format_name = request.output_schema_json.as_ref().map(|_| {
provider_format_name(
request
.output_contract_id
.as_deref()
.unwrap_or(&request.request_id),
)
});
let output_schema_json = request
.output_schema_json
.as_deref()
.map(strict_provider_schema)
.transpose()?
.map(|schema| serde_json::to_string(&schema))
.transpose()?;
let tools = request
.tools
.into_iter()
.map(|tool| {
Ok(CodexToolDefinition {
name: tool.name,
description: tool.description,
parameters_json: serde_json::to_string(&strict_provider_schema(
&tool.parameters_json,
)?)?,
})
})
.collect::<Result<Vec<_>>>()?;
let tool_choice = if !tools.is_empty() && !has_tool_result {
CodexToolChoice::Required
} else {
CodexToolChoice::Auto
};
let input = request
.input
.into_iter()
.map(|item| match item {
EpiphanyOpenAiInputItem::UserText { text } => CodexInputItem::UserText { text },
EpiphanyOpenAiInputItem::AssistantText { text } => {
CodexInputItem::AssistantText { text }
}
EpiphanyOpenAiInputItem::ToolCall {
call_id,
name,
arguments,
} => CodexInputItem::ToolCall {
call_id: provider_call_id(&call_id),
name,
arguments,
},
EpiphanyOpenAiInputItem::ToolResult { call_id, output } => CodexInputItem::ToolResult {
call_id: provider_call_id(&call_id),
output,
},
})
.collect();
let mut provider_request = CodexProviderRequest::new(
request.request_id,
request.conversation_id,
request.model,
request.instructions,
);
provider_request.input = input;
provider_request.reasoning_effort = request.reasoning_effort;
provider_request.reasoning_summary = request.reasoning_summary;
provider_request.service_tier = request.service_tier;
provider_request.output_format_name = output_format_name;
provider_request.previous_response_id = request.previous_response_id;
provider_request.tools = tools;
provider_request.tool_choice = tool_choice;
provider_request.parallel_tool_calls = false;
provider_request.output_schema_json = output_schema_json;
provider_request.validate()?;
Ok(provider_request)
}
pub(super) fn events_from_connector_result(
result: codex_connector::CodexTransportResult,
) -> Result<Vec<EpiphanyOpenAiStreamEvent>> {
let request_id = result.request_id.clone();
match result.disposition {
CodexTransportDisposition::Refused(reason) => Err(anyhow!(
"Codex connector refused request {request_id:?}: {reason:?}"
)),
CodexTransportDisposition::Transported { events, receipt } => {
let mut projected = events
.into_iter()
.map(|event| EpiphanyOpenAiStreamEvent {
request_id: request_id.clone(),
sequence: event.sequence,
payload: match event.payload {
CodexTransportEventPayload::TextDelta { text } => {
EpiphanyOpenAiStreamPayload::TextDelta { text }
}
CodexTransportEventPayload::ToolCall {
call_id,
name,
arguments,
} => EpiphanyOpenAiStreamPayload::ToolCall {
call_id,
name,
arguments,
},
},
})
.collect::<Vec<_>>();
let mut terminal = EpiphanyOpenAiModelReceipt::new(&request_id, &receipt.model);
terminal.transport = Some(receipt.transport.clone());
terminal.caller_runtime_id = Some(receipt.caller_runtime_id.clone());
terminal.native_request_sha256 = Some(hex_digest(receipt.native_request_sha256));
terminal.provider_request_sha256 = Some(hex_digest(receipt.provider_request_sha256));
match receipt.outcome {
CodexTransportOutcome::Completed {
provider_response_id,
input_tokens,
output_tokens,
reasoning_output_tokens,
cached_input_tokens,
} => {
terminal.response_id = provider_response_id;
terminal.input_tokens = input_tokens;
terminal.output_tokens = output_tokens;
terminal.reasoning_output_tokens = reasoning_output_tokens;
terminal.cached_input_tokens = cached_input_tokens;
projected.push(EpiphanyOpenAiStreamEvent {
request_id,
sequence: projected.len() as u64,
payload: EpiphanyOpenAiStreamPayload::Completed {
receipt: Box::new(terminal),
},
});
}
CodexTransportOutcome::Failed {
failure_kind,
message,
} => {
projected.push(EpiphanyOpenAiStreamEvent {
request_id,
sequence: projected.len() as u64,
payload: EpiphanyOpenAiStreamPayload::Failed {
message: format!("Codex connector {failure_kind}: {message}"),
},
});
}
}
Ok(projected)
}
}
}
async fn execute_openrouter(
options: &EpiphanyOpenAiRuntimeOptions,
request: EpiphanyOpenAiModelRequest,
) -> Result<Vec<EpiphanyOpenAiStreamEvent>> {
let api_key = Zeroizing::new(read_static_provider_credential(
options.provider_credential_path.as_deref(),
OPENROUTER_MODEL_PROVIDER,
)?);
let request_timeout = options.request_timeout;
tokio::task::spawn_blocking(move || {
let body = serde_json::to_vec(&openrouter_request_body(&request)?)?;
let agent: ureq::Agent = ureq::Agent::config_builder()
.timeout_connect(Some(Duration::from_secs(10)))
.timeout_recv_response(request_timeout)
.timeout_recv_body(request_timeout)
.max_redirects(0)
.build()
.into();
let authorization = Zeroizing::new(format!("Bearer {}", api_key.as_str()));
let response = agent
.post(OPENROUTER_COMPLETIONS_URL)
.header("authorization", authorization.as_str())
.header("content-type", "application/json")
.header("accept", "application/json")
.send(body)
.context("OpenRouter request failed")?;
let mut bytes = Vec::new();
response
.into_body()
.into_reader()
.take(MAX_OPENROUTER_RESPONSE_BYTES + 1)
.read_to_end(&mut bytes)
.context("OpenRouter response read failed")?;
if bytes.len() as u64 > MAX_OPENROUTER_RESPONSE_BYTES {
return Err(anyhow!("OpenRouter response exceeded its byte bound"));
}
openrouter_events_from_response(&request, &bytes)
})
.await
.context("OpenRouter client task failed")?
}
async fn collect_transport_events<F>(future: F, request_id: &str) -> Vec<EpiphanyOpenAiStreamEvent>
where
F: std::future::Future<Output = Result<Vec<EpiphanyOpenAiStreamEvent>>>,
@ -78,3 +334,21 @@ fn read_static_provider_credential(path: Option<&Path>, provider: &str) -> Resul
}
Ok(credential.to_string())
}
fn unix_time_ms() -> Result<u64> {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.context("system clock predates Unix epoch")?
.as_millis()
.try_into()
.context("Unix time does not fit u64 milliseconds")
}
fn hex_digest(digest: [u8; 32]) -> String {
let mut value = String::with_capacity(64);
for byte in digest {
use std::fmt::Write as _;
write!(&mut value, "{byte:02x}").expect("writing to a String cannot fail");
}
value
}