This repository has been archived on 2026-10-29. You can view files and clone it, but you cannot make any changes to its state, such as pushing and creating new issues, pull requests or comments.
Epiphany/epiphany-model-adapter/src/provider.rs
2026-08-25 01:44:59 +02:00

922 lines
31 KiB
Rust

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