Seal exact provider requests before transport

This commit is contained in:
Meta Vens 2026-08-24 23:44:57 +02:00
commit c37cae8bc1
10 changed files with 242 additions and 252 deletions

3
Cargo.lock generated
View file

@ -242,7 +242,7 @@ dependencies = [
[[package]]
name = "codex-connector"
version = "0.1.0"
source = "git+https://github.com/GameCult/CodexConnector?rev=54d8bc2525b7e7fa1b9dd26b95871247ff4c7566#54d8bc2525b7e7fa1b9dd26b95871247ff4c7566"
source = "git+https://github.com/GameCult/CodexConnector?rev=89d965b0495ba817a1e48adda0a28509d6637d31#89d965b0495ba817a1e48adda0a28509d6637d31"
dependencies = [
"aes-gcm",
"base64 0.23.1",
@ -572,6 +572,7 @@ name = "epiphany-openai-adapter"
version = "0.1.0"
dependencies = [
"anyhow",
"codex-connector",
"cultcache-rs",
"epiphany-model-adapter",
"serde",

View file

@ -29,7 +29,7 @@ epiphany-core = { path = "epiphany-core" }
epiphany-model-adapter = { path = "epiphany-model-adapter" }
epiphany-openai-adapter = { path = "epiphany-openai-adapter" }
epiphany-openai-runtime = { path = "epiphany-openai-runtime", optional = true }
codex-connector = { git = "https://github.com/GameCult/CodexConnector", rev = "54d8bc2525b7e7fa1b9dd26b95871247ff4c7566", default-features = false, optional = true }
codex-connector = { git = "https://github.com/GameCult/CodexConnector", rev = "89d965b0495ba817a1e48adda0a28509d6637d31", default-features = false, features = ["client"], optional = true }
epiphany-tool-adapter = { path = "epiphany-tool-adapter" }
epiphany-tool-mcp-runtime = { path = "epiphany-tool-mcp-runtime", optional = true }
rmp-serde = "1"

View file

@ -7,7 +7,9 @@ use crate::{
use anyhow::{Result, anyhow};
use cultcache_rs::{CacheBackingStore, CultCache, CultCacheEnvelope, DatabaseEntry};
use epiphany_model_adapter::EpiphanyModelRequest;
use epiphany_openai_adapter::EpiphanyOpenAiModelRequest;
use epiphany_openai_adapter::EpiphanyProviderRequest;
#[cfg(test)]
use epiphany_openai_adapter::EpiphanyProviderRequestPayload;
use epiphany_tool_adapter::{
EpiphanyToolInvocationIntent, EpiphanyToolInvocationReceipt, receipt_output_for_model,
tool_invocation_intent_key, tool_invocation_receipt_key,
@ -18,7 +20,7 @@ use std::collections::BTreeSet;
use std::path::Path;
pub const REASONING_BASIS_SCHEMA_VERSION: &str = "epiphany.reasoning_basis.v1";
pub const DECISION_CONTEXT_SCHEMA_VERSION: &str = "epiphany.decision_context.v2";
pub const DECISION_CONTEXT_SCHEMA_VERSION: &str = "epiphany.decision_context.v3";
pub const MODEL_PASS_FAILURE_SCHEMA_VERSION: &str = "epiphany.model_pass_failure.v1";
pub const MIND_COMMIT_RECEIPT_SCHEMA_VERSION: &str = "epiphany.mind_commit_receipt.v1";
pub const DECISION_AUDIT_PROJECTION_SCHEMA_VERSION: &str = "epiphany.decision_audit_projection.v1";
@ -342,7 +344,7 @@ pub struct EpiphanyDecisionToolObservation {
#[derive(Clone, Debug, PartialEq, DatabaseEntry)]
#[cultcache(
type = "epiphany.decision_context.v2",
type = "epiphany.decision_context.v3",
schema = "EpiphanyDecisionContext"
)]
pub struct EpiphanyDecisionContext {
@ -369,7 +371,7 @@ impl EpiphanyDecisionContext {
tool_observations: Vec<EpiphanyDecisionToolObservation>,
) -> Result<Self> {
basis.validate()?;
let provider_request = epiphany_openai_adapter::request_from_native(&native_request);
let provider_request = epiphany_openai_adapter::request_from_native(&native_request)?;
validate_request_pair(basis, &native_request, &provider_request)?;
validate_tool_observations(&native_request, &tool_observations)?;
let mut context = Self {
@ -411,7 +413,7 @@ impl EpiphanyDecisionContext {
.map_err(|error| anyhow!("decision native request is invalid: {error}"))
}
pub fn provider_request(&self) -> Result<EpiphanyOpenAiModelRequest> {
pub fn provider_request(&self) -> Result<EpiphanyProviderRequest> {
rmp_serde::from_slice(&self.provider_request_msgpack)
.map_err(|error| anyhow!("decision provider request is invalid: {error}"))
}
@ -633,7 +635,7 @@ pub struct EpiphanyDecisionAuditProjection {
pub decision_context: EpiphanyDecisionContext,
pub reasoning_projection: EpiphanyReasoningProjection,
pub terminal_native_request: EpiphanyModelRequest,
pub terminal_provider_request: EpiphanyOpenAiModelRequest,
pub terminal_provider_request: EpiphanyProviderRequest,
pub tool_observations: Vec<EpiphanyDecisionToolObservation>,
pub terminal_records: EpiphanyDecisionTerminalRecords,
pub mind_commit_receipts: Vec<EpiphanyMindCommitReceipt>,
@ -1340,7 +1342,7 @@ fn validate_context_store_ownership(
.as_ref()
!= Some(&native)
|| cache
.get::<EpiphanyOpenAiModelRequest>(&provider.request_id)?
.get::<EpiphanyProviderRequest>(provider.request_id())?
.as_ref()
!= Some(&provider)
{
@ -1692,12 +1694,12 @@ fn commit_authorized_mind_mutation(
fn validate_request_pair(
basis: &EpiphanyReasoningBasis,
native: &EpiphanyModelRequest,
provider: &EpiphanyOpenAiModelRequest,
provider: &EpiphanyProviderRequest,
) -> Result<()> {
if native.reasoning_basis_id.as_deref() != Some(basis.basis_id.as_str()) {
return Err(anyhow!("model request does not bind its reasoning basis"));
}
if provider != &epiphany_openai_adapter::request_from_native(native) {
if provider != &epiphany_openai_adapter::request_from_native(native)? {
return Err(anyhow!("native and provider terminal requests diverge"));
}
Ok(())
@ -1981,9 +1983,7 @@ mod tests {
)
}
fn requests(
basis: &EpiphanyReasoningBasis,
) -> (EpiphanyModelRequest, EpiphanyOpenAiModelRequest) {
fn requests(basis: &EpiphanyReasoningBasis) -> (EpiphanyModelRequest, EpiphanyProviderRequest) {
let mut native = EpiphanyModelRequest::new(
"request-1",
"conversation-1",
@ -1995,25 +1995,7 @@ mod tests {
native.input.push(EpiphanyModelInputItem::UserText {
text: "projection".into(),
});
let provider = EpiphanyOpenAiModelRequest {
schema_id: epiphany_openai_adapter::OPENAI_ADAPTER_REQUEST_SCHEMA_ID.into(),
request_id: native.request_id.clone(),
conversation_id: native.conversation_id.clone(),
model: native.model.clone(),
instructions: native.instructions.clone(),
input: vec![epiphany_openai_adapter::EpiphanyOpenAiInputItem::UserText {
text: "projection".into(),
}],
reasoning_effort: None,
reasoning_summary: None,
service_tier: None,
output_contract_id: None,
previous_response_id: None,
tools: Vec::new(),
output_schema_json: None,
provider_id: native.provider.clone(),
wire_dialect: epiphany_openai_adapter::EpiphanyOpenAiWireDialect::Responses,
};
let provider = epiphany_openai_adapter::request_from_native(&native).unwrap();
(native, provider)
}
@ -2060,7 +2042,12 @@ mod tests {
let (native, _) = requests(&reasoning_basis);
let context = EpiphanyDecisionContext::new(&reasoning_basis, native.clone(), Vec::new())?;
let mut substituted_provider_input = context.provider_request()?;
substituted_provider_input.input.clear();
match &mut substituted_provider_input.payload {
EpiphanyProviderRequestPayload::Codex(request) => request.input.clear(),
EpiphanyProviderRequestPayload::OpenRouter(_) => {
panic!("test fixture must lower to the Codex provider contract")
}
}
let mut substituted_provider_context = context;
substituted_provider_context.provider_request_msgpack =
rmp_serde::to_vec_named(&substituted_provider_input)?;
@ -2085,7 +2072,7 @@ mod tests {
)?;
assert_eq!(
tool_context.provider_request()?,
epiphany_openai_adapter::request_from_native(&native_with_substituted_tools),
epiphany_openai_adapter::request_from_native(&native_with_substituted_tools)?,
"provider request must be derived from the complete native request"
);
@ -2179,14 +2166,13 @@ mod tests {
let context = EpiphanyDecisionContext::new(&reasoning_basis, native.clone(), Vec::new())?;
let provider = context.provider_request()?;
assert_eq!(provider.provider_id, "openrouter");
assert_eq!(
provider.wire_dialect,
epiphany_openai_adapter::EpiphanyOpenAiWireDialect::ChatCompletionsTerminalTool
);
assert!(matches!(
provider.payload,
EpiphanyProviderRequestPayload::OpenRouter(_)
));
assert_eq!(
provider,
epiphany_openai_adapter::request_from_native(&native)
epiphany_openai_adapter::request_from_native(&native)?
);
Ok(())
}
@ -2608,7 +2594,7 @@ mod tests {
assert_eq!(audit.context_id, context.context_id);
assert_eq!(audit.reasoning_basis, basis);
assert_eq!(audit.terminal_native_request.request_id, "request-1");
assert_eq!(audit.terminal_provider_request.request_id, "request-1");
assert_eq!(audit.terminal_provider_request.request_id(), "request-1");
assert_eq!(
audit.terminal_records.role_worker_results,
vec![terminal_result.clone()]

View file

@ -34,7 +34,7 @@ use epiphany_model_adapter::EpiphanyModelReceipt;
use epiphany_model_adapter::EpiphanyModelRequest;
use epiphany_model_adapter::EpiphanyModelStreamEvent;
use epiphany_model_adapter::EpiphanyModelStreamPayload;
use epiphany_openai_adapter::EpiphanyOpenAiModelRequest;
use epiphany_openai_adapter::EpiphanyProviderRequest;
use epiphany_tool_adapter::EpiphanyToolInvocationIntent;
use epiphany_tool_adapter::EpiphanyToolInvocationReceipt;
use epiphany_tool_adapter::TOOL_ADAPTER_INVOCATION_INTENT_SCHEMA_ID;
@ -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.v46";
pub const RUNTIME_SPINE_SCHEMA_VERSION: &str = "epiphany.runtime_spine.v47";
pub const EPIPHANY_RUNTIME_ROOT_SESSION_ID: &str = "epiphany-main";
#[derive(Clone, Debug, PartialEq, DatabaseEntry)]
#[cultcache(type = "epiphany.runtime.identity", schema = "EpiphanyRuntimeIdentity")]
@ -700,7 +700,7 @@ fn runtime_spine_schema_cache() -> Result<CultCache> {
cache.register_entry_type::<HandsCommandReceipt>()?;
cache.register_entry_type::<HandsCommitReceipt>()?;
cache.register_entry_type::<SoulVerdictReceipt>()?;
cache.register_entry_type::<EpiphanyOpenAiModelRequest>()?;
cache.register_entry_type::<EpiphanyProviderRequest>()?;
cache.register_entry_type::<EpiphanyModelRequest>()?;
cache.register_entry_type::<EpiphanyModelStreamEvent>()?;
cache.register_entry_type::<EpiphanyModelReceipt>()?;
@ -1078,7 +1078,7 @@ pub fn open_runtime_model_execution(
validate_non_empty(&job_options.job_id, "model execution job id")?;
validate_non_empty(&model_request.request_id, "model execution request id")?;
validate_non_empty(&model_request.provider, "model execution provider")?;
let provider_request = epiphany_openai_adapter::request_from_native(model_request);
let provider_request = epiphany_openai_adapter::request_from_native(model_request)?;
let store_path = store_path.as_ref();
let mut cache = runtime_spine_cache(store_path)?;
@ -1173,7 +1173,7 @@ pub fn open_runtime_model_execution(
.get::<EpiphanyModelRequest>(&model_request.request_id)?
.is_some()
|| cache
.get::<EpiphanyOpenAiModelRequest>(&provider_request.request_id)?
.get::<EpiphanyProviderRequest>(provider_request.request_id())?
.is_some()
{
return Err(anyhow!(
@ -1210,7 +1210,7 @@ pub fn open_runtime_model_execution(
.prepare_entry(&model_request.request_id, model_request)?
.0,
cache
.prepare_entry(&provider_request.request_id, &provider_request)?
.prepare_entry(provider_request.request_id(), &provider_request)?
.0,
];
replacements.extend(source_worker_envelopes);
@ -1320,7 +1320,7 @@ pub fn put_runtime_tool_execution_intent(
for envelope in [
cache.get_envelope::<EpiphanyRuntimeModelExecutionBinding>(model_request_id)?,
cache.get_envelope::<EpiphanyModelRequest>(model_request_id)?,
cache.get_envelope::<EpiphanyOpenAiModelRequest>(model_request_id)?,
cache.get_envelope::<EpiphanyProviderRequest>(model_request_id)?,
] {
let envelope = envelope.ok_or_else(|| {
anyhow!(
@ -1388,7 +1388,7 @@ pub(crate) fn validate_runtime_model_execution_binding(
.get::<EpiphanyModelRequest>(request_id)?
.ok_or_else(|| anyhow!("model execution binding {request_id:?} lost its native request"))?;
let provider = cache
.get::<EpiphanyOpenAiModelRequest>(request_id)?
.get::<EpiphanyProviderRequest>(request_id)?
.ok_or_else(|| {
anyhow!("model execution binding {request_id:?} lost its provider request")
})?;
@ -1399,7 +1399,7 @@ pub(crate) fn validate_runtime_model_execution_binding(
.get::<EpiphanyRuntimeJob>(&binding.job_id)?
.ok_or_else(|| anyhow!("model execution binding {request_id:?} lost its job"))?;
if binding.request_id != request_id
|| provider != epiphany_openai_adapter::request_from_native(&native)
|| provider != epiphany_openai_adapter::request_from_native(&native)?
{
return Err(anyhow!(
"model execution binding {request_id:?} is not one exact request family"
@ -1734,10 +1734,10 @@ fn archive_completed_model_session(
for native_request in &native_requests {
let request_id = &native_request.request_id;
let provider_request = cache
.get::<EpiphanyOpenAiModelRequest>(request_id)?
.get::<EpiphanyProviderRequest>(request_id)?
.ok_or_else(|| anyhow!("archived model execution lost provider request"))?;
if provider_request.request_id != *request_id
|| provider_request != epiphany_openai_adapter::request_from_native(native_request)
if provider_request.request_id() != request_id
|| provider_request != epiphany_openai_adapter::request_from_native(native_request)?
{
return Err(anyhow!(
"archived model execution request family is inconsistent"
@ -1865,7 +1865,7 @@ fn archive_completed_model_session(
binding.request_id.clone(),
));
retired_identities.insert((
EpiphanyOpenAiModelRequest::TYPE.to_string(),
EpiphanyProviderRequest::TYPE.to_string(),
binding.request_id.clone(),
));
for event in cache

View file

@ -11,6 +11,7 @@ path = "src/lib.rs"
[dependencies]
anyhow = "1"
codex-connector = { git = "https://github.com/GameCult/CodexConnector", rev = "89d965b0495ba817a1e48adda0a28509d6637d31", default-features = false }
cultcache-rs = { path = "../vendor/cultcache-rs" }
epiphany-model-adapter = { path = "../epiphany-model-adapter" }
serde = { version = "1", features = ["derive"] }

View file

@ -1,52 +1,64 @@
use anyhow::{Result, anyhow};
use codex_connector::{CodexInputItem, CodexProviderRequest, CodexToolChoice, CodexToolDefinition};
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)]
pub enum EpiphanyOpenAiWireDialect {
Responses,
ChatCompletionsTerminalTool,
}
#[derive(Debug, Clone, PartialEq, DatabaseEntry)]
#[cultcache(
type = "epiphany.openai_model_request.v1",
schema = "EpiphanyOpenAiModelRequest"
type = "epiphany.provider_request.v2",
schema = "EpiphanyProviderRequest"
)]
pub struct EpiphanyOpenAiModelRequest {
pub struct EpiphanyProviderRequest {
#[cultcache(key = 0)]
pub schema_id: String,
#[cultcache(key = 1)]
pub payload: EpiphanyProviderRequestPayload,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum EpiphanyProviderRequestPayload {
Codex(CodexProviderRequest),
OpenRouter(EpiphanyOpenAiModelRequest),
}
impl EpiphanyProviderRequest {
pub fn request_id(&self) -> &str {
match &self.payload {
EpiphanyProviderRequestPayload::Codex(request) => &request.request_id,
EpiphanyProviderRequestPayload::OpenRouter(request) => &request.request_id,
}
}
pub fn conversation_id(&self) -> &str {
match &self.payload {
EpiphanyProviderRequestPayload::Codex(request) => &request.conversation_id,
EpiphanyProviderRequestPayload::OpenRouter(request) => &request.conversation_id,
}
}
pub fn model(&self) -> &str {
match &self.payload {
EpiphanyProviderRequestPayload::Codex(request) => &request.model,
EpiphanyProviderRequestPayload::OpenRouter(request) => &request.model,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EpiphanyOpenAiModelRequest {
pub request_id: String,
#[cultcache(key = 2)]
pub conversation_id: String,
#[cultcache(key = 3)]
pub model: String,
#[cultcache(key = 4)]
pub instructions: String,
#[cultcache(key = 5, default)]
pub input: Vec<EpiphanyOpenAiInputItem>,
#[cultcache(key = 6, default)]
pub reasoning_effort: Option<String>,
#[cultcache(key = 7, default)]
pub reasoning_summary: Option<String>,
#[cultcache(key = 8, default)]
pub service_tier: Option<String>,
#[cultcache(key = 9, default)]
pub output_contract_id: Option<String>,
#[cultcache(key = 10, default)]
pub previous_response_id: Option<String>,
#[cultcache(key = 11, default)]
pub tools: Vec<EpiphanyOpenAiToolDefinition>,
#[cultcache(key = 12, default)]
pub output_schema_json: Option<String>,
#[cultcache(key = 13)]
pub provider_id: String,
#[cultcache(key = 14)]
pub wire_dialect: EpiphanyOpenAiWireDialect,
}
impl EpiphanyOpenAiModelRequest {
@ -57,7 +69,6 @@ impl EpiphanyOpenAiModelRequest {
instructions: impl Into<String>,
) -> Self {
Self {
schema_id: OPENAI_ADAPTER_REQUEST_SCHEMA_ID.to_string(),
request_id: request_id.into(),
conversation_id: conversation_id.into(),
model: model.into(),
@ -70,18 +81,26 @@ impl EpiphanyOpenAiModelRequest {
previous_response_id: None,
tools: Vec::new(),
output_schema_json: None,
provider_id: "openai-codex".to_string(),
wire_dialect: EpiphanyOpenAiWireDialect::Responses,
}
}
}
/// The only lowering from a native model request to the OpenAI transport.
/// Internal audit identity stays on the native request; every provider-bearing
/// byte is derived here.
pub fn request_from_native(request: &EpiphanyModelRequest) -> EpiphanyOpenAiModelRequest {
/// The only lowering from a native model request to an exact provider request.
pub fn request_from_native(request: &EpiphanyModelRequest) -> Result<EpiphanyProviderRequest> {
let payload = match request.provider.as_str() {
"openai-codex" | "openai" => {
EpiphanyProviderRequestPayload::Codex(codex_request_from_native(request)?)
}
"openrouter" => {
EpiphanyProviderRequestPayload::OpenRouter(openrouter_request_from_native(request))
}
_ => return Err(anyhow!("unsupported model provider {:?}", request.provider)),
};
Ok(EpiphanyProviderRequest { payload })
}
fn openrouter_request_from_native(request: &EpiphanyModelRequest) -> EpiphanyOpenAiModelRequest {
EpiphanyOpenAiModelRequest {
schema_id: OPENAI_ADAPTER_REQUEST_SCHEMA_ID.to_string(),
request_id: request.request_id.clone(),
conversation_id: request.conversation_id.clone(),
model: request.model.clone(),
@ -102,11 +121,85 @@ pub fn request_from_native(request: &EpiphanyModelRequest) -> EpiphanyOpenAiMode
})
.collect(),
output_schema_json: request.output_schema_json.clone(),
provider_id: request.provider.clone(),
wire_dialect: if request.provider == "openrouter" {
EpiphanyOpenAiWireDialect::ChatCompletionsTerminalTool
} else {
EpiphanyOpenAiWireDialect::Responses
}
}
fn codex_request_from_native(request: &EpiphanyModelRequest) -> Result<CodexProviderRequest> {
let has_tool_result = request
.input
.iter()
.any(|item| matches!(item, EpiphanyModelInputItem::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
.iter()
.map(|tool| {
Ok(CodexToolDefinition {
name: tool.name.clone(),
description: tool.description.clone(),
parameters_json: serde_json::to_string(&strict_provider_schema(
&tool.parameters_json,
)?)?,
})
})
.collect::<Result<Vec<_>>>()?;
let mut provider = CodexProviderRequest::new(
&request.request_id,
&request.conversation_id,
&request.model,
&request.instructions,
);
provider.input = request.input.iter().map(codex_input_from_native).collect();
provider.reasoning_effort = request.reasoning_effort.clone();
provider.reasoning_summary = request.reasoning_summary.clone();
provider.service_tier = request.service_tier.clone();
provider.output_format_name = output_format_name;
provider.previous_response_id = request.previous_response_id.clone();
provider.tools = tools;
provider.tool_choice = if !provider.tools.is_empty() && !has_tool_result {
CodexToolChoice::Required
} else {
CodexToolChoice::Auto
};
provider.output_schema_json = output_schema_json;
provider.validate()?;
Ok(provider)
}
fn codex_input_from_native(input: &EpiphanyModelInputItem) -> CodexInputItem {
match input {
EpiphanyModelInputItem::UserText { text } => {
CodexInputItem::UserText { text: text.clone() }
}
EpiphanyModelInputItem::AssistantText { text } => {
CodexInputItem::AssistantText { text: text.clone() }
}
EpiphanyModelInputItem::ToolCall {
call_id,
name,
arguments,
} => CodexInputItem::ToolCall {
call_id: provider_call_id(call_id),
name: name.clone(),
arguments: arguments.clone(),
},
EpiphanyModelInputItem::ToolResult { call_id, output } => CodexInputItem::ToolResult {
call_id: provider_call_id(call_id),
output: output.clone(),
},
}
}
@ -284,13 +377,6 @@ pub const OPENROUTER_TERMINAL_TOOL_NAME: &str = "epiphany_submit_typed_result";
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()
@ -834,7 +920,7 @@ mod tests {
use super::*;
#[test]
fn native_provider_identity_selects_one_exact_wire_dialect() {
fn native_provider_identity_selects_one_exact_request_contract() {
let openai = EpiphanyModelRequest::new(
"openai-request",
"conversation",
@ -850,16 +936,16 @@ mod tests {
"decide",
);
let openai = request_from_native(&openai);
let openrouter = request_from_native(&openrouter);
assert_eq!(openai.provider_id, "openai-codex");
assert_eq!(openai.wire_dialect, EpiphanyOpenAiWireDialect::Responses);
assert_eq!(openrouter.provider_id, "openrouter");
assert_eq!(
openrouter.wire_dialect,
EpiphanyOpenAiWireDialect::ChatCompletionsTerminalTool
);
assert_ne!(openai.schema_id, "epiphany.openai_model_request.v0");
let openai = request_from_native(&openai).unwrap();
let openrouter = request_from_native(&openrouter).unwrap();
assert!(matches!(
openai.payload,
EpiphanyProviderRequestPayload::Codex(_)
));
assert!(matches!(
openrouter.payload,
EpiphanyProviderRequestPayload::OpenRouter(_)
));
}
#[test]
@ -918,8 +1004,6 @@ mod tests {
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(),
);

View file

@ -19,7 +19,7 @@ use epiphany_model_adapter::EpiphanyModelRequest;
#[cfg(test)]
use epiphany_openai_adapter::{
EpiphanyOpenAiModelReceipt, EpiphanyOpenAiModelRequest, EpiphanyOpenAiStreamEvent,
EpiphanyOpenAiStreamPayload,
EpiphanyOpenAiStreamPayload, EpiphanyProviderRequestPayload,
};
use epiphany_openai_runtime::DEFAULT_CODEX_CONNECTOR_ENDPOINT;
use epiphany_openai_runtime::DEFAULT_PROVIDER_REQUEST_TIMEOUT;
@ -897,9 +897,10 @@ mod tests {
#[test]
fn codex_connector_projection_is_one_strict_deterministic_request() -> Result<()> {
let mut request = EpiphanyOpenAiModelRequest::new(
let mut request = EpiphanyModelRequest::new(
"connector-request",
"connector-conversation",
"openai-codex",
"gpt-test",
"Decide.",
);
@ -910,7 +911,7 @@ mod tests {
);
request
.tools
.push(epiphany_openai_adapter::EpiphanyOpenAiToolDefinition {
.push(epiphany_model_adapter::EpiphanyModelToolDefinition {
name: "inspect_body".into(),
description: "Inspect the typed Body.".into(),
parameters_json:
@ -919,19 +920,22 @@ mod tests {
});
request
.input
.push(epiphany_openai_adapter::EpiphanyOpenAiInputItem::ToolCall {
.push(epiphany_model_adapter::EpiphanyModelInputItem::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 {
request
.input
.push(epiphany_model_adapter::EpiphanyModelInputItem::ToolResult {
call_id: "native/call".into(),
output: r#"{"ok":true}"#.into(),
},
);
});
let projected = provider_transport::codex_request_from_epiphany(request)?;
let projected = epiphany_openai_adapter::request_from_native(&request)?;
let EpiphanyProviderRequestPayload::Codex(projected) = projected.payload else {
panic!("Codex provider must lower to the connector contract")
};
assert_eq!(
projected.output_format_name.as_deref(),
Some("role_result_v1")

View file

@ -29,9 +29,9 @@ use epiphany_model_adapter::EpiphanyModelRequest;
use epiphany_model_adapter::EpiphanyModelStreamEvent;
use epiphany_model_adapter::EpiphanyModelStreamPayload;
use epiphany_model_adapter::EpiphanyModelToolDefinition;
use epiphany_openai_adapter::EpiphanyOpenAiModelRequest;
use epiphany_openai_adapter::EpiphanyOpenAiStreamEvent;
use epiphany_openai_adapter::EpiphanyOpenAiStreamPayload;
use epiphany_openai_adapter::EpiphanyProviderRequest;
use epiphany_tool_adapter::EPIPHANY_TOOL_RUNTIME_ADAPTER_ID;
use epiphany_tool_adapter::EpiphanyToolInvocationIntent;
use epiphany_tool_adapter::EpiphanyToolInvocationReceipt;
@ -95,7 +95,7 @@ pub fn open_model_turn(
provider: &str,
options: &EpiphanyOpenAiRuntimeOptions,
model_request: &EpiphanyModelRequest,
) -> Result<EpiphanyOpenAiModelRequest> {
) -> Result<EpiphanyProviderRequest> {
validate_model_provider(provider)?;
if !provider_matches_request(provider, &model_request.provider) {
return Err(anyhow!(
@ -113,7 +113,7 @@ pub fn open_model_turn(
},
model_request,
)?;
Ok(openai_request_from_model_request(model_request))
provider_request_from_model_request(model_request)
}
pub fn record_model_turn_events(
@ -123,7 +123,7 @@ pub fn record_model_turn_events(
events: &[EpiphanyOpenAiStreamEvent],
) -> Result<EpiphanyOpenAiRuntimeRunSummary> {
let store_path = store_path.as_ref();
let provider_request = openai_request_from_model_request(request);
let provider_request = provider_request_from_model_request(request)?;
let events = compact_openai_events_for_storage(events);
let tool_intents = tool_invocation_intents_from_openai_events(&request.provider, &events);
for intent in &tool_intents {
@ -168,12 +168,12 @@ pub fn record_model_turn_events(
let summary = if let Some(message) = failure {
format!(
"OpenAI model request {} failed: {message}",
provider_request.request_id
provider_request.request_id()
)
} else if let Some(receipt) = &receipt {
format!(
"OpenAI model request {} completed through {}.",
provider_request.request_id,
provider_request.request_id(),
receipt
.transport
.clone()
@ -182,7 +182,7 @@ pub fn record_model_turn_events(
} else {
format!(
"OpenAI model request {} ended without a terminal receipt.",
provider_request.request_id
provider_request.request_id()
)
};
terminalize_runtime_job(
@ -194,7 +194,7 @@ pub fn record_model_turn_events(
EpiphanyRuntimeJobStatus::Failed
},
&now(),
&provider_request.request_id,
provider_request.request_id(),
)?;
Ok(EpiphanyOpenAiRuntimeRunSummary {
@ -738,19 +738,19 @@ pub fn append_requested_public_source_receipts(
pub fn default_options(
store_path: PathBuf,
request: &EpiphanyOpenAiModelRequest,
request: &EpiphanyProviderRequest,
) -> EpiphanyOpenAiRuntimeOptions {
EpiphanyOpenAiRuntimeOptions {
store_path,
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),
session_id: format!("openai-session-{}", request.conversation_id()),
job_id: format!("openai-job-{}", request.request_id()),
objective: format!("Run typed provider request {}", request.request_id()),
coordinator_note: "Native OpenAI runtime route; Codex is auth/model transport only."
.to_string(),
default_model: Some(request.model.clone()),
default_model: Some(request.model().to_string()),
request_timeout: Some(DEFAULT_PROVIDER_REQUEST_TIMEOUT),
}
}
@ -767,9 +767,9 @@ pub fn model_receipt_key(request_id: &str) -> String {
request_id.to_string()
}
pub fn openai_request_from_model_request(
pub fn provider_request_from_model_request(
request: &EpiphanyModelRequest,
) -> EpiphanyOpenAiModelRequest {
) -> Result<EpiphanyProviderRequest> {
epiphany_openai_adapter::request_from_native(request)
}
@ -2833,7 +2833,7 @@ mod tests {
"gpt-5.4",
"Answer plainly.",
);
let request = epiphany_openai_adapter::request_from_native(&native_request);
let request = epiphany_openai_adapter::request_from_native(&native_request)?;
let options = default_options(store.clone(), &request);
ensure_openai_runtime_ready(&options)?;
open_runtime_model_execution(
@ -2868,7 +2868,7 @@ mod tests {
.is_some()
);
assert!(cache.get::<EpiphanyModelReceipt>("req-1")?.is_some());
assert!(cache.get::<EpiphanyOpenAiModelRequest>("req-1")?.is_some());
assert!(cache.get::<EpiphanyProviderRequest>("req-1")?.is_some());
assert_eq!(
runtime_job(&store, &options.job_id)?
.expect("snapshot")
@ -3275,9 +3275,11 @@ mod tests {
"gpt-5.4",
"Answer after tool output.",
);
native_request.output_schema_json =
Some(r#"{"type":"object","required":["researchDecision"]}"#.to_string());
let request = epiphany_openai_adapter::request_from_native(&native_request);
native_request.output_schema_json = Some(
r#"{"type":"object","properties":{"researchDecision":{"type":"string"}},"required":["researchDecision"]}"#
.to_string(),
);
let request = epiphany_openai_adapter::request_from_native(&native_request)?;
let options = default_options(store.clone(), &request);
ensure_openai_runtime_ready(&options)?;
open_runtime_model_execution(
@ -3346,7 +3348,9 @@ mod tests {
assert_eq!(followup.previous_response_id, None);
assert_eq!(
followup.output_schema_json.as_deref(),
Some(r#"{"type":"object","required":["researchDecision"]}"#)
Some(
r#"{"type":"object","properties":{"researchDecision":{"type":"string"}},"required":["researchDecision"]}"#
)
);
assert_eq!(followup.input.len(), 2);
assert_eq!(

View file

@ -687,7 +687,7 @@ mod tests {
PersonaModelExecutionPlan::from_admitted_input(
store,
"turn-1",
"test",
crate::DEFAULT_MODEL_PROVIDER,
"test-model",
cultmesh_store,
"epiphany-test",

View file

@ -4,16 +4,14 @@ use std::time::{Duration, SystemTime, UNIX_EPOCH};
use anyhow::{Context, Result, anyhow};
use codex_connector::{
CodexConnectorClient, CodexInputItem, CodexProviderRequest, CodexToolChoice,
CodexToolDefinition, CodexTransportDisposition, CodexTransportEventPayload,
CodexTransportInvocation, CodexTransportOutcome,
CodexConnectorClient, CodexProviderRequest, CodexTransportDisposition,
CodexTransportEventPayload, CodexTransportInvocation, CodexTransportOutcome,
};
use epiphany_model_adapter::EpiphanyModelRequest;
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,
EpiphanyOpenAiModelReceipt, EpiphanyOpenAiModelRequest, EpiphanyOpenAiStreamEvent,
EpiphanyOpenAiStreamPayload, EpiphanyProviderRequestPayload, openrouter_events_from_response,
openrouter_request_body,
};
use epiphany_openai_runtime::{
EpiphanyOpenAiRuntimeOptions, EpiphanyOpenAiRuntimeRunSummary, OPENROUTER_MODEL_PROVIDER,
@ -34,19 +32,22 @@ pub async fn run_model_turn(
) -> 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 events = match (provider, provider_request.payload) {
("openai-codex" | "openai", EpiphanyProviderRequestPayload::Codex(codex_request)) => {
collect_transport_events(
execute_codex_connector(&options, &request, provider_request),
execute_codex_connector(&options, &request, codex_request),
&request_id,
)
.await
}
OPENROUTER_MODEL_PROVIDER => {
collect_transport_events(execute_openrouter(&options, provider_request), &request_id)
.await
(OPENROUTER_MODEL_PROVIDER, EpiphanyProviderRequestPayload::OpenRouter(request)) => {
collect_transport_events(execute_openrouter(&options, request), &request_id).await
}
_ => {
return Err(anyhow!(
"provider request contract disagrees with selected provider"
));
}
_ => unreachable!("open_model_turn validates provider identity"),
};
record_model_turn_events(&options.store_path, &options, &request, &events)
}
@ -54,7 +55,7 @@ pub async fn run_model_turn(
async fn execute_codex_connector(
options: &EpiphanyOpenAiRuntimeOptions,
native_request: &EpiphanyModelRequest,
request: EpiphanyOpenAiModelRequest,
provider_request: CodexProviderRequest,
) -> Result<Vec<EpiphanyOpenAiStreamEvent>> {
let endpoint = options
.connector_endpoint
@ -70,7 +71,6 @@ async fn execute_codex_connector(
"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"))?;
@ -94,96 +94,6 @@ async fn execute_codex_connector(
.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>> {