Seal exact provider requests before transport
This commit is contained in:
parent
4177e186bb
commit
c37cae8bc1
10 changed files with 242 additions and 252 deletions
3
Cargo.lock
generated
3
Cargo.lock
generated
|
|
@ -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",
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -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()]
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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"] }
|
||||
|
|
|
|||
|
|
@ -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(),
|
||||
);
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -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!(
|
||||
|
|
|
|||
|
|
@ -687,7 +687,7 @@ mod tests {
|
|||
PersonaModelExecutionPlan::from_admitted_input(
|
||||
store,
|
||||
"turn-1",
|
||||
"test",
|
||||
crate::DEFAULT_MODEL_PROVIDER,
|
||||
"test-model",
|
||||
cultmesh_store,
|
||||
"epiphany-test",
|
||||
|
|
|
|||
|
|
@ -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>> {
|
||||
|
|
|
|||
Reference in a new issue