From c37cae8bc132b2a2b5597263b68cdc90add13add Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 24 Aug 2026 23:44:57 +0200 Subject: [PATCH] Seal exact provider requests before transport --- Cargo.lock | 3 +- Cargo.toml | 2 +- epiphany-core/src/reasoning_context.rs | 66 +++--- epiphany-core/src/runtime_spine.rs | 26 +-- epiphany-openai-adapter/Cargo.toml | 1 + epiphany-openai-adapter/src/lib.rs | 204 ++++++++++++------ .../src/bin/epiphany-openai-runtime.rs | 22 +- epiphany-openai-runtime/src/lib.rs | 46 ++-- .../src/persona_executor.rs | 2 +- .../src/provider_transport.rs | 122 ++--------- 10 files changed, 242 insertions(+), 252 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index daebe993..319d7bb6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -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", diff --git a/Cargo.toml b/Cargo.toml index f208bbc6..69754984 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -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" diff --git a/epiphany-core/src/reasoning_context.rs b/epiphany-core/src/reasoning_context.rs index 781b1b20..13c55b5f 100644 --- a/epiphany-core/src/reasoning_context.rs +++ b/epiphany-core/src/reasoning_context.rs @@ -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, ) -> Result { 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 { + pub fn provider_request(&self) -> Result { 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, pub terminal_records: EpiphanyDecisionTerminalRecords, pub mind_commit_receipts: Vec, @@ -1340,7 +1342,7 @@ fn validate_context_store_ownership( .as_ref() != Some(&native) || cache - .get::(&provider.request_id)? + .get::(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()] diff --git a/epiphany-core/src/runtime_spine.rs b/epiphany-core/src/runtime_spine.rs index 023a21ff..2f35cec0 100644 --- a/epiphany-core/src/runtime_spine.rs +++ b/epiphany-core/src/runtime_spine.rs @@ -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 { cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; - cache.register_entry_type::()?; + cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; cache.register_entry_type::()?; @@ -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::(&model_request.request_id)? .is_some() || cache - .get::(&provider_request.request_id)? + .get::(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::(model_request_id)?, cache.get_envelope::(model_request_id)?, - cache.get_envelope::(model_request_id)?, + cache.get_envelope::(model_request_id)?, ] { let envelope = envelope.ok_or_else(|| { anyhow!( @@ -1388,7 +1388,7 @@ pub(crate) fn validate_runtime_model_execution_binding( .get::(request_id)? .ok_or_else(|| anyhow!("model execution binding {request_id:?} lost its native request"))?; let provider = cache - .get::(request_id)? + .get::(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::(&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::(request_id)? + .get::(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 diff --git a/epiphany-openai-adapter/Cargo.toml b/epiphany-openai-adapter/Cargo.toml index 6fc79709..575cbf6d 100644 --- a/epiphany-openai-adapter/Cargo.toml +++ b/epiphany-openai-adapter/Cargo.toml @@ -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"] } diff --git a/epiphany-openai-adapter/src/lib.rs b/epiphany-openai-adapter/src/lib.rs index ca2f5c89..698df1d8 100644 --- a/epiphany-openai-adapter/src/lib.rs +++ b/epiphany-openai-adapter/src/lib.rs @@ -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, - #[cultcache(key = 6, default)] pub reasoning_effort: Option, - #[cultcache(key = 7, default)] pub reasoning_summary: Option, - #[cultcache(key = 8, default)] pub service_tier: Option, - #[cultcache(key = 9, default)] pub output_contract_id: Option, - #[cultcache(key = 10, default)] pub previous_response_id: Option, - #[cultcache(key = 11, default)] pub tools: Vec, - #[cultcache(key = 12, default)] pub output_schema_json: Option, - #[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, ) -> 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 { + 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 { + 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::>>()?; + 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 { - 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(), ); diff --git a/epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs b/epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs index fcf84953..ea8c93ee 100644 --- a/epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs +++ b/epiphany-openai-runtime/src/bin/epiphany-openai-runtime.rs @@ -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") diff --git a/epiphany-openai-runtime/src/lib.rs b/epiphany-openai-runtime/src/lib.rs index bf00b08c..e4c8bc83 100644 --- a/epiphany-openai-runtime/src/lib.rs +++ b/epiphany-openai-runtime/src/lib.rs @@ -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 { +) -> Result { 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 { 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 { 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::("req-1")?.is_some()); - assert!(cache.get::("req-1")?.is_some()); + assert!(cache.get::("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!( diff --git a/epiphany-openai-runtime/src/persona_executor.rs b/epiphany-openai-runtime/src/persona_executor.rs index f956e343..5a5192aa 100644 --- a/epiphany-openai-runtime/src/persona_executor.rs +++ b/epiphany-openai-runtime/src/persona_executor.rs @@ -687,7 +687,7 @@ mod tests { PersonaModelExecutionPlan::from_admitted_input( store, "turn-1", - "test", + crate::DEFAULT_MODEL_PROVIDER, "test-model", cultmesh_store, "epiphany-test", diff --git a/epiphany-openai-runtime/src/provider_transport.rs b/epiphany-openai-runtime/src/provider_transport.rs index ff2d0785..80fbc6fc 100644 --- a/epiphany-openai-runtime/src/provider_transport.rs +++ b/epiphany-openai-runtime/src/provider_transport.rs @@ -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 { 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> { 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 { - 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::>>()?; - 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> {