Extract Codex transport from Epiphany
This commit is contained in:
parent
ce22c3b11f
commit
ed7357a28b
17 changed files with 2627 additions and 8314 deletions
5054
Cargo.lock
generated
5054
Cargo.lock
generated
File diff suppressed because it is too large
Load diff
|
|
@ -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"]
|
||||
|
||||
|
|
|
|||
|
|
@ -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(),
|
||||
|
|
|
|||
|
|
@ -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(),
|
||||
|
|
|
|||
|
|
@ -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(),
|
||||
|
|
|
|||
|
|
@ -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(),
|
||||
|
|
|
|||
|
|
@ -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(),
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
));
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
|
@ -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]"
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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(),
|
||||
|
|
|
|||
|
|
@ -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)?;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
Reference in a new issue