feat(protocol): support Messages ingress and API upstreams

Support Responses, Chat Completions and Messages ingress with Responses
or Messages API upstreams in the existing OpenAI provider.

Share generation admission and delivery, preserve native protocol payloads,
and translate cross-protocol tools, reasoning, streams and usage. Add
Messages token counting and editable upstream protocol settings.

Co-authored-by: Codex <noreply@openai.com>
This commit is contained in:
Zyy
2026-11-10 22:07:46 +08:00
co-authored by Codex
parent 63db306ba2
commit dd65665128
129 changed files with 9716 additions and 1738 deletions
+3
View File
@@ -17,6 +17,9 @@
/.runtime/
*.log
# Local planning documents
/docs/plans/
# Local configuration and secrets
/deploy/config.yaml
.env
+34
View File
@@ -102,6 +102,12 @@ dependencies = [
"windows-sys 0.61.2",
]
[[package]]
name = "anyhow"
version = "1.0.104"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
[[package]]
name = "arc-swap"
version = "1.9.2"
@@ -716,6 +722,17 @@ version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc0b364ead1874514c8c2855ab558056ebfeb775653e7ae45ff72f28f8f3166c"
[[package]]
name = "bstr"
version = "1.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6bb31b46c14244e20ee9984b11bf5c992b91fb6939fea616e3512c8baecdbe5f"
dependencies = [
"memchr",
"regex-automata",
"serde_core",
]
[[package]]
name = "bumpalo"
version = "3.20.3"
@@ -1777,6 +1794,7 @@ dependencies = [
"event-listener",
"futures",
"futures-timer",
"gateway-protocol",
"http",
"http-body-util",
"semver",
@@ -3344,6 +3362,7 @@ dependencies = [
"hyper",
"hyper-rustls",
"hyper-util",
"lru",
"native-tls",
"openssl",
"openssl-sys",
@@ -3362,6 +3381,7 @@ dependencies = [
"tar",
"tempfile",
"thiserror",
"tiktoken-rs",
"tokio",
"tokio-rustls",
"tokio-tungstenite 0.28.0",
@@ -4604,6 +4624,20 @@ dependencies = [
"cfg-if",
]
[[package]]
name = "tiktoken-rs"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2aeff724640cfe13037336ddf35befdffd2909cbdb65cf041cc8a4cf8c584cfa"
dependencies = [
"anyhow",
"base64 0.22.1",
"bstr",
"fancy-regex",
"regex",
"rustc-hash",
]
[[package]]
name = "time"
version = "0.3.53"
@@ -509,6 +509,7 @@ const ALLOWED_INTERNAL_EDGES: &[(&str, &str)] = &[
("gateway-api", "gateway-admin"),
("gateway-api", "gateway-core"),
("gateway-api", "gateway-protocol"),
("gateway-core", "gateway-protocol"),
("gateway-host", "gateway-admin"),
("gateway-host", "gateway-core"),
("gateway-host", "gateway-protocol"),
@@ -276,6 +276,7 @@ impl UpdateAccountRequest {
#[derive(Clone, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct AccountConnectionUpdateRequest {
pub protocol: Option<String>,
pub base_url: Option<String>,
pub transport: String,
pub api_key: Option<String>,
@@ -283,6 +284,13 @@ pub struct AccountConnectionUpdateRequest {
impl AccountConnectionUpdateRequest {
fn validate(&self) -> Result<(), WireValidationError> {
if self
.protocol
.as_deref()
.is_some_and(|protocol| !matches!(protocol, "responses" | "messages"))
{
return Err(WireValidationError::new("connection.protocol"));
}
if let Some(base_url) = &self.base_url {
require_text(base_url, 2048, "connection.baseUrl")?;
}
@@ -302,6 +310,9 @@ impl AccountConnectionUpdateRequest {
fn into_document(self) -> ProviderDocument {
let mut material =
Map::from_iter([("transport".to_owned(), Value::String(self.transport))]);
if let Some(protocol) = self.protocol {
material.insert("protocol".to_owned(), Value::String(protocol));
}
if let Some(base_url) = self.base_url {
material.insert("base_url".to_owned(), Value::String(base_url));
}
@@ -1100,7 +1100,7 @@ impl From<(DomainConnectionTestEvent, crate::time::TimePresenter)> for AccountCo
DomainConnectionTestEvent::Started { model } => serde_json::json!({
"type": "test_start",
"model": model,
"text": "正在连接上游 Responses"
"text": "正在连接上游"
}),
DomainConnectionTestEvent::Request {
model,
@@ -1,5 +1,9 @@
//! 插件管理页面、资源、授权回调与页面模型请求的 HTTP 边界
use crate::openai::generation::{
GenerationHttpRequest, ResponseAuthorization, execute_prepared_generation,
};
use std::{net::SocketAddr, sync::Arc};
use axum::{
@@ -35,10 +39,7 @@ use crate::{
auth::SessionState,
openai::{
error::{gateway_error_response, protocol_error_response},
responses::{
ResponseAuthorization, ResponsesHttpRequest, decode_request_with_body,
execute_prepared_responses,
},
responses::decode_request_with_body,
},
};
@@ -140,10 +141,10 @@ async fn model_responses(
};
let authorization: Arc<dyn ResponseAuthorization> =
Arc::new(PluginModelsAuthorization { state, target });
let response = execute_prepared_responses(
let response = execute_prepared_generation(
service,
prepared,
ResponsesHttpRequest {
GenerationHttpRequest {
peer_address: parts
.extensions
.get::<ConnectInfo<SocketAddr>>()
@@ -158,6 +159,7 @@ async fn model_responses(
middleware_body,
},
Some(authorization),
None,
)
.await;
Ok(plugin_response(response))
+2
View File
@@ -250,6 +250,8 @@ pub fn initialize(
axum::http::header::AUTHORIZATION,
axum::http::header::CONTENT_TYPE,
HeaderName::from_static("x-api-key"),
HeaderName::from_static("anthropic-version"),
HeaderName::from_static("anthropic-beta"),
request_id_header.clone(),
])
.allow_credentials(true),
+29 -9
View File
@@ -1,4 +1,4 @@
//! OpenAI 客户端协议的 Bearer API key 认证
//! 数据面客户端 Bearer 与 x-api-key 认证
use axum::{
http::{HeaderMap, header::AUTHORIZATION},
@@ -87,8 +87,9 @@ impl ClientApiKeyAuthError {
pub(crate) async fn authenticate_client(
service: &OpenAiService,
headers: &HeaderMap,
accepted: ClientKeyHeaders,
) -> Result<AuthenticatedClient, ClientAccessError> {
let request = client_authentication_request(headers)?;
let request = client_authentication_request(headers, accepted)?;
let client = service.authenticate(request).await?;
if let Some(identified) = identify_codex_client(headers) {
client
@@ -104,19 +105,38 @@ pub(crate) async fn verify_client(
service: &OpenAiService,
headers: &HeaderMap,
) -> Result<AuthenticatedClient, ClientApiKeyAuthError> {
let request = client_authentication_request(headers)?;
let request = client_authentication_request(headers, ClientKeyHeaders::Bearer)?;
service.verify(request).await
}
/// 入口声明其认证头合同,所有形式仍进入同一 Client Key 认证链路
#[derive(Clone, Copy)]
pub(crate) enum ClientKeyHeaders {
Bearer,
Anthropic,
}
fn client_authentication_request(
headers: &HeaderMap,
accepted: ClientKeyHeaders,
) -> Result<ClientAuthenticationRequest, ClientApiKeyAuthError> {
let raw = headers
.get(AUTHORIZATION)
.ok_or(ClientApiKeyAuthError::MissingAuthorization)?
.to_str()
.map_err(|_| ClientApiKeyAuthError::MalformedAuthorization)?;
let request = ClientAuthenticationRequest::new(raw.to_owned())
let raw = if let Some(authorization) = headers.get(AUTHORIZATION) {
authorization
.to_str()
.map_err(|_| ClientApiKeyAuthError::MalformedAuthorization)?
.to_owned()
} else if matches!(accepted, ClientKeyHeaders::Anthropic)
&& let Some(key) = headers.get("x-api-key")
{
format!(
"Bearer {}",
key.to_str()
.map_err(|_| ClientApiKeyAuthError::MalformedAuthorization)?
)
} else {
return Err(ClientApiKeyAuthError::MissingAuthorization);
};
let request = ClientAuthenticationRequest::new(raw)
.map_err(|_| ClientApiKeyAuthError::MalformedAuthorization)?;
let request = request.with_request_context(
crate::middleware::current().and_then(|context| context.extensions.shared_request()),
@@ -11,12 +11,13 @@ use axum::{
use crate::ApiState;
use crate::openai::{
auth::{authenticate_client, client_access_error_response},
auth::{ClientKeyHeaders, authenticate_client, client_access_error_response},
error::{gateway_error_response, protocol_error_response},
responses::{
DecodedResponsesRequest, HttpResponseAdapter, RequestDecodeError, ResponsesHttpRequest,
decode_request_with_headers, decompress_request_body, execute_prepared_response,
generation::{
DecodedGenerationRequest, GenerationHttpRequest, HttpResponseAdapter,
execute_prepared_generation,
},
responses::{RequestDecodeError, decode_request_with_headers, decompress_request_body},
router::CHAT_COMPLETIONS_PATH,
};
@@ -34,7 +35,7 @@ pub(in crate::openai) async fn chat_completions(
body: Bytes,
) -> Response {
let service = state.openai().clone();
let client = match authenticate_client(&service, &headers).await {
let client = match authenticate_client(&service, &headers, ClientKeyHeaders::Bearer).await {
Ok(client) => client,
Err(error) => return client_access_error_response(error),
};
@@ -68,10 +69,10 @@ pub(in crate::openai) async fn chat_completions(
}),
stream_error: chat_error_frame,
};
execute_prepared_response(
execute_prepared_generation(
service,
prepared,
ResponsesHttpRequest {
GenerationHttpRequest {
peer_address: connect_info.map(|Extension(ConnectInfo(address))| address),
ingress_id,
headers,
@@ -88,7 +89,7 @@ fn decode_request(
body: &[u8],
headers: &HeaderMap,
maximum_body_bytes: usize,
) -> Result<(DecodedResponsesRequest, Bytes, bool), RequestDecodeError> {
) -> Result<(DecodedGenerationRequest, Bytes, bool), RequestDecodeError> {
let body = decompress_request_body(body, headers, maximum_body_bytes)?;
let converted = convert_request(&body)?;
let body =
@@ -89,7 +89,7 @@ where
)
.await;
let response = match result {
Ok(response) => into_http_response(response, ExpectedBody::SingleJson).await,
Ok(response) => into_http_response(response, ExpectedBody::SingleJson, "openai").await,
Err(error) => error_response(error),
};
if !execution_entered.load(Ordering::Relaxed) {
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,80 @@
//! 生成与计数协议共用的解码事实和 HTTP 执行边界
pub(crate) mod http;
mod request;
mod response;
mod validation;
pub(crate) use http::{
GenerationHttpRequest, HttpResponseAdapter, ResponseAuthorization, execute_prepared_generation,
};
pub use request::{ContinuationIntent, DecodedGenerationRequest, GenerationRequestMetadata};
use axum::http::HeaderMap;
use gateway_core::{
error::{GatewayError, GatewayErrorKind},
operation::OperationKind,
};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum GenerationProtocol {
Responses,
Messages,
MessageTokenCount,
}
impl GenerationProtocol {
pub(crate) fn from_request(request: &DecodedGenerationRequest) -> Self {
if request.operation().kind() == OperationKind::CountTokens {
Self::MessageTokenCount
} else if request.operation().protocol() == "anthropic" {
Self::Messages
} else {
Self::Responses
}
}
pub(crate) const fn wire(self) -> &'static str {
match self {
Self::Responses => "openai",
Self::Messages | Self::MessageTokenCount => "anthropic",
}
}
pub(crate) const fn endpoint(self) -> &'static str {
match self {
Self::Responses => super::router::RESPONSES_PATH,
Self::Messages => super::router::MESSAGES_PATH,
Self::MessageTokenCount => super::router::MESSAGE_TOKENS_PATH,
}
}
pub(crate) const fn operation(self) -> OperationKind {
match self {
Self::Responses | Self::Messages => OperationKind::Generate,
Self::MessageTokenCount => OperationKind::CountTokens,
}
}
pub(crate) fn decode(
self,
body: &[u8],
headers: &HeaderMap,
maximum: usize,
) -> Result<DecodedGenerationRequest, GatewayError> {
match self {
Self::Responses => super::responses::decode_request_with_headers(
body, headers, maximum,
)
.map_err(|_| {
GatewayError::new(
GatewayErrorKind::InvalidRequest,
"Request middleware produced an invalid Responses request.",
)
}),
Self::Messages | Self::MessageTokenCount => {
super::messages::decode_request(body, headers, maximum, self)
}
}
}
}
@@ -0,0 +1,160 @@
//! 生成与计数入口共用的已解码操作和交付元数据
use gateway_core::operation::{Operation, ProviderSessionState};
use std::{fmt, net::IpAddr};
/// 客户端声明的 continuation 意图
#[derive(Clone, PartialEq, Eq)]
pub enum ContinuationIntent {
/// 不使用先前响应
None,
/// 使用当前调用方可见的 OpenAI response ID
PreviousResponseId(String),
}
impl ContinuationIntent {
/// 返回待 history owner 解析的 response ID
#[must_use]
pub fn previous_response_id(&self) -> Option<&str> {
match self {
Self::None => None,
Self::PreviousResponseId(value) => Some(value),
}
}
}
impl fmt::Debug for ContinuationIntent {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::None => formatter.write_str("None"),
Self::PreviousResponseId(_) => formatter.write_str("PreviousResponseId(<redacted>)"),
}
}
}
/// Handler、Router 和 history owner 使用的请求元数据
#[derive(Clone, PartialEq, Eq)]
pub struct GenerationRequestMetadata {
pub(in crate::openai) requested_model: String,
pub(in crate::openai) stream: bool,
pub(in crate::openai) store: bool,
pub(in crate::openai) continuation: ContinuationIntent,
pub(in crate::openai) client_ip: Option<IpAddr>,
pub(in crate::openai) user_agent: Option<String>,
}
impl GenerationRequestMetadata {
/// 返回客户端原始模型名
#[must_use]
pub fn requested_model(&self) -> &str {
&self.requested_model
}
/// 返回客户端是否请求 SSE
#[must_use]
pub const fn stream(&self) -> bool {
self.stream
}
/// 返回客户端 storage intent
#[must_use]
pub const fn store(&self) -> bool {
self.store
}
/// 返回 continuation intent
#[must_use]
pub const fn continuation(&self) -> &ContinuationIntent {
&self.continuation
}
/// 返回从 HTTP 连接边界解析出的客户端地址
#[must_use]
pub const fn client_ip(&self) -> Option<IpAddr> {
self.client_ip
}
/// 返回经过 UTF-8 校验和空白归一化的 User-Agent
#[must_use]
pub fn user_agent(&self) -> Option<&str> {
self.user_agent.as_deref()
}
}
impl fmt::Debug for GenerationRequestMetadata {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("GenerationRequestMetadata")
.field("requested_model", &self.requested_model)
.field("stream", &self.stream)
.field("store", &self.store)
.field("continuation", &self.continuation)
.field("client_ip", &self.client_ip)
.field("has_user_agent", &self.user_agent.is_some())
.finish()
}
}
/// 一次成功解码的生成或计数请求
#[derive(Clone, PartialEq)]
pub struct DecodedGenerationRequest {
pub(in crate::openai) operation: Operation,
pub(in crate::openai) metadata: GenerationRequestMetadata,
}
impl DecodedGenerationRequest {
pub(crate) fn with_middleware_capabilities(
mut self,
request: &gateway_core::engine::middleware::MiddlewareRequest,
) -> Result<Self, gateway_core::engine::middleware::MiddlewareError> {
self.operation = request.apply_capabilities(self.operation)?;
Ok(self)
}
/// 附着当前 WebSocket 连接保存的 Provider 私有上一轮状态
#[must_use]
pub fn with_provider_session_state(mut self, state: ProviderSessionState) -> Self {
self.operation = self.operation.with_provider_session_state(state);
self
}
/// 返回协议无关 operation
#[must_use]
pub const fn operation(&self) -> &Operation {
&self.operation
}
/// 返回 handler 元数据
#[must_use]
pub const fn metadata(&self) -> &GenerationRequestMetadata {
&self.metadata
}
/// 拆分为 operation 与元数据
#[must_use]
pub fn into_parts(self) -> (Operation, GenerationRequestMetadata) {
(self.operation, self.metadata)
}
/// 附着只由 HTTP/WebSocket 连接边界提供的诊断事实
#[must_use]
pub fn with_client_context(
mut self,
client_ip: Option<IpAddr>,
user_agent: Option<String>,
) -> Self {
self.metadata.client_ip = client_ip;
self.metadata.user_agent = user_agent;
self
}
}
impl fmt::Debug for DecodedGenerationRequest {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("DecodedGenerationRequest")
.field("operation", &self.operation)
.field("metadata", &self.metadata)
.finish()
}
}
@@ -0,0 +1,191 @@
//! 原生协议出口保留 wire,只在非流式交付时聚合消息正文
use axum::body::Bytes;
use gateway_core::{error::GatewayError, event::ProviderEvent};
use gateway_protocol::{
anthropic::MessagesAccumulator,
openai::sse::{
DONE_SSE_FRAME, encode_sse_event_with_metadata, response_failed_sse_event_with_id,
},
};
use serde_json::{Value, json};
use super::GenerationProtocol;
use crate::openai::{
error::gateway_error_contract,
messages,
responses::{OpenAiResponsesEncoder, ResponseEncodeError},
};
pub(super) enum GenerationEncoder {
Responses(OpenAiResponsesEncoder),
Messages {
response_id: Option<String>,
completed: bool,
failed: bool,
},
}
impl GenerationEncoder {
pub(super) fn new(protocol: GenerationProtocol) -> Self {
match protocol {
GenerationProtocol::Responses => Self::Responses(OpenAiResponsesEncoder::new()),
GenerationProtocol::Messages | GenerationProtocol::MessageTokenCount => {
Self::Messages {
response_id: None,
completed: false,
failed: false,
}
}
}
}
pub(super) fn push_sse(&mut self, event: &ProviderEvent) -> Vec<Bytes> {
match self {
Self::Responses(encoder) => encoder.push_sse(event),
Self::Messages {
response_id,
completed,
failed,
} => {
let Some(wire) = event
.wire_event()
.filter(|wire| wire.protocol() == "anthropic")
else {
return Vec::new();
};
if let Some(raw) = wire.raw_json_body() {
let events = serde_json::from_slice(raw).ok().and_then(|value| {
gateway_protocol::anthropic::message_to_stream_events(value).ok()
});
let Some(events) = events else {
*failed = true;
return vec![messages::stream_error(
&json!({"error":{"message":"The upstream message is invalid."}}),
)];
};
*response_id = events
.first()
.and_then(|value| value.pointer("/message/id"))
.and_then(Value::as_str)
.map(str::to_owned);
*completed = true;
return events
.into_iter()
.map(|value| {
Bytes::from(encode_sse_event_with_metadata(
value["type"].as_str().unwrap_or_default(),
&value.to_string(),
None,
None,
))
})
.collect();
}
let kind = wire
.event_type()
.or_else(|| wire.data().get("type").and_then(Value::as_str));
match kind {
Some("message_start") => {
*response_id = wire
.data()
.pointer("/message/id")
.and_then(Value::as_str)
.map(str::to_owned)
}
Some("message_stop") => *completed = true,
Some("error") => *failed = true,
_ => {}
}
if let Some(raw) = wire.raw_sse_frame() {
return vec![raw.clone()];
}
vec![Bytes::from(encode_sse_event_with_metadata(
kind.unwrap_or_default(),
&wire.data().to_string(),
wire.sse_id(),
wire.sse_retry(),
))]
}
}
}
pub(super) fn is_completed(&self) -> bool {
match self {
Self::Responses(encoder) => encoder.is_completed(),
Self::Messages { completed, .. } => *completed,
}
}
pub(super) fn has_wire_failure(&self) -> bool {
match self {
Self::Responses(encoder) => encoder.has_wire_failure(),
Self::Messages { failed, .. } => *failed,
}
}
pub(super) fn error_frame(&self, error: &GatewayError) -> Bytes {
let (status, error_type, code) = gateway_error_contract(error.kind());
match self {
Self::Responses(encoder) => Bytes::from(response_failed_sse_event_with_id(
encoder.response_id(),
error.client_error_type().unwrap_or(error_type),
crate::client_error::client_error_code(error.client_error_code().unwrap_or(code)),
error.client_message(),
)),
Self::Messages { .. } => {
let value = messages::error_payload(
&json!({"error":{"message":error.client_message()}}),
status,
);
messages::stream_error(&value)
}
}
}
}
impl GenerationProtocol {
pub(super) fn terminal_bytes(self) -> Bytes {
match self {
Self::Responses => Bytes::from_static(DONE_SSE_FRAME.as_bytes()),
// Messages 的 message_stop 已在 wire 中交付,空帧只确认宿主交付终结
Self::Messages | Self::MessageTokenCount => Bytes::new(),
}
}
pub(super) fn collect(self, events: &[ProviderEvent]) -> Result<Vec<u8>, ResponseEncodeError> {
if self == Self::Responses {
return serde_json::to_vec(&crate::openai::responses::response::collect_response(
events,
)?)
.map_err(|_| ResponseEncodeError::Serialization);
}
let mut accumulator = MessagesAccumulator::default();
let mut response = None;
for wire in events
.iter()
.filter_map(ProviderEvent::wire_event)
.filter(|wire| wire.protocol() == self.wire())
{
if let Some(raw) = wire.raw_json_body() {
return Ok(raw.to_vec());
}
let value = wire.data();
if self == Self::MessageTokenCount {
if value.get("input_tokens").and_then(Value::as_u64).is_some() {
response = Some(value.clone());
}
} else if value.get("type").and_then(Value::as_str) == Some("message") {
response = Some(value.clone());
} else if wire.has_json_data()
&& let Some(message) = accumulator
.push(value)
.map_err(|_| ResponseEncodeError::InvalidOutputItems)?
{
response = Some(message);
}
}
serde_json::to_vec(&response.ok_or(ResponseEncodeError::MissingWireTerminal)?)
.map_err(|_| ResponseEncodeError::Serialization)
}
}
@@ -0,0 +1,187 @@
//! 出口校验按协议维护边界事实,不在流式路径保存生成正文
use gateway_core::event::ProviderEvent;
use gateway_protocol::openai::sse::parse_sse_events;
use serde_json::Value;
use std::sync::{Arc, Mutex};
use super::GenerationProtocol;
use crate::openai::responses::validation::{
ResponseValidationFacts, ResponsesDeliveryValidator, validate_buffered_response,
};
#[derive(Clone)]
pub(super) enum GenerationValidationFacts {
Responses(ResponseValidationFacts),
Messages(Arc<Mutex<Option<String>>>),
Count,
}
impl GenerationValidationFacts {
pub(super) fn new(protocol: GenerationProtocol) -> Self {
match protocol {
GenerationProtocol::Responses => Self::Responses(ResponseValidationFacts::default()),
GenerationProtocol::Messages => Self::Messages(Arc::default()),
GenerationProtocol::MessageTokenCount => Self::Count,
}
}
pub(super) fn observe_event(&self, event: &ProviderEvent) {
match self {
Self::Responses(facts) => facts.observe_event(event),
Self::Messages(id) => {
if let Some(value) = event
.wire_event()
.filter(|wire| wire.protocol() == "anthropic")
.map(|wire| wire.data())
&& let Some(value) = value
.pointer("/message/id")
.or_else(|| value.get("id"))
.and_then(Value::as_str)
&& let Ok(mut id) = id.lock()
{
*id = Some(value.to_owned());
}
}
Self::Count => {}
}
}
pub(super) fn observe_buffered(&self, events: &[ProviderEvent], bytes: &[u8]) {
if let Self::Responses(facts) = self {
facts.observe_buffered(events, bytes);
} else {
for event in events {
self.observe_event(event);
}
if let Self::Messages(id) = self
&& let Ok(value) = serde_json::from_slice::<Value>(bytes)
&& let Some(value) = value.get("id").and_then(Value::as_str)
&& let Ok(mut id) = id.lock()
{
*id = Some(value.to_owned());
}
}
}
pub(super) fn response_id(&self) -> Option<String> {
match self {
Self::Responses(facts) => facts.response_id(),
Self::Messages(id) => id.lock().ok().and_then(|id| id.clone()),
Self::Count => None,
}
}
pub(super) fn validate_buffered(&self, bytes: &[u8]) -> Result<(), ()> {
match self {
Self::Responses(facts) => validate_buffered_response(facts, bytes).map_err(|_| ()),
Self::Messages(_) => {
let value: Value = serde_json::from_slice(bytes).map_err(|_| ())?;
let id = value.get("id").and_then(Value::as_str).ok_or(())?;
if value.get("type").and_then(Value::as_str) != Some("message")
|| !value.get("content").is_some_and(Value::is_array)
|| self.response_id().is_some_and(|expected| expected != id)
{
return Err(());
}
Ok(())
}
Self::Count => serde_json::from_slice::<Value>(bytes)
.ok()
.and_then(|value| value.get("input_tokens").and_then(Value::as_u64))
.map(|_| ())
.ok_or(()),
}
}
}
pub(super) enum GenerationDeliveryValidator {
Responses(ResponsesDeliveryValidator),
Messages { id: Option<String>, finished: bool },
}
impl GenerationDeliveryValidator {
pub(super) fn new(protocol: GenerationProtocol) -> Self {
match protocol {
GenerationProtocol::Responses => Self::Responses(ResponsesDeliveryValidator::default()),
_ => Self::Messages {
id: None,
finished: false,
},
}
}
pub(super) fn response_id(&self) -> Option<&str> {
match self {
Self::Responses(validator) => validator.response_id(),
Self::Messages { id, .. } => id.as_deref(),
}
}
pub(super) fn validate_frame(
&mut self,
bytes: &[u8],
transformed: bool,
facts: &GenerationValidationFacts,
) -> Result<(), ()> {
match (self, facts) {
(Self::Responses(validator), GenerationValidationFacts::Responses(facts)) => validator
.validate_frame(bytes, transformed, facts)
.map_err(|_| ()),
(Self::Messages { id, finished }, GenerationValidationFacts::Messages(_)) => {
if bytes.is_empty() {
return if *finished { Ok(()) } else { Err(()) };
}
for event in
parse_sse_events(std::str::from_utf8(bytes).map_err(|_| ())?).map_err(|_| ())?
{
let value: Value = match serde_json::from_str(&event.data) {
Ok(value) => value,
Err(_) if !transformed => continue,
Err(_) => return Err(()),
};
let kind = value
.get("type")
.and_then(Value::as_str)
.unwrap_or_default();
if *finished {
return Err(());
}
match kind {
"message_start" => {
let next = value
.pointer("/message/id")
.and_then(Value::as_str)
.ok_or(())?;
if id.is_some()
|| (transformed
&& facts.response_id().is_some_and(|expected| expected != next))
{
return Err(());
}
*id = Some(next.to_owned());
}
"message_stop" => {
if id.is_none() {
return Err(());
}
*finished = true;
}
"error" => *finished = true,
_ => {}
}
}
Ok(())
}
_ => Err(()),
}
}
pub(super) fn finish_delivery(&self) -> Result<(), ()> {
match self {
Self::Responses(validator) => validator.finish_delivery().map_err(|_| ()),
Self::Messages { finished: true, .. } => Ok(()),
_ => Err(()),
}
}
}
@@ -19,7 +19,7 @@ use crate::ApiState;
use crate::middleware::headers::encode_headers;
use crate::openai::middleware::RequestInput;
use crate::openai::{
auth::{authenticate_client, client_access_error_response},
auth::{ClientKeyHeaders, authenticate_client, client_access_error_response},
endpoint::provider_endpoint_response,
responses::{OpenAiRequestHeaders, request_client_context},
router::{IMAGE_EDITS_PATH, IMAGE_GENERATIONS_PATH},
@@ -73,7 +73,7 @@ async fn handle_image_request(
endpoint: &'static str,
) -> Response {
let service = state.openai();
let client = match authenticate_client(service, &headers).await {
let client = match authenticate_client(service, &headers, ClientKeyHeaders::Bearer).await {
Ok(client) => client,
Err(error) => return client_access_error_response(error),
};
@@ -23,7 +23,7 @@ use super::{
use crate::{
ApiState,
openai::{
auth::{authenticate_client, client_access_error_response},
auth::{ClientKeyHeaders, authenticate_client, client_access_error_response},
error::{engine_error_response, gateway_error_response},
middleware::PendingExecution,
responses::request_client_context,
@@ -42,7 +42,7 @@ pub(crate) async fn live_call(
request: Request,
) -> Response {
let service = state.openai();
let client = match authenticate_client(service, &headers).await {
let client = match authenticate_client(service, &headers, ClientKeyHeaders::Bearer).await {
Ok(client) => client,
Err(error) => return client_access_error_response(error),
};
@@ -116,7 +116,7 @@ pub(crate) async fn hangup(
body: Bytes,
) -> Response {
let service = state.openai();
let client = match authenticate_client(service, &headers).await {
let client = match authenticate_client(service, &headers, ClientKeyHeaders::Bearer).await {
Ok(client) => client,
Err(error) => return client_access_error_response(error),
};
@@ -22,7 +22,7 @@ use super::LiveErrorShape;
use crate::{
ApiState,
openai::{
auth::{authenticate_client, client_access_error_response},
auth::{ClientKeyHeaders, authenticate_client, client_access_error_response},
error::runtime_unavailable_response,
live::{
filter_protocol_headers, live_error_response, offered_subprotocols,
@@ -110,7 +110,7 @@ async fn open_sideband(
return upgrade_required_response();
};
let service = state.openai();
let client = match authenticate_client(service, &headers).await {
let client = match authenticate_client(service, &headers, ClientKeyHeaders::Bearer).await {
Ok(client) => client,
Err(error) => return client_access_error_response(error),
};
@@ -0,0 +1,237 @@
//! Messages 与输入计数的 HTTP 入口和原生错误表达
use std::net::SocketAddr;
use axum::{
body::{Body, Bytes},
extract::{Extension, State, connect_info::ConnectInfo},
http::{HeaderMap, HeaderValue, StatusCode, header::CONTENT_TYPE},
response::Response,
};
use gateway_core::{
error::{GatewayError, GatewayErrorKind},
operation::{GenerateRequest, Operation, ProtocolPayload, RawJsonPayload, TokenCountRequest},
};
use gateway_protocol::{anthropic, openai::sse::encode_sse_event};
use serde_json::{Value, json};
use super::{
auth::{ClientKeyHeaders, authenticate_client, client_access_error_response},
error::gateway_error_response,
generation::{
ContinuationIntent, DecodedGenerationRequest, GenerationHttpRequest, GenerationProtocol,
GenerationRequestMetadata, execute_prepared_generation,
},
responses::{OpenAiRequestHeaders, decompress_request_body},
};
use crate::ApiState;
pub(super) async fn messages(
State(state): State<ApiState>,
connect_info: Option<Extension<ConnectInfo<SocketAddr>>>,
ingress_id: Option<Extension<tower_http::request_id::RequestId>>,
headers: HeaderMap,
body: Bytes,
) -> Response {
execute(
state,
connect_info,
ingress_id,
headers,
body,
GenerationProtocol::Messages,
)
.await
}
pub(super) async fn count_tokens(
State(state): State<ApiState>,
connect_info: Option<Extension<ConnectInfo<SocketAddr>>>,
ingress_id: Option<Extension<tower_http::request_id::RequestId>>,
headers: HeaderMap,
body: Bytes,
) -> Response {
execute(
state,
connect_info,
ingress_id,
headers,
body,
GenerationProtocol::MessageTokenCount,
)
.await
}
async fn execute(
state: ApiState,
connect_info: Option<Extension<ConnectInfo<SocketAddr>>>,
ingress_id: Option<Extension<tower_http::request_id::RequestId>>,
mut headers: HeaderMap,
body: Bytes,
protocol: GenerationProtocol,
) -> Response {
let service = state.openai().clone();
let client = match authenticate_client(&service, &headers, ClientKeyHeaders::Anthropic).await {
Ok(client) => client,
Err(error) => return project_error_response(client_access_error_response(error)).await,
};
let maximum = client.snapshot().responses_max_decompressed_body_bytes();
let body = match decompress_request_body(&body, &headers, maximum) {
Ok(body) => Bytes::copy_from_slice(&body),
Err(error) => {
return error_response(
StatusCode::BAD_REQUEST,
"invalid_request_error",
&error.protocol_body().error.message,
);
}
};
headers.remove(axum::http::header::CONTENT_ENCODING);
headers.remove(axum::http::header::CONTENT_LENGTH);
let decoded = match decode_request(&body, &headers, maximum, protocol) {
Ok(decoded) => decoded,
Err(error) => return project_error_response(gateway_error_response(&error)).await,
};
let prepared = match service.execution().prepare_execution(client).await {
Ok(prepared) => prepared,
Err(error) => return project_error_response(gateway_error_response(&error)).await,
};
execute_prepared_generation(
service,
prepared,
GenerationHttpRequest {
peer_address: connect_info.map(|Extension(ConnectInfo(address))| address),
ingress_id,
headers,
decoded,
middleware_body: body,
},
None,
None,
)
.await
}
pub(super) fn decode_request(
body: &[u8],
headers: &HeaderMap,
maximum: usize,
protocol: GenerationProtocol,
) -> Result<DecodedGenerationRequest, GatewayError> {
let invalid = |message| GatewayError::new(GatewayErrorKind::InvalidRequest, message);
let body = decompress_request_body(body, headers, maximum)
.map_err(|_| invalid("Request body could not be decoded."))?;
let object = serde_json::from_slice::<Value>(&body)
.ok()
.and_then(|value| value.as_object().cloned())
.ok_or_else(|| invalid("Request body must be a JSON object."))?;
let counted = protocol == GenerationProtocol::MessageTokenCount;
let validation = if counted {
anthropic::validate_count_request(&object)
} else {
anthropic::validate_request(&object)
};
validation.map_err(|error| {
invalid(match error {
anthropic::TranslationError::InvalidRequest(message) => message,
_ => "Messages request is invalid.",
})
})?;
let model = object
.get("model")
.and_then(Value::as_str)
.unwrap_or_default()
.to_owned();
let stream = !counted
&& object
.get("stream")
.and_then(Value::as_bool)
.unwrap_or(false);
let context = OpenAiRequestHeaders::from_headers(headers).session_context();
let operation = if counted {
let payload = RawJsonPayload::new(protocol.wire(), Bytes::copy_from_slice(&body))
.map_err(|_| invalid("Request protocol is invalid."))?
.with_context(context);
Operation::CountTokens(TokenCountRequest::from_raw_json(payload))
} else {
let payload = ProtocolPayload::json_object(protocol.wire(), object)
.map_err(|_| invalid("Request protocol is invalid."))?
.with_context(context);
Operation::Generate(GenerateRequest::from_protocol_payload(payload))
};
Ok(DecodedGenerationRequest {
operation,
metadata: GenerationRequestMetadata {
requested_model: model,
stream,
store: false,
continuation: ContinuationIntent::None,
client_ip: None,
user_agent: None,
},
})
}
fn error_type(status: StatusCode) -> &'static str {
match status.as_u16() {
400 | 405 | 422 => "invalid_request_error",
401 => "authentication_error",
403 => "permission_error",
404 => "not_found_error",
413 => "request_too_large",
429 => "rate_limit_error",
503 | 529 => "overloaded_error",
_ => "api_error",
}
}
pub(super) fn error_payload(value: &Value, status: StatusCode) -> Value {
if value.get("type").and_then(Value::as_str) == Some("error") && value.get("error").is_some() {
return value.clone();
}
let error = value
.pointer("/response/error")
.or_else(|| value.get("error"))
.unwrap_or(value);
let message = error
.get("message")
.and_then(Value::as_str)
.unwrap_or("The gateway could not complete the request.");
json!({"type":"error", "error":{"type":error_type(status), "message":message}})
}
fn error_response(status: StatusCode, kind: &str, message: &str) -> Response {
let mut response = Response::new(Body::from(
json!({"type":"error", "error":{"type":kind,"message":message}}).to_string(),
));
*response.status_mut() = status;
response
.headers_mut()
.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
response
}
pub(super) async fn project_error_response(response: Response) -> Response {
if response.status().is_success() {
return response;
}
let (mut parts, body) = response.into_parts();
let bytes = axum::body::to_bytes(body, usize::MAX)
.await
.unwrap_or_default();
let value = serde_json::from_slice(&bytes)
.unwrap_or_else(|_| json!({"error":{"message":String::from_utf8_lossy(&bytes)}}));
parts.headers.remove(axum::http::header::CONTENT_LENGTH);
parts
.headers
.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
let projected = error_payload(&value, parts.status);
Response::from_parts(parts, Body::from(projected.to_string()))
}
pub(super) fn stream_error(value: &Value) -> Bytes {
Bytes::from(encode_sse_event(
"error",
&error_payload(value, StatusCode::INTERNAL_SERVER_ERROR).to_string(),
))
}
@@ -94,9 +94,10 @@ impl ExpectedBody {
pub(crate) async fn into_http_response(
response: MiddlewareResponse,
expected: ExpectedBody,
expected_protocol: &str,
) -> Response {
let (protocol, status, headers, mut body, _) = response.into_parts();
if protocol != "openai" {
if protocol != expected_protocol {
return fail_before_commit(body, MiddlewareError::InvalidState).await;
}
let head = response_head(status, headers);
@@ -64,6 +64,7 @@ where
Err(error) => return gateway_error_response(&error),
};
let protocol = input.protocol.clone();
let expected_protocol = protocol.clone();
let result = invoke_request(
execution,
prepared,
@@ -79,7 +80,9 @@ where
)
.await;
match result {
Ok(response) => into_http_response(response, ExpectedBody::SingleJson).await,
Ok(response) => {
into_http_response(response, ExpectedBody::SingleJson, &expected_protocol).await
}
Err(error) => error_response(error),
}
}
@@ -4,8 +4,10 @@ pub mod auth;
mod chat_completions;
mod endpoint;
pub mod error;
pub(crate) mod generation;
pub mod images;
pub(crate) mod live;
mod messages;
pub(crate) mod middleware;
pub mod models;
mod peer_link;
+108 -22
View File
@@ -1,4 +1,4 @@
//! OpenAI 模型目录 HTTP adapter
//! 按显式协议头投影模型目录,Codex 目录保留独立合同
use axum::{
Json,
@@ -19,7 +19,7 @@ use crate::{
};
use super::{
auth::{authenticate_client, client_access_error_response},
auth::{ClientKeyHeaders, authenticate_client, client_access_error_response},
error::{model_not_found_response, openai_error_response},
};
@@ -29,6 +29,9 @@ const CODEX_BASE_INSTRUCTIONS: &str = "You are Codex, a coding agent. Follow the
#[derive(Debug, Deserialize)]
pub(crate) struct ModelsQuery {
client_version: Option<String>,
after_id: Option<String>,
before_id: Option<String>,
limit: Option<String>,
}
/// `GET /v1/models`
@@ -38,28 +41,37 @@ pub(crate) async fn models(
Query(query): Query<ModelsQuery>,
headers: HeaderMap,
) -> Response {
let anthropic = headers.contains_key("anthropic-version") || headers.contains_key("x-api-key");
let service = state.openai();
let client = match authenticate_client(service, &headers).await {
let client = match authenticate_client(service, &headers, ClientKeyHeaders::Anthropic).await {
Ok(client) => client,
Err(error) => return client_access_error_response(error),
Err(error) => {
return model_protocol_response(client_access_error_response(error), anthropic).await;
}
};
middleware::query_response(
service.execution(),
client,
RequestInput::query(super::router::MODELS_PATH.to_owned(), None, &headers),
move |client| models_response(state, client, query),
)
.await
let mut input = RequestInput::query(super::router::MODELS_PATH.to_owned(), None, &headers);
if anthropic {
input.protocol = "anthropic".to_owned();
}
let response = middleware::query_response(service.execution(), client, input, move |client| {
models_response(state, client, query, anthropic)
})
.await;
model_protocol_response(response, anthropic).await
}
async fn models_response(
state: ApiState,
client: AuthenticatedClient,
query: ModelsQuery,
anthropic: bool,
) -> Response {
let service = state.openai();
if anthropic {
return anthropic_models_response(service.public_models(&client), &query);
}
if let Some(version) = query
.client_version
.as_deref()
@@ -147,28 +159,37 @@ pub(crate) async fn model_detail(
headers: HeaderMap,
Path(model_id): Path<String>,
) -> Response {
let anthropic = headers.contains_key("anthropic-version") || headers.contains_key("x-api-key");
let service = state.openai();
let client = match authenticate_client(service, &headers).await {
let client = match authenticate_client(service, &headers, ClientKeyHeaders::Anthropic).await {
Ok(client) => client,
Err(error) => return client_access_error_response(error),
Err(error) => {
return model_protocol_response(client_access_error_response(error), anthropic).await;
}
};
middleware::query_response(
let mut input = RequestInput::query(
format!("{}/{model_id}", super::router::MODELS_PATH),
Some(model_id.clone()),
&headers,
);
if anthropic {
input.protocol = "anthropic".to_owned();
}
let response = middleware::query_response(
service.execution(),
client,
RequestInput::query(
format!("{}/{model_id}", super::router::MODELS_PATH),
Some(model_id.clone()),
&headers,
),
move |client| async move { model_detail_response(&state, &client, model_id) },
input,
move |client| async move { model_detail_response(&state, &client, model_id, anthropic) },
)
.await
.await;
model_protocol_response(response, anthropic).await
}
fn model_detail_response(
state: &ApiState,
client: &AuthenticatedClient,
model_id: String,
anthropic: bool,
) -> Response {
let service = state.openai();
let Ok(public_model) = PublicModelId::new(model_id) else {
@@ -180,11 +201,76 @@ fn model_detail_response(
(
StatusCode::OK,
Json(openai_model_json(public_model.as_str())),
Json(if anthropic {
anthropic_model_json(public_model.as_str())
} else {
openai_model_json(public_model.as_str())
}),
)
.into_response()
}
async fn model_protocol_response(response: Response, anthropic: bool) -> Response {
if anthropic {
super::messages::project_error_response(response).await
} else {
response
}
}
fn anthropic_models_response(models: Vec<String>, query: &ModelsQuery) -> Response {
let limit = match query.limit.as_deref().unwrap_or("20").parse::<usize>() {
Ok(limit @ 1..=1000) => limit,
_ => {
return openai_error_response(
StatusCode::BAD_REQUEST,
"Model list limit must be between 1 and 1000.",
"invalid_request_error",
"invalid_limit",
)
.into_response();
}
};
let cursor = |value: &Option<String>| -> Result<Option<usize>, ()> {
value
.as_ref()
.map(|id| models.iter().position(|model| model == id).ok_or(()))
.transpose()
};
let (Ok(after), Ok(before)) = (cursor(&query.after_id), cursor(&query.before_id)) else {
return openai_error_response(
StatusCode::BAD_REQUEST,
"The model pagination cursor was not found.",
"invalid_request_error",
"invalid_cursor",
)
.into_response();
};
let start = after.map_or(0, |index| index + 1);
let end = before.unwrap_or(models.len());
let range = if before.is_some() {
start.max(end.saturating_sub(limit))..end
} else {
start..end.min(start.saturating_add(limit))
};
let data = models
.get(range.clone())
.unwrap_or_default()
.iter()
.map(|model| anthropic_model_json(model))
.collect::<Vec<_>>();
let has_more = if before.is_some() {
range.start > start
} else {
range.end < end
};
Json(json!({"first_id":data.first().and_then(|model| model.get("id")), "last_id":data.last().and_then(|model| model.get("id")), "has_more":has_more, "data":data})).into_response()
}
fn anthropic_model_json(id: &str) -> Value {
json!({"id":id, "type":"model", "display_name":id, "created_at":"1970-01-01T00:00:00Z", "capabilities":null, "max_input_tokens":null, "max_tokens":null, "line":null, "lifecycle":"active", "deprecated_at":null, "retires_at":null})
}
fn openai_model_json(id: &str) -> Value {
json!({
"id": id,
File diff suppressed because it is too large Load Diff
@@ -18,17 +18,18 @@ use tokio::sync::oneshot;
use crate::openai::middleware::{SSE_KEEPALIVE_FRAME, SSE_KEEPALIVE_INTERVAL};
pub(super) async fn response(
pub(in crate::openai) async fn response(
response: impl Future<Output = Response> + Send + 'static,
admitted: oneshot::Receiver<ResponseCommit>,
) -> Response {
response_with_encoder(response, admitted, None).await
response_with_encoder(response, admitted, None, true).await
}
pub(super) async fn response_with_encoder(
pub(in crate::openai) async fn response_with_encoder(
response: impl Future<Output = Response> + Send + 'static,
admitted: oneshot::Receiver<ResponseCommit>,
error_encoder: Option<fn(&Value) -> Bytes>,
append_done: bool,
) -> Response {
let mut response = Box::pin(response);
// 鉴权、模型门禁和准入失败仍保留原 HTTP 状态,不提前建立 SSE
@@ -48,7 +49,7 @@ pub(super) async fn response_with_encoder(
if !commit.record(Some(StatusCode::OK.as_u16())) {
return response.await;
}
let pending = PendingResponse::Waiting(response, error_encoder);
let pending = PendingResponse::Waiting(response, error_encoder, append_done);
let stream = stream::once(async { Ok::<_, axum::Error>(SSE_KEEPALIVE_FRAME) })
.chain(stream::try_unfold(pending, PendingResponse::next));
let mut response = Response::new(Body::from_stream(stream));
@@ -66,7 +67,11 @@ pub(super) async fn response_with_encoder(
}
enum PendingResponse {
Waiting(BoxFuture<'static, Response>, Option<fn(&Value) -> Bytes>),
Waiting(
BoxFuture<'static, Response>,
Option<fn(&Value) -> Bytes>,
bool,
),
Streaming(BodyDataStream),
}
@@ -74,7 +79,7 @@ impl PendingResponse {
async fn next(mut self) -> Result<Option<(Bytes, Self)>, axum::Error> {
loop {
match &mut self {
Self::Waiting(response, error_encoder) => {
Self::Waiting(response, error_encoder, append_done) => {
// 心跳只轮询同一个 future,不取消重建首帧等待或插件调用
let response = tokio::select! {
biased;
@@ -93,7 +98,7 @@ impl PendingResponse {
let body = if sse {
response.into_body()
} else {
stream_failure(response, *error_encoder).await
stream_failure(response, *error_encoder, *append_done).await
};
// 正式响应的正文已经带有交付期心跳,后续只转交,不叠加定时器
self = Self::Streaming(body.into_data_stream());
@@ -110,7 +115,11 @@ impl PendingResponse {
}
}
async fn stream_failure(response: Response, error_encoder: Option<fn(&Value) -> Bytes>) -> Body {
async fn stream_failure(
response: Response,
error_encoder: Option<fn(&Value) -> Bytes>,
append_done: bool,
) -> Body {
let status = response.status();
let retry_after = response
.headers()
@@ -157,6 +166,8 @@ async fn stream_failure(response: Response, error_encoder: Option<fn(&Value) ->
Some(encode) => encode(&data).to_vec(),
None => encode_sse_event("response.failed", &data.to_string()).into_bytes(),
};
event.extend_from_slice(DONE_SSE_FRAME.as_bytes());
if append_done {
event.extend_from_slice(DONE_SSE_FRAME.as_bytes());
}
Body::from(event)
}
@@ -2,25 +2,22 @@
mod error;
mod http;
mod keepalive;
mod request;
mod response;
mod validation;
pub(in crate::openai) mod keepalive;
pub(in crate::openai) mod request;
pub(in crate::openai) mod response;
pub(in crate::openai) mod validation;
pub mod websocket;
pub use crate::client_error::{ProtocolError, ProtocolErrorBody};
pub use crate::openai::generation::http::{collect_execution_response, stream_execution_response};
pub use crate::openai::generation::{
ContinuationIntent, DecodedGenerationRequest, GenerationRequestMetadata,
};
pub(crate) use crate::request_context::request_client_context;
pub use error::{RequestDecodeError, ResponseEncodeError};
pub(in crate::openai) use http::{HttpResponseAdapter, execute_prepared_response};
pub(crate) use http::{
ResponseAuthorization, ResponsesHttpRequest, execute_prepared_responses, responses,
};
pub use http::{collect_execution_response, stream_execution_response};
pub(crate) use http::responses;
pub(in crate::openai) use request::decompress_request_body;
pub use request::{
ContinuationIntent, DecodedResponsesRequest, OpenAiRequestHeaders, ResponsesRequestMetadata,
decode_request_with_headers,
};
pub use request::{OpenAiRequestHeaders, decode_request_with_headers};
pub(crate) use request::{decode_request_with_body, passthrough_request_headers};
pub use response::OpenAiResponsesEncoder;
pub(crate) use websocket::responses_websocket;
@@ -1,13 +1,11 @@
//! OpenAI Responses JSON 到 Core 路由事实与不透明 wire payload 的单一解码边界
use std::{borrow::Cow, fmt, net::IpAddr};
use std::borrow::Cow;
use axum::http::{HeaderMap, HeaderName, HeaderValue};
use base64::{Engine as _, engine::general_purpose::STANDARD};
use bytes::Bytes;
use gateway_core::operation::{
ClientTurn, GenerateRequest, Operation, ProtocolPayload, ProviderSessionState,
};
use gateway_core::operation::{ClientTurn, GenerateRequest, Operation, ProtocolPayload};
use gateway_protocol::openai::{
X_OPENAI_INTERNAL_CODEX_RESPONSES_LITE_HEADER, X_OPENAI_MEMGEN_REQUEST_HEADER,
is_transport_managed_request_header,
@@ -15,6 +13,9 @@ use gateway_protocol::openai::{
use serde_json::{Map, Value};
use super::error::RequestDecodeError;
use crate::openai::generation::{
ContinuationIntent, DecodedGenerationRequest, GenerationRequestMetadata,
};
const OPENAI_PROTOCOL: &str = "openai";
const OPENAI_SUBAGENT_KEY: &str = "x-openai-subagent";
@@ -179,162 +180,6 @@ fn insert_protocol_context(context: &mut Map<String, Value>, field: &str, value:
}
}
/// 客户端声明的 continuation 意图
#[derive(Clone, PartialEq, Eq)]
pub enum ContinuationIntent {
/// 不使用先前响应
None,
/// 使用当前调用方可见的 OpenAI response ID
PreviousResponseId(String),
}
impl ContinuationIntent {
/// 返回待 history owner 解析的 response ID
#[must_use]
pub fn previous_response_id(&self) -> Option<&str> {
match self {
Self::None => None,
Self::PreviousResponseId(value) => Some(value),
}
}
}
impl fmt::Debug for ContinuationIntent {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::None => formatter.write_str("None"),
Self::PreviousResponseId(_) => formatter.write_str("PreviousResponseId(<redacted>)"),
}
}
}
/// Handler、Router 和 history owner 使用的请求元数据
#[derive(Clone, PartialEq, Eq)]
pub struct ResponsesRequestMetadata {
requested_model: String,
stream: bool,
store: bool,
continuation: ContinuationIntent,
client_ip: Option<IpAddr>,
user_agent: Option<String>,
}
impl ResponsesRequestMetadata {
/// 返回客户端原始模型名
#[must_use]
pub fn requested_model(&self) -> &str {
&self.requested_model
}
/// 返回客户端是否请求 SSE
#[must_use]
pub const fn stream(&self) -> bool {
self.stream
}
/// 返回客户端 storage intent
#[must_use]
pub const fn store(&self) -> bool {
self.store
}
/// 返回 continuation intent
#[must_use]
pub const fn continuation(&self) -> &ContinuationIntent {
&self.continuation
}
/// 返回从 HTTP 连接边界解析出的客户端地址
#[must_use]
pub const fn client_ip(&self) -> Option<IpAddr> {
self.client_ip
}
/// 返回经过 UTF-8 校验和空白归一化的 User-Agent
#[must_use]
pub fn user_agent(&self) -> Option<&str> {
self.user_agent.as_deref()
}
}
impl fmt::Debug for ResponsesRequestMetadata {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("ResponsesRequestMetadata")
.field("requested_model", &self.requested_model)
.field("stream", &self.stream)
.field("store", &self.store)
.field("continuation", &self.continuation)
.field("client_ip", &self.client_ip)
.field("has_user_agent", &self.user_agent.is_some())
.finish()
}
}
/// 一次成功解码的 Responses 请求
#[derive(Clone, PartialEq)]
pub struct DecodedResponsesRequest {
operation: Operation,
metadata: ResponsesRequestMetadata,
}
impl DecodedResponsesRequest {
pub(crate) fn with_middleware_capabilities(
mut self,
request: &gateway_core::engine::middleware::MiddlewareRequest,
) -> Result<Self, gateway_core::engine::middleware::MiddlewareError> {
self.operation = request.apply_capabilities(self.operation)?;
Ok(self)
}
/// 附着当前 WebSocket 连接保存的 Provider 私有上一轮状态
#[must_use]
pub fn with_provider_session_state(mut self, state: ProviderSessionState) -> Self {
self.operation = self.operation.with_provider_session_state(state);
self
}
/// 返回协议无关 operation
#[must_use]
pub const fn operation(&self) -> &Operation {
&self.operation
}
/// 返回 handler 元数据
#[must_use]
pub const fn metadata(&self) -> &ResponsesRequestMetadata {
&self.metadata
}
/// 拆分为 operation 与元数据
#[must_use]
pub fn into_parts(self) -> (Operation, ResponsesRequestMetadata) {
(self.operation, self.metadata)
}
/// 附着只由 HTTP/WebSocket 连接边界提供的诊断事实
#[must_use]
pub fn with_client_context(
mut self,
client_ip: Option<IpAddr>,
user_agent: Option<String>,
) -> Self {
self.metadata.client_ip = client_ip;
self.metadata.user_agent = user_agent;
self
}
}
impl fmt::Debug for DecodedResponsesRequest {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("DecodedResponsesRequest")
.field("operation", &self.operation)
.field("metadata", &self.metadata)
.finish()
}
}
/// 使用下游 OpenAI/Codex 请求头解码 `POST /v1/responses`
///
/// # Errors
@@ -344,7 +189,7 @@ pub fn decode_request_with_headers(
body: &[u8],
headers: &HeaderMap,
max_decompressed_bytes: usize,
) -> Result<DecodedResponsesRequest, RequestDecodeError> {
) -> Result<DecodedGenerationRequest, RequestDecodeError> {
let body = decompress_request_body(body, headers, max_decompressed_bytes)?;
decode_request_inner(&body, &OpenAiRequestHeaders::from_headers(headers))
}
@@ -357,7 +202,7 @@ pub(crate) fn decode_request_with_body(
body: &[u8],
headers: &HeaderMap,
max_decompressed_bytes: usize,
) -> Result<(DecodedResponsesRequest, Bytes), RequestDecodeError> {
) -> Result<(DecodedGenerationRequest, Bytes), RequestDecodeError> {
let body = decompress_request_body(body, headers, max_decompressed_bytes)?;
let decoded = decode_request_inner(&body, &OpenAiRequestHeaders::from_headers(headers))?;
Ok((decoded, Bytes::copy_from_slice(&body)))
@@ -449,7 +294,7 @@ fn read_bounded<R: std::io::Read>(
pub(super) fn decode_request_inner(
body: &[u8],
request_headers: &OpenAiRequestHeaders,
) -> Result<DecodedResponsesRequest, RequestDecodeError> {
) -> Result<DecodedGenerationRequest, RequestDecodeError> {
let value =
serde_json::from_slice::<Value>(body).map_err(|_| RequestDecodeError::MalformedJson)?;
let Value::Object(object) = value else {
@@ -463,7 +308,7 @@ pub(super) fn decode_request_object(
mut object: Map<String, Value>,
request_headers: &OpenAiRequestHeaders,
source: RequestDecodeSource,
) -> Result<DecodedResponsesRequest, RequestDecodeError> {
) -> Result<DecodedGenerationRequest, RequestDecodeError> {
// 仅消费已识别的本地 transport 开关;未知同名值保留给未来上游协议
let use_websocket = object.get("use_websocket").and_then(Value::as_bool);
if use_websocket.is_some() {
@@ -523,9 +368,9 @@ pub(super) fn decode_request_object(
let operation = Operation::Generate(
GenerateRequest::from_protocol_payload(payload).with_client_turn(client_turn),
);
Ok(DecodedResponsesRequest {
Ok(DecodedGenerationRequest {
operation,
metadata: ResponsesRequestMetadata {
metadata: GenerationRequestMetadata {
requested_model: model,
stream,
store,
@@ -187,7 +187,9 @@ impl OpenAiResponsesEncoder {
}
/// 仅在非流式出口聚合同一响应的完成项,不让流式转发常驻保存输出内容
pub(super) fn collect_response(events: &[ProviderEvent]) -> Result<Value, ResponseEncodeError> {
pub(in crate::openai) fn collect_response(
events: &[ProviderEvent],
) -> Result<Value, ResponseEncodeError> {
let mut encoder = OpenAiResponsesEncoder::new();
let mut response_id = None;
let mut items = BTreeMap::new();
@@ -14,7 +14,7 @@ const MAX_IDENTIFIER_BYTES: usize = 1_024;
/// 插件输出不能安全投递为 OpenAI Responses 协议
#[derive(Debug, Clone, Copy)]
pub(super) struct ResponseValidationError;
pub(in crate::openai) struct ResponseValidationError;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum TerminalKind {
@@ -33,10 +33,10 @@ struct ExpectedResponseFacts {
/// 仅保存最终协议复核所需的响应 ID 与终态类别,不缓存流正文
#[derive(Clone, Default)]
pub(super) struct ResponseValidationFacts(Arc<Mutex<ExpectedResponseFacts>>);
pub(in crate::openai) struct ResponseValidationFacts(Arc<Mutex<ExpectedResponseFacts>>);
impl ResponseValidationFacts {
pub(super) fn observe_event(&self, event: &ProviderEvent) {
pub(in crate::openai) fn observe_event(&self, event: &ProviderEvent) {
let mut facts = self
.0
.lock()
@@ -55,7 +55,7 @@ impl ResponseValidationFacts {
}
}
pub(super) fn observe_buffered(&self, events: &[ProviderEvent], original: &[u8]) {
pub(in crate::openai) fn observe_buffered(&self, events: &[ProviderEvent], original: &[u8]) {
for event in events {
self.observe_event(event);
}
@@ -81,7 +81,7 @@ impl ResponseValidationFacts {
.clone()
}
pub(super) fn response_id(&self) -> Option<String> {
pub(in crate::openai) fn response_id(&self) -> Option<String> {
self.snapshot().response_id
}
}
@@ -146,7 +146,7 @@ impl ExpectedResponseFacts {
}
/// 只复核中间件确实改写过的完整 JSON;未经改写的原生快路保持原行为
pub(super) fn validate_buffered_response(
pub(in crate::openai) fn validate_buffered_response(
facts: &ResponseValidationFacts,
modified: &[u8],
) -> Result<(), ResponseValidationError> {
@@ -176,7 +176,7 @@ pub(super) fn validate_buffered_response(
/// 原始前缀只旁路构建状态;直到插件首次改写或丢弃正文才启用严格拒绝,避免给
/// 无策略原生热路增加新的兼容性条件
#[derive(Debug, Default)]
pub(super) struct ResponsesDeliveryValidator {
pub(in crate::openai) struct ResponsesDeliveryValidator {
active: bool,
invalid_prefix: bool,
state: DeliveryState,
@@ -184,7 +184,7 @@ pub(super) struct ResponsesDeliveryValidator {
impl ResponsesDeliveryValidator {
/// 复核实际交付帧;只有宿主标记为已改写时才激活严格模式
pub(super) fn validate_frame(
pub(in crate::openai) fn validate_frame(
&mut self,
delivered: &[u8],
transformed: bool,
@@ -194,7 +194,7 @@ impl ResponsesDeliveryValidator {
}
/// WebSocket JSON message 与 SSE 共用同一响应顺序和关联校验
pub(super) fn validate_websocket_frame(
pub(in crate::openai) fn validate_websocket_frame(
&mut self,
delivered: &[u8],
transformed: bool,
@@ -263,11 +263,11 @@ impl ResponsesDeliveryValidator {
self.state.apply(parsed)
}
pub(super) fn response_id(&self) -> Option<&str> {
pub(in crate::openai) fn response_id(&self) -> Option<&str> {
self.state.response_id.as_deref()
}
pub(super) fn finish_delivery(&self) -> Result<(), ResponseValidationError> {
pub(in crate::openai) fn finish_delivery(&self) -> Result<(), ResponseValidationError> {
if !self.active || self.state.done {
Ok(())
} else {
@@ -275,12 +275,14 @@ impl ResponsesDeliveryValidator {
}
}
pub(super) fn completed_response_id(&self) -> Option<&str> {
pub(in crate::openai) fn completed_response_id(&self) -> Option<&str> {
self.response_id()
.filter(|_| self.state.terminal == Some(TerminalKind::Completed))
}
pub(super) fn finish_websocket_delivery(&self) -> Result<(), ResponseValidationError> {
pub(in crate::openai) fn finish_websocket_delivery(
&self,
) -> Result<(), ResponseValidationError> {
if !self.active || self.state.terminal.is_some() {
Ok(())
} else {
@@ -22,7 +22,7 @@ use crate::openai::middleware::{PendingExecution, pending_execution_response};
use crate::openai::responses::validation::{ResponseValidationFacts, ResponsesDeliveryValidator};
use super::{
super::{DecodedResponsesRequest, OpenAiResponsesEncoder, ProtocolErrorBody},
super::{DecodedGenerationRequest, OpenAiResponsesEncoder, ProtocolErrorBody},
connection::{
ConnectionEvent, FramePhase, ResponsesWebSocketConnection, WriteContext, WriteOutcome,
},
@@ -45,7 +45,7 @@ pub(super) struct ConnectionReplaySnapshot {
}
impl ConnectionReplaySnapshot {
pub(super) fn prepare(&self, request: DecodedResponsesRequest) -> DecodedResponsesRequest {
pub(super) fn prepare(&self, request: DecodedGenerationRequest) -> DecodedGenerationRequest {
match (
request.metadata().continuation().previous_response_id(),
self.last_response_id.as_deref(),
@@ -32,7 +32,7 @@ use crate::{
ApiState,
openai::middleware::{RequestInput, invoke_request, request_parts},
openai::{
auth::{authenticate_client, client_access_error_response},
auth::{ClientKeyHeaders, authenticate_client, client_access_error_response},
error::runtime_unavailable_response,
service::OpenAiService,
},
@@ -65,7 +65,7 @@ pub(crate) async fn responses_websocket(
websocket: Upgrade,
) -> Response {
let service = state.openai().clone();
let client = match authenticate_client(&service, &headers).await {
let client = match authenticate_client(&service, &headers, ClientKeyHeaders::Bearer).await {
Ok(client) => client,
Err(error) => return client_access_error_response(error),
};
@@ -365,7 +365,7 @@ async fn serve_responses_websocket(socket: Socket, session: ResponsesWebSocketSe
.prepare(decoded)
.with_middleware_capabilities(&request)?;
let started = service_for_terminal
.start_prepared_response(
.start_prepared_generation(
prepared,
decoded,
ClientTransport::WebSocket,
@@ -12,7 +12,7 @@ use thiserror::Error;
use crate::openai::error::{gateway_error_contract, gateway_error_from_engine};
use super::super::{
DecodedResponsesRequest, ProtocolErrorBody, RequestDecodeError,
DecodedGenerationRequest, ProtocolErrorBody, RequestDecodeError,
request::{OpenAiRequestHeaders, RequestDecodeSource},
};
@@ -27,7 +27,7 @@ use super::super::{
pub fn decode_response_create_with_context(
payload: &str,
request_headers: &OpenAiRequestHeaders,
) -> Result<DecodedResponsesRequest, ResponseCreateFrameError> {
) -> Result<DecodedGenerationRequest, ResponseCreateFrameError> {
decode_response_create_inner(payload, request_headers)
}
@@ -52,7 +52,7 @@ pub(super) fn is_response_create(payload: &str) -> bool {
fn decode_response_create_inner(
payload: &str,
request_headers: &OpenAiRequestHeaders,
) -> Result<DecodedResponsesRequest, ResponseCreateFrameError> {
) -> Result<DecodedGenerationRequest, ResponseCreateFrameError> {
let Value::Object(mut body) = serde_json::from_str::<Value>(payload)
.map_err(|_| ResponseCreateFrameError::InvalidJson)?
else {
@@ -10,6 +10,7 @@ use super::{
chat_completions::chat_completions,
images::{image_edits, image_generations},
live,
messages::{count_tokens, messages},
models::{model_detail, models},
responses::{responses, responses_websocket},
search::standalone_search,
@@ -20,6 +21,8 @@ use crate::ApiState;
// 公开协议路径由 API 层统一定义;Core 使用操作类型,不根据这些路径分派业务
pub(super) const RESPONSES_PATH: &str = "/v1/responses";
pub(super) const MESSAGES_PATH: &str = "/v1/messages";
pub(super) const MESSAGE_TOKENS_PATH: &str = "/v1/messages/count_tokens";
pub(super) const CHAT_COMPLETIONS_PATH: &str = "/v1/chat/completions";
pub(super) const IMAGE_GENERATIONS_PATH: &str = "/v1/images/generations";
pub(super) const IMAGE_EDITS_PATH: &str = "/v1/images/edits";
@@ -37,6 +40,8 @@ pub(crate) fn router() -> Router<ApiState> {
.route(SEARCH_PATH, post(standalone_search))
.route(RESPONSES_PATH, get(responses_websocket).post(responses))
.route(CHAT_COMPLETIONS_PATH, post(chat_completions))
.route(MESSAGES_PATH, post(messages))
.route(MESSAGE_TOKENS_PATH, post(count_tokens))
.route(MODELS_PATH, get(models))
// 官方 OpenAI 模型详情合同使用 path ID;它不属于 Admin API 约束
.route(MODEL_DETAIL_PATH, get(model_detail))
@@ -16,7 +16,7 @@ use crate::ApiState;
use crate::middleware::headers::encode_headers;
use crate::openai::middleware::RequestInput;
use crate::openai::{
auth::{authenticate_client, client_access_error_response},
auth::{ClientKeyHeaders, authenticate_client, client_access_error_response},
endpoint::provider_endpoint_response,
responses::{OpenAiRequestHeaders, request_client_context},
router::SEARCH_PATH,
@@ -32,7 +32,7 @@ pub(crate) async fn standalone_search(
body: Bytes,
) -> Response {
let service = state.openai();
let client = match authenticate_client(service, &headers).await {
let client = match authenticate_client(service, &headers, ClientKeyHeaders::Bearer).await {
Ok(client) => client,
Err(error) => return client_access_error_response(error),
};
@@ -18,7 +18,7 @@ use gateway_core::routing::{
use uuid::Uuid;
use super::auth::ClientApiKeyAuthError;
use super::responses::{ContinuationIntent, DecodedResponsesRequest};
use super::responses::{ContinuationIntent, DecodedGenerationRequest};
/// OpenAI HTTP/WS adapter 共享的 Core 与连接生命周期能力
#[derive(Clone)]
@@ -89,14 +89,15 @@ impl OpenAiService {
self.execution.contains_public_model(client, model)
}
pub(crate) async fn start_prepared_response(
pub(crate) async fn start_prepared_generation(
&self,
prepared: PreparedRootExecution,
request: DecodedResponsesRequest,
request: DecodedGenerationRequest,
transport: ClientTransport,
endpoint: &'static str,
) -> Result<StartedExecution, GatewayError> {
let (operation, metadata) = request.into_parts();
let protocol = operation.protocol().to_owned();
let public_model = PublicModelId::from_client_wire(metadata.requested_model().to_owned())
.map_err(|_| {
GatewayError::new(
@@ -117,7 +118,7 @@ impl OpenAiService {
public_model,
operation,
metadata: ExecutionRequestMetadata {
protocol: "openai".to_owned(),
protocol,
endpoint: endpoint.to_owned(),
transport,
stream: metadata.stream(),
+3 -3
View File
@@ -27,7 +27,7 @@ use gateway_core::{
use crate::{
ApiState,
openai::{
auth::{authenticate_client, client_access_error_response},
auth::{ClientKeyHeaders, authenticate_client, client_access_error_response},
error::{engine_error_response, gateway_error_response, openai_error_response},
middleware::PendingExecution,
responses::request_client_context,
@@ -67,7 +67,7 @@ async fn count_tokens(
body: Bytes,
) -> Response {
let service = state.openai();
let client = match authenticate_client(service, &headers).await {
let client = match authenticate_client(service, &headers, ClientKeyHeaders::Bearer).await {
Ok(client) => client,
Err(error) => return client_access_error_response(error),
};
@@ -132,7 +132,7 @@ async fn provider_http(
_ => return invalid_request("Provider HTTP method is unsupported."),
};
let service = state.openai();
let client = match authenticate_client(service, &headers).await {
let client = match authenticate_client(service, &headers, ClientKeyHeaders::Bearer).await {
Ok(client) => client,
Err(error) => return client_access_error_response(error),
};
@@ -984,7 +984,7 @@ mod actions {
assert_eq!(
events,
[
json!({ "type": "test_start", "model": "grok-4.5", "text": "正在连接上游 Responses" }),
json!({ "type": "test_start", "model": "grok-4.5", "text": "正在连接上游" }),
json!({
"type": "request",
"payload": {
@@ -86,7 +86,7 @@ async fn authentication_unknown_routes_and_method_errors_are_observable() {
),
(
"POST",
"/v1/messages?secret=SENSITIVE_QUERY",
"/v1/unknown?secret=SENSITIVE_QUERY",
StatusCode::NOT_FOUND,
"unknown_endpoint",
),
@@ -1,12 +1,8 @@
//! Chat HTTP 夹具和共享执行、鉴权、插件及终结边界
use std::{
collections::VecDeque,
io::Write as _,
sync::{
Arc, Mutex,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
sync::{Arc, Mutex, atomic::Ordering},
time::Duration,
};
@@ -19,11 +15,10 @@ use bytes::Bytes;
use futures::future::BoxFuture;
use gateway_core::{
engine::{
CommitRequirement, CoordinatedEvent, EngineError, ModelRequestId,
ModelRequestId,
execution::{
AuthenticatedClient, ClientAuthenticationError, ExecutionService, ExecutionSession,
PreparedRootExecution, ResponseCommit, StartExecution, StartProviderExecution,
StartedExecution,
AuthenticatedClient, ClientAuthenticationError, ExecutionService,
PreparedRootExecution, StartExecution, StartProviderExecution, StartedExecution,
},
middleware::{
FrozenMiddlewarePlan, MiddlewareContext, MiddlewareError, MiddlewareNext,
@@ -31,7 +26,7 @@ use gateway_core::{
},
},
error::GatewayError,
event::{ProviderEvent, ProviderResponseHeader},
event::ProviderResponseHeader,
operation::Operation,
routing::{
PublicModelId,
@@ -50,136 +45,7 @@ use crate::openai::{
pub(super) const PATH: &str = "/v1/chat/completions";
const KEY: &str = "sk_chat_fixture";
#[derive(Default)]
pub(super) struct Trace {
pub commits: AtomicUsize,
pub discarded: AtomicUsize,
pub cancelled: AtomicBool,
pub finalized: AtomicBool,
pub detached: AtomicUsize,
response_commit: ResponseCommit,
}
#[derive(Default)]
pub(super) enum Finish {
#[default]
Success,
Error,
Pending,
}
pub(super) struct Session {
events: VecDeque<Vec<ProviderEvent>>,
pub trace: Arc<Trace>,
pub finish: Finish,
pub delay: Option<Duration>,
pub fail_commit: bool,
pub response_headers: Vec<ProviderResponseHeader>,
committed: bool,
buffered: bool,
}
impl Session {
pub fn new(events: Vec<ProviderEvent>) -> Self {
Self {
events: events.into_iter().map(|event| vec![event]).collect(),
trace: Arc::default(),
finish: Finish::Success,
delay: None,
fail_commit: false,
response_headers: Vec::new(),
committed: false,
buffered: false,
}
}
pub fn with_batch(mut self, events: Vec<ProviderEvent>) -> Self {
self.events.push_back(events);
self
}
}
impl ExecutionSession for Session {
fn response_commit(&self) -> ResponseCommit {
self.trace.response_commit.clone()
}
fn next_event(&mut self) -> BoxFuture<'_, Result<Option<CoordinatedEvent>, EngineError>> {
Box::pin(async move {
if let Some(delay) = self.delay.take() {
tokio::time::sleep(delay).await;
}
if let Some(event) = self.events.pop_front() {
let requirement = if self.committed {
CommitRequirement::AlreadyCommitted
} else {
CommitRequirement::CommitBeforeDelivery
};
return CoordinatedEvent::try_batch(event, requirement).map(Some);
}
match self.finish {
Finish::Success => {
self.trace.finalized.store(true, Ordering::SeqCst);
Ok(None)
}
Finish::Error => {
self.trace.finalized.store(true, Ordering::SeqCst);
Err(EngineError::ProviderMetadataMismatch)
}
Finish::Pending => futures::future::pending().await,
}
})
}
fn collect_uncommitted(&mut self) -> BoxFuture<'_, Result<Vec<ProviderEvent>, EngineError>> {
self.buffered = true;
Box::pin(async move { Ok(self.events.drain(..).flatten().collect()) })
}
fn response_headers(&self) -> &[ProviderResponseHeader] {
&self.response_headers
}
fn discard_pending_delivery(&mut self) -> Result<(), EngineError> {
self.trace.discarded.fetch_add(1, Ordering::SeqCst);
Ok(())
}
fn commit_downstream(&mut self, status: Option<u16>) -> BoxFuture<'_, Result<(), EngineError>> {
Box::pin(async move {
self.trace.commits.fetch_add(1, Ordering::SeqCst);
if self.fail_commit {
return Err(EngineError::ProviderMetadataMismatch);
}
self.trace.response_commit.record(status);
self.committed = true;
if self.buffered {
self.trace.finalized.store(true, Ordering::SeqCst);
}
Ok(())
})
}
fn record_client_status(&mut self, status: u16) -> BoxFuture<'_, Result<(), EngineError>> {
Box::pin(async move {
self.trace.response_commit.record(Some(status));
Ok(())
})
}
fn is_finalized(&self) -> bool {
self.trace.finalized.load(Ordering::SeqCst)
}
fn cancel(&self) {
self.trace.cancelled.store(true, Ordering::SeqCst);
}
fn detach_finalize(self: Box<Self>) -> BoxFuture<'static, ()> {
Box::pin(async move {
self.trace.detached.fetch_add(1, Ordering::SeqCst);
self.trace.finalized.store(true, Ordering::SeqCst);
})
}
}
use crate::support::generation::{Finish, Session};
#[derive(Clone, Debug)]
pub(super) struct Captured {
@@ -255,7 +121,7 @@ impl ExecutionService for Execution {
pub(super) struct Fixture {
pub router: axum::Router,
pub execution: Arc<Execution>,
pub trace: Arc<Trace>,
pub trace: Arc<crate::support::generation::Trace>,
}
impl Fixture {
@@ -5,7 +5,7 @@ use serde_json::{Value, json};
use super::{
chat_request, completed,
http::{Fixture, Session, json_body},
http::{Fixture, json_body},
message,
};
@@ -417,3 +417,5 @@ async fn files_and_audio_are_preserved_as_inputs_instead_of_losing_the_user_turn
);
}
}
use crate::support::generation::Session;
@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
use super::{
chat_request, completed, created,
http::{Fixture, Session, json_body},
http::{Fixture, json_body},
message, wire,
};
@@ -892,3 +892,5 @@ async fn streaming_citation_offsets_follow_delivered_text_when_messages_interlea
assert_eq!(annotations[0]["url_citation"]["start_index"], 4);
assert_eq!(annotations[0]["url_citation"]["end_index"], 6);
}
use crate::support::generation::Session;
@@ -0,0 +1,305 @@
//! Messages 原生交付、错误格式、计数与公共生命周期的接口合同
use axum::{
body::{Body, to_bytes},
http::{Request, StatusCode},
};
use bytes::Bytes;
use futures::{StreamExt as _, future::BoxFuture};
use gateway_core::{
engine::ModelRequestId,
engine::execution::{
AuthenticatedClient, ClientAuthenticationError, ExecutionService, StartExecution,
StartProviderExecution, StartedExecution,
},
error::GatewayError,
event::{ProtocolWireEvent, ProviderEvent},
operation::Operation,
routing::PublicModelId,
};
use serde_json::{Value, json};
use std::sync::{Arc, Mutex, atomic::Ordering};
use tower::ServiceExt as _;
use super::{api_router, authenticated_client};
use crate::support::generation::{Finish, Session};
struct Execution {
session: Mutex<Option<Session>>,
captured: Mutex<Option<Operation>>,
}
impl ExecutionService for Execution {
fn authenticate(&self, key: &str) -> Result<AuthenticatedClient, ClientAuthenticationError> {
if key == "sk_messages_test" {
Ok(authenticated_client(key))
} else {
Err(ClientAuthenticationError::InvalidKey)
}
}
fn public_models(&self, _: &AuthenticatedClient) -> Vec<PublicModelId> {
vec![]
}
fn contains_public_model(&self, _: &AuthenticatedClient, _: &PublicModelId) -> bool {
true
}
fn start(
&self,
request: StartExecution,
) -> BoxFuture<'_, Result<StartedExecution, GatewayError>> {
Box::pin(async move {
assert_eq!(request.metadata.protocol, "anthropic");
assert!(request.metadata.endpoint.starts_with("/v1/messages"));
*self.captured.lock().unwrap() = Some(request.operation);
Ok(StartedExecution {
request_id: ModelRequestId::new("req_messages").unwrap(),
created_at: std::time::SystemTime::now(),
stream: request.metadata.stream,
session: Box::new(self.session.lock().unwrap().take().unwrap()),
})
})
}
fn start_provider_endpoint(
&self,
_: StartProviderExecution,
) -> BoxFuture<'_, Result<StartedExecution, GatewayError>> {
Box::pin(async { panic!("Messages uses model execution") })
}
}
fn wire(value: Value) -> ProviderEvent {
ProviderEvent::wire(
ProtocolWireEvent::json(
"anthropic",
value.get("type").and_then(Value::as_str).map(str::to_owned),
value,
)
.unwrap(),
)
}
fn message() -> Value {
json!({"id":"msg_native","type":"message","role":"assistant","model":"native-model","content":[{"type":"text","text":"你好"}],"stop_reason":"end_turn","usage":{"input_tokens":3,"output_tokens":2},"future_extension":{"preserved":true}})
}
fn stream_events() -> Vec<ProviderEvent> {
vec![
wire(
json!({"type":"message_start","message":{"id":"msg_native","type":"message","role":"assistant","model":"native-model","content":[],"stop_reason":null,"usage":{"input_tokens":3,"output_tokens":0}}}),
),
wire(
json!({"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}),
),
wire(
json!({"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"你好"}}),
),
wire(json!({"type":"content_block_stop","index":0})),
wire(
json!({"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":2}}),
),
wire(json!({"type":"message_stop"})),
]
}
fn request(path: &str, stream: bool) -> Request<Body> {
Request::post(path).header("x-api-key", "sk_messages_test").header("anthropic-version", "2023-06-01").header("content-type", "application/json")
.body(Body::from(json!({"model":"model-a","max_tokens":0,"stream":stream,"messages":[{"role":"user","content":"你好"}],"future_extension":{"preserved":true}}).to_string())).unwrap()
}
async fn fixture(session: Session) -> (axum::Router, Arc<Execution>) {
let execution = Arc::new(Execution {
session: Mutex::new(Some(session)),
captured: Mutex::default(),
});
(api_router(execution.clone()).await, execution)
}
#[tokio::test]
async fn native_json_preserves_extensions_and_uses_client_key_authentication() {
let raw = Bytes::from(format!(" {}\n", message()));
let session = Session::new(vec![ProviderEvent::wire(
ProtocolWireEvent::raw_json("anthropic", raw.clone()).unwrap(),
)]);
let trace = session.trace.clone();
let (router, execution) = fixture(session).await;
let response = router
.oneshot(request("/v1/messages", false))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let bytes = to_bytes(response.into_body(), usize::MAX).await.unwrap();
assert_eq!(bytes, raw);
let body: Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(body, message());
let captured = execution.captured.lock().unwrap();
let Operation::Generate(generation) = captured.as_ref().unwrap() else {
panic!("generate")
};
assert_eq!(generation.protocol_payload().protocol(), "anthropic");
assert_eq!(
generation.protocol_payload().body()["future_extension"]["preserved"],
true
);
assert_eq!(generation.max_output_tokens(), Some(0));
assert_eq!(trace.commits.load(Ordering::SeqCst), 1);
assert!(trace.finalized.load(Ordering::SeqCst));
}
#[tokio::test]
async fn native_stream_ends_at_message_stop_without_openai_done() {
let session = Session::new(stream_events());
let trace = session.trace.clone();
let (router, _) = fixture(session).await;
let response = router.oneshot(request("/v1/messages", true)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let bytes = to_bytes(response.into_body(), usize::MAX).await.unwrap();
let text = std::str::from_utf8(&bytes).unwrap();
assert!(text.contains("你好"));
assert!(text.ends_with("event: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"));
assert!(!text.contains("[DONE]"));
assert_eq!(trace.commits.load(Ordering::SeqCst), 1);
assert!(trace.finalized.load(Ordering::SeqCst));
}
#[tokio::test]
async fn buffered_client_aggregates_native_events_and_cumulative_usage() {
let (router, _) = fixture(Session::new(stream_events())).await;
let response = router
.oneshot(request("/v1/messages", false))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let body: Value =
serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap()).unwrap();
assert_eq!(body["content"][0]["text"], "你好");
assert_eq!(body["usage"], json!({"input_tokens":3,"output_tokens":2}));
assert_eq!(body["stop_reason"], "end_turn");
}
#[tokio::test]
async fn count_tokens_uses_its_own_operation_without_generation_budget() {
let (router, execution) = fixture(Session::new(vec![wire(json!({"input_tokens":9}))])).await;
let request = Request::post("/v1/messages/count_tokens")
.header("x-api-key", "sk_messages_test")
.header("content-type", "application/json")
.body(Body::from(
json!({"model":"model-a","messages":[{"role":"user","content":"hello"}]}).to_string(),
))
.unwrap();
let response = router.oneshot(request).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let body: Value =
serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap()).unwrap();
assert_eq!(body, json!({"input_tokens":9}));
assert!(matches!(
execution.captured.lock().unwrap().as_ref(),
Some(Operation::CountTokens(_))
));
}
#[tokio::test]
async fn authentication_errors_use_messages_envelope() {
let (router, _) = fixture(Session::new(vec![])).await;
let response = router
.oneshot(Request::post("/v1/messages").body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
let body: Value =
serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap()).unwrap();
assert_eq!(body["type"], "error");
assert_eq!(body["error"]["type"], "authentication_error");
}
#[tokio::test]
async fn stream_failure_and_disconnect_finalize_the_same_execution() {
let mut session = Session::new(vec![stream_events().remove(0)]);
session.finish = Finish::Error;
let trace = session.trace.clone();
let (router, _) = fixture(session).await;
let response = router.oneshot(request("/v1/messages", true)).await.unwrap();
let bytes = to_bytes(response.into_body(), usize::MAX).await.unwrap();
let text = std::str::from_utf8(&bytes).unwrap();
assert!(text.contains("event: error\n"));
assert!(!text.contains("[DONE]"));
assert!(trace.finalized.load(Ordering::SeqCst));
let mut session = Session::new(vec![stream_events().remove(0)]);
session.finish = Finish::Pending;
let trace = session.trace.clone();
let (router, _) = fixture(session).await;
let response = router.oneshot(request("/v1/messages", true)).await.unwrap();
let mut stream = response.into_body().into_data_stream();
assert!(
stream
.next()
.await
.unwrap()
.unwrap()
.starts_with(b"event: message_start")
);
drop(stream);
tokio::task::yield_now().await;
assert!(trace.cancelled.load(Ordering::SeqCst));
assert!(trace.finalized.load(Ordering::SeqCst));
}
#[tokio::test]
async fn sse_preserves_raw_frames() {
let raw = Bytes::from_static(b"event: message_start\nid: frame-1\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_native\"},\"future\":true}\n\n");
let event = ProtocolWireEvent::json_with_raw_sse_metadata(
"anthropic",
Some("message_start".to_owned()),
json!({"type":"message_start","message":{"id":"msg_native"},"future":true}),
raw.clone(),
Some("frame-1".to_owned()),
None,
)
.unwrap();
let (router, _) = fixture(Session::new(vec![
ProviderEvent::wire(event),
wire(json!({"type":"message_stop"})),
]))
.await;
let response = router.oneshot(request("/v1/messages", true)).await.unwrap();
let bytes = to_bytes(response.into_body(), usize::MAX).await.unwrap();
assert!(bytes.starts_with(&raw));
}
#[tokio::test]
async fn streaming_client_can_receive_a_complete_native_json_response() {
let event = ProviderEvent::wire(
ProtocolWireEvent::raw_json("anthropic", message().to_string().into()).unwrap(),
);
let (router, _) = fixture(Session::new(vec![event])).await;
let response = router.oneshot(request("/v1/messages", true)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let bytes = to_bytes(response.into_body(), usize::MAX).await.unwrap();
let text = std::str::from_utf8(&bytes).unwrap();
assert!(text.contains("event: message_start\n"));
assert!(text.contains("future_extension"));
assert!(text.contains("你好"));
assert!(text.contains("event: message_stop\n"));
}
#[tokio::test]
async fn native_future_non_json_events_remain_opaque_but_missing_stop_is_an_error() {
let raw = Bytes::from_static(b"event: future_extension\ndata: opaque future payload\n\n");
let mut events = stream_events();
events.insert(
1,
ProviderEvent::wire(ProtocolWireEvent::raw_sse("anthropic", raw.clone()).unwrap()),
);
let (router, _) = fixture(Session::new(events)).await;
let response = router.oneshot(request("/v1/messages", true)).await.unwrap();
let bytes = to_bytes(response.into_body(), usize::MAX).await.unwrap();
assert!(bytes.windows(raw.len()).any(|window| window == raw));
let (router, _) = fixture(Session::new(vec![stream_events().remove(0)])).await;
let response = router.oneshot(request("/v1/messages", true)).await.unwrap();
let bytes = to_bytes(response.into_body(), usize::MAX).await.unwrap();
assert!(
std::str::from_utf8(&bytes)
.unwrap()
.contains("event: error\n")
);
}
@@ -7,6 +7,7 @@ mod error;
mod image_policy;
mod images;
mod live;
mod messages;
mod middleware;
mod models;
mod peer_link;
@@ -22,6 +22,96 @@ use tower::ServiceExt;
use super::{api_router, authenticated_client, authenticated_client_with_min_versions};
#[tokio::test]
async fn anthropic_models_use_explicit_headers_and_cursor_pagination() {
let router = api_router(ModelsExecution::new()).await;
for (path, id, more) in [
("/v1/models?limit=1", "model-a", true),
("/v1/models?limit=1&after_id=model-a", "model-b", false),
("/v1/models?limit=1&before_id=model-b", "model-a", false),
] {
let response = router
.clone()
.oneshot(
Request::get(path)
.header("x-api-key", "sk_models_test")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let body: serde_json::Value =
serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap())
.unwrap();
assert_eq!(body["data"].as_array().unwrap().len(), 1);
assert_eq!(body["data"][0]["type"], "model");
assert_eq!(body["first_id"], id);
assert_eq!(body["last_id"], id);
assert_eq!(body["has_more"], more);
assert!(body.get("object").is_none());
}
for path in [
"/v1/models?limit=0",
"/v1/models?limit=1001",
"/v1/models?limit=invalid",
"/v1/models?after_id=unknown",
] {
let response = router
.clone()
.oneshot(
Request::get(path)
.header("authorization", "Bearer sk_models_test")
.header("anthropic-version", "2023-06-01")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let body: serde_json::Value =
serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap())
.unwrap();
assert_eq!(body["type"], "error");
assert_eq!(body["error"]["type"], "invalid_request_error");
}
}
#[tokio::test]
async fn anthropic_model_detail_keeps_public_model_access() {
let router = api_router(ModelsExecution::new()).await;
for (path, expected) in [
("/v1/models/model-a", StatusCode::OK),
("/v1/models/unknown", StatusCode::NOT_FOUND),
] {
let response = router
.clone()
.oneshot(
Request::get(path)
.header("x-api-key", "sk_models_test")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), expected);
let body: serde_json::Value =
serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap())
.unwrap();
if expected == StatusCode::NOT_FOUND {
assert_eq!(body["error"]["type"], "not_found_error");
}
assert_eq!(
body["type"],
if expected == StatusCode::OK {
"model"
} else {
"error"
}
);
}
}
pub(super) struct ModelsExecution {
client: AuthenticatedClient,
presentation: Option<ModelPresentation>,
@@ -8,7 +8,7 @@ use axum::http::{HeaderMap, HeaderValue};
use base64::{Engine as _, engine::general_purpose::STANDARD};
use bytes::Bytes;
use gateway_api::openai::responses::{
ContinuationIntent, DecodedResponsesRequest, OpenAiRequestHeaders, OpenAiResponsesEncoder,
ContinuationIntent, DecodedGenerationRequest, OpenAiRequestHeaders, OpenAiResponsesEncoder,
RequestDecodeError, ResponseCreateFrameError, ResponseEncodeError, decode_request_with_headers,
decode_response_create_with_context,
};
@@ -20,17 +20,17 @@ use gateway_core::{
use gateway_protocol::openai::sse::parse_sse_events;
use serde_json::{Value, json};
fn decode_request(body: &[u8]) -> Result<DecodedResponsesRequest, RequestDecodeError> {
fn decode_request(body: &[u8]) -> Result<DecodedGenerationRequest, RequestDecodeError> {
decode_request_with_headers(body, &HeaderMap::new(), 64 * 1024 * 1024)
}
fn decode_response_create(
payload: &str,
) -> Result<DecodedResponsesRequest, ResponseCreateFrameError> {
) -> Result<DecodedGenerationRequest, ResponseCreateFrameError> {
decode_response_create_with_context(payload, &OpenAiRequestHeaders::default())
}
fn generate_request(body: Value) -> DecodedResponsesRequest {
fn generate_request(body: Value) -> DecodedGenerationRequest {
decode_request(body.to_string().as_bytes()).expect("test request should decode")
}
@@ -78,7 +78,7 @@ fn decoder_should_attach_only_identified_codex_inference_turns() {
}
fn generate_operation(
decoded: &DecodedResponsesRequest,
decoded: &DecodedGenerationRequest,
) -> &gateway_core::operation::GenerateRequest {
let Operation::Generate(request) = decoded.operation() else {
panic!("Responses decoder must produce Generate")
@@ -86,11 +86,11 @@ fn generate_operation(
request
}
fn openai_wire_body(decoded: &DecodedResponsesRequest) -> &serde_json::Map<String, Value> {
fn openai_wire_body(decoded: &DecodedGenerationRequest) -> &serde_json::Map<String, Value> {
generate_operation(decoded).protocol_payload().body()
}
fn openai_protocol_context(decoded: &DecodedResponsesRequest) -> &serde_json::Map<String, Value> {
fn openai_protocol_context(decoded: &DecodedGenerationRequest) -> &serde_json::Map<String, Value> {
generate_operation(decoded).protocol_payload().context()
}
@@ -19,7 +19,7 @@ use axum::{
use bytes::Bytes;
use futures::{SinkExt, StreamExt, future::BoxFuture};
use gateway_api::openai::responses::{
DecodedResponsesRequest, OpenAiRequestHeaders, ResponseCreateFrameError,
DecodedGenerationRequest, OpenAiRequestHeaders, ResponseCreateFrameError,
decode_response_create_with_context,
};
use gateway_core::account::ProviderAccountId;
@@ -69,7 +69,7 @@ use crate::openai::{
fn decode_response_create_with_turn_header(
payload: Value,
opening_turn_metadata: &'static str,
) -> DecodedResponsesRequest {
) -> DecodedGenerationRequest {
let mut headers = HeaderMap::new();
headers.insert(
"x-codex-turn-metadata",
@@ -145,10 +145,13 @@ async fn configured_cors_origin_assembles_router_and_answers_preflight() {
.oneshot(
Request::builder()
.method(Method::OPTIONS)
.uri("/v1/models")
.uri("/v1/messages")
.header("origin", "https://app.example.com")
.header("access-control-request-method", "GET")
.header("access-control-request-headers", "authorization")
.header("access-control-request-method", "POST")
.header(
"access-control-request-headers",
"x-api-key,content-type,anthropic-version,anthropic-beta",
)
.body(Body::empty())
.expect("build preflight request"),
)
@@ -177,5 +180,7 @@ async fn configured_cors_origin_assembles_router_and_answers_preflight() {
.expect("allow-headers present");
assert!(allow_headers.contains("authorization"));
assert!(allow_headers.contains("x-api-key"));
assert!(allow_headers.contains("anthropic-version"));
assert!(allow_headers.contains("anthropic-beta"));
assert!(allow_headers.contains("x-request-id"));
}
@@ -0,0 +1,149 @@
//! 各生成协议共用的执行会话夹具,记录提交、取消与终结事实
use futures::future::BoxFuture;
use gateway_core::{
engine::{
CommitRequirement, CoordinatedEvent, EngineError,
execution::{ExecutionSession, ResponseCommit},
},
event::{ProviderEvent, ProviderResponseHeader},
};
use std::{
collections::VecDeque,
sync::{
Arc,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
time::Duration,
};
#[derive(Default)]
pub(crate) struct Trace {
pub commits: AtomicUsize,
pub discarded: AtomicUsize,
pub cancelled: AtomicBool,
pub finalized: AtomicBool,
pub detached: AtomicUsize,
pub response_commit: ResponseCommit,
}
#[derive(Default)]
pub(crate) enum Finish {
#[default]
Success,
Error,
Pending,
}
pub(crate) struct Session {
events: VecDeque<Vec<ProviderEvent>>,
pub trace: Arc<Trace>,
pub finish: Finish,
pub delay: Option<Duration>,
pub fail_commit: bool,
pub response_headers: Vec<ProviderResponseHeader>,
committed: bool,
buffered: bool,
}
impl Session {
pub fn new(events: Vec<ProviderEvent>) -> Self {
Self {
events: events.into_iter().map(|event| vec![event]).collect(),
trace: Arc::default(),
finish: Finish::Success,
delay: None,
fail_commit: false,
response_headers: Vec::new(),
committed: false,
buffered: false,
}
}
pub fn with_batch(mut self, events: Vec<ProviderEvent>) -> Self {
self.events.push_back(events);
self
}
}
impl ExecutionSession for Session {
fn response_commit(&self) -> ResponseCommit {
self.trace.response_commit.clone()
}
fn next_event(&mut self) -> BoxFuture<'_, Result<Option<CoordinatedEvent>, EngineError>> {
Box::pin(async move {
if let Some(delay) = self.delay.take() {
tokio::time::sleep(delay).await;
}
if let Some(event) = self.events.pop_front() {
let requirement = if self.committed {
CommitRequirement::AlreadyCommitted
} else {
CommitRequirement::CommitBeforeDelivery
};
return CoordinatedEvent::try_batch(event, requirement).map(Some);
}
match self.finish {
Finish::Success => {
self.trace.finalized.store(true, Ordering::SeqCst);
Ok(None)
}
Finish::Error => {
self.trace.finalized.store(true, Ordering::SeqCst);
Err(EngineError::ProviderMetadataMismatch)
}
Finish::Pending => futures::future::pending().await,
}
})
}
fn collect_uncommitted(&mut self) -> BoxFuture<'_, Result<Vec<ProviderEvent>, EngineError>> {
self.buffered = true;
Box::pin(async move { Ok(self.events.drain(..).flatten().collect()) })
}
fn response_headers(&self) -> &[ProviderResponseHeader] {
&self.response_headers
}
fn discard_pending_delivery(&mut self) -> Result<(), EngineError> {
self.trace.discarded.fetch_add(1, Ordering::SeqCst);
Ok(())
}
fn commit_downstream(&mut self, status: Option<u16>) -> BoxFuture<'_, Result<(), EngineError>> {
Box::pin(async move {
self.trace.commits.fetch_add(1, Ordering::SeqCst);
if self.fail_commit {
return Err(EngineError::ProviderMetadataMismatch);
}
self.trace.response_commit.record(status);
self.committed = true;
if self.buffered {
self.trace.finalized.store(true, Ordering::SeqCst);
}
Ok(())
})
}
fn record_client_status(&mut self, status: u16) -> BoxFuture<'_, Result<(), EngineError>> {
Box::pin(async move {
self.trace.response_commit.record(Some(status));
Ok(())
})
}
fn is_finalized(&self) -> bool {
self.trace.finalized.load(Ordering::SeqCst)
}
fn cancel(&self) {
self.trace.cancelled.store(true, Ordering::SeqCst);
}
fn detach_finalize(self: Box<Self>) -> BoxFuture<'static, ()> {
Box::pin(async move {
self.trace.detached.fetch_add(1, Ordering::SeqCst);
self.trace.finalized.store(true, Ordering::SeqCst);
})
}
}
@@ -174,3 +174,5 @@ impl gateway_core::diagnostics::OperationalDiagnostics for RecordingDiagnostics
Ok(())
}
}
pub(crate) mod generation;
+1
View File
@@ -23,6 +23,7 @@ futures = "0.3.32"
http = "1.5.0"
http-body-util = "0.1.5"
futures-timer = "3.0.3"
gateway-protocol = { path = "../gateway-protocol" }
serde = { version = "1.0.228", features = ["derive", "rc"] }
serde_json = { version = "1.0.150", features = ["arbitrary_precision", "preserve_order"] }
sha2 = "0.11.0"
@@ -174,17 +174,17 @@ impl MiddlewareRequest {
declaration: Option<MiddlewareCapabilityDeclaration>,
) -> Result<Self, MiddlewareError> {
if let Some(declaration) = declaration {
if self.protocol != "openai"
|| protocol != "openai"
|| self.original_protocol != "openai"
if !matches!(protocol.as_str(), "openai" | "anthropic")
|| self.protocol != protocol
|| self.original_protocol != protocol
|| declaration.handled.contains(&Feature::NativeContinuation)
|| !declaration.handled.is_disjoint(&declaration.required)
|| (declaration.handled.is_empty() && declaration.required.is_empty())
{
return Err(MiddlewareError::InvalidState);
}
let before = generate_requirements(&self.body)?;
let after = generate_requirements(&body)?;
let before = generate_requirements(&self.protocol, &self.body)?;
let after = generate_requirements(&protocol, &body)?;
if !declaration.handled.is_subset(before.features())
|| !declaration.handled.is_disjoint(after.features())
{
@@ -205,10 +205,12 @@ impl MiddlewareRequest {
let Some(declaration) = &self.capabilities else {
return Ok(operation);
};
if operation.kind() != OperationKind::Generate || operation.protocol() != "openai" {
if operation.kind() != OperationKind::Generate
|| operation.protocol() != self.original_protocol
{
return Err(MiddlewareError::InvalidState);
}
let original = generate_requirements(&self.original_body)?;
let original = generate_requirements(&self.original_protocol, &self.original_body)?;
let mut effective = CapabilityRequirements::new(OperationKind::Generate);
for feature in original
.features()
@@ -228,10 +230,13 @@ impl MiddlewareRequest {
}
}
fn generate_requirements(body: &[u8]) -> Result<CapabilityRequirements, MiddlewareError> {
fn generate_requirements(
protocol: &str,
body: &[u8],
) -> Result<CapabilityRequirements, MiddlewareError> {
let body = serde_json::from_slice(body).map_err(|_| MiddlewareError::InvalidState)?;
let payload =
ProtocolPayload::json_object("openai", body).map_err(|_| MiddlewareError::InvalidState)?;
ProtocolPayload::json_object(protocol, body).map_err(|_| MiddlewareError::InvalidState)?;
Ok(
Operation::Generate(GenerateRequest::from_protocol_payload(payload))
.capability_requirements(),
+37 -69
View File
@@ -10,6 +10,7 @@ use std::fmt;
use std::sync::Arc;
use bytes::Bytes;
use gateway_protocol::request::{RequestFacts, request_facts};
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
@@ -420,6 +421,7 @@ pub struct GenerateRequest {
#[derive(Clone, PartialEq)]
struct GeneratePayload {
source_image_generation: bool,
wire_facts: RequestFacts,
protocol_payload: ProtocolPayload,
client_turn: Option<ClientTurn>,
provider_session_state: Option<ProviderSessionState>,
@@ -463,6 +465,7 @@ impl GenerateRequest {
Self {
payload: Arc::new(GeneratePayload {
source_image_generation: false,
wire_facts: request_facts(protocol_payload.protocol(), protocol_payload.body()),
protocol_payload,
client_turn: None,
provider_session_state: None,
@@ -497,10 +500,7 @@ impl GenerateRequest {
/// 返回最大输出 token 数
#[must_use]
pub fn max_output_tokens(&self) -> Option<u64> {
self.body()
.get("max_output_tokens")
.and_then(Value::as_u64)
.filter(|tokens| *tokens > 0)
self.payload.wire_facts.max_output_tokens
}
/// 返回客户端提供的 prompt cache 路由键
@@ -515,10 +515,7 @@ impl GenerateRequest {
/// 返回原始请求是否要求 Provider 原生 continuation
#[must_use]
pub fn native_continuation_requested(&self) -> bool {
self.body()
.get("previous_response_id")
.and_then(Value::as_str)
.is_some()
self.payload.wire_facts.native_continuation
}
/// 返回客户端是否请求了图片生成工具
@@ -548,44 +545,33 @@ impl GenerateRequest {
if let Some(requirements) = &self.payload.source_requirements {
return requirements.clone();
}
let mut requirements = CapabilityRequirements::new(OperationKind::Generate)
.with_requested_output_tokens(self.max_output_tokens());
let mut requirements = self.wire_capability_requirements();
if let Some(inherited) = &self.payload.inherited_capability_requirements {
for feature in inherited.features() {
requirements = requirements.require(*feature);
}
}
if self
.body()
.get("tools")
.and_then(Value::as_array)
.is_some_and(|tools| !tools.is_empty())
{
requirements = requirements.require(Feature::Tools);
}
if contains_type(self.body().get("input"), "input_image") {
requirements = requirements.require(Feature::Vision);
}
if self.body().get("reasoning").is_some_and(Value::is_object) {
requirements = requirements.require(Feature::Reasoning);
}
if self
.body()
.get("text")
.and_then(Value::as_object)
.and_then(|text| text.get("format"))
.and_then(Value::as_object)
.and_then(|format| format.get("type"))
.and_then(Value::as_str)
== Some("json_schema")
{
requirements = requirements.require(Feature::JsonSchema);
}
if self.native_continuation_requested() {
requirements.require(Feature::NativeContinuation)
} else {
requirements
requirements
}
/// 返回当前 wire 的能力要求,不混入转换前或中间件继承的要求
#[must_use]
pub fn wire_capability_requirements(&self) -> CapabilityRequirements {
let facts = self.payload.wire_facts;
let mut requirements = CapabilityRequirements::new(OperationKind::Generate)
.with_requested_output_tokens(facts.max_output_tokens);
for (requested, feature) in [
(facts.tools, Feature::Tools),
(facts.vision, Feature::Vision),
(facts.reasoning, Feature::Reasoning),
(facts.json_schema, Feature::JsonSchema),
(facts.native_continuation, Feature::NativeContinuation),
] {
if requested {
requirements = requirements.require(feature);
}
}
requirements
}
fn body(&self) -> &Map<String, Value> {
@@ -610,21 +596,6 @@ impl fmt::Debug for GenerateRequest {
}
}
fn contains_type(value: Option<&Value>, expected: &str) -> bool {
match value {
Some(Value::Array(values)) => values
.iter()
.any(|value| contains_type(Some(value), expected)),
Some(Value::Object(object)) => {
object.get("type").and_then(Value::as_str) == Some(expected)
|| object
.values()
.any(|value| contains_type(Some(value), expected))
}
_ => false,
}
}
/// 原生工具声明授权上游生成图片,Codex 的被动 namespace 与图片输入不属于该权限
fn requests_image_generation(body: &Map<String, Value>) -> bool {
contains_image_tool(body.get("tools"))
@@ -1056,27 +1027,24 @@ impl Operation {
let translating = target_protocol.is_some();
match self {
Self::Generate(request) => {
let protocol_payload = request.protocol_payload();
let source_requirements = translating.then(|| request.requirements());
let source_image_generation = translating && request.image_generation_requested();
let body = match body {
Some(body) => {
// 修改上下文不改变正文事实;只有新 wire 才需要重新扫描输入
let mut payload = Arc::unwrap_or_clone(request.payload);
if let Some(body) = body {
let body =
serde_json::from_slice::<Map<String, Value>>(&body).map_err(|_| {
OperationError::EmptyField {
field: "protocol_payload body",
}
})?
})?;
if let Some(protocol) = target_protocol {
payload.protocol_payload.protocol = protocol;
}
None => protocol_payload.body().clone(),
};
let replacement = ProtocolPayload {
protocol: target_protocol
.unwrap_or_else(|| protocol_payload.protocol().to_owned()),
body,
context,
};
let mut payload = (*request.payload).clone();
payload.protocol_payload = replacement;
payload.wire_facts = request_facts(payload.protocol_payload.protocol(), &body);
payload.protocol_payload.body = body;
}
payload.protocol_payload.context = context;
// 跨协议转换不能抹去已识别的生图权限要求,也不解释目标私有协议
payload.source_image_generation |= source_image_generation;
if let Some(requirements) = source_requirements {
@@ -181,6 +181,52 @@ fn body_operation(body: &Value) -> Operation {
))
}
#[test]
fn messages_capability_declaration_rechecks_native_body_and_keeps_input_requirements() {
use gateway_core::{engine::middleware::MiddlewareCapabilityDeclaration, operation::Feature};
let original = json!({"max_tokens":0,"messages":[{"role":"user","content":[{"type":"image","source":{"type":"url","url":"https://example.test/image.png"}}]}],"thinking":{"type":"enabled","budget_tokens":1024},"tools":[{"name":"lookup","input_schema":{"type":"object"}}]});
let mut converted = original.clone();
converted.as_object_mut().unwrap().remove("thinking");
let request = MiddlewareRequest::new(
"anthropic",
vec![],
serde_json::to_vec(&original).unwrap().into(),
)
.replace_parts(
"anthropic".into(),
vec![],
serde_json::to_vec(&converted).unwrap().into(),
Some(MiddlewareCapabilityDeclaration {
handled: [Feature::Reasoning].into(),
required: Default::default(),
}),
)
.unwrap();
let operation = request
.apply_capabilities(Operation::Generate(GenerateRequest::from_protocol_payload(
ProtocolPayload::json_object("anthropic", converted.as_object().unwrap().clone())
.unwrap(),
)))
.unwrap();
assert_eq!(
operation.capability_requirements().features(),
&[Feature::Tools, Feature::Vision].into()
);
assert!(
request
.replace_parts(
"openai".into(),
vec![],
Bytes::from_static(b"{}"),
Some(MiddlewareCapabilityDeclaration {
handled: [Feature::Tools].into(),
required: Default::default()
})
)
.is_err()
);
}
#[test]
fn capability_declaration_preserves_original_semantics_and_recomputes_upstream_needs() {
use gateway_core::{engine::middleware::MiddlewareCapabilityDeclaration, operation::Feature};
@@ -514,6 +514,9 @@ Chat 的下游流模式及 `include_usage` 由 API 持有,request 阶段不能
同一边界的原样保留不要求 Chat 与 Responses 字节相同;需要读写 `messages` 或 `choices` 的插件应使用 HTTP 挂载,
字段范围见 [Chat 合同](../../../../../docs/api.md#chat-completions-请求)
Messages 入站的 `protocol` 为 `anthropic`,端点为 `/v1/messages`;计数使用 `/v1/messages/count_tokens` 与 `count_tokens` 操作
同协议请求保留原生正文,Responses 与 Messages 之间的转换发生在所选上游的执行边界
中间件可读取和改写完整请求、响应 headers、正文与响应帧,也不按字段名称过滤认证、Cookie、会话或连接头。
该能力遵循[完整信任](manifest.md#完整信任)边界;类型、HTTP 格式、大小及资源生命周期仍需符合合同
@@ -535,7 +538,8 @@ Header 修改采用增量 remove/append,保留合法多值。`MiddlewareBody::
这一保证比较插件前后的同一边界,Provider 自身的协议适配、两次调用的随机值和网络分段不在比较范围内
`request.declare_capabilities(CapabilityDeclaration { handled, required })` 随单次 `next` 发出,必须同时显式替换正文。
当前仅允许 OpenAI 生成请求的 request 阶段,HTTP 与 WebSocket 共用规则;不扩展端点允许的协议或流模式。
当前仅允许 Responses 或 Messages 生成请求的 request 阶段,HTTP 与 WebSocket 共用规则;不扩展端点允许的协议或流模式。
Responses 与 Messages 的功能声明均按各自协议正文重新提取事实,声明不能改变请求协议
`handled` 只允许列举改写前确实存在、改写后已从实际请求移除的 `tools`、`vision`、`reasoning`、`json_schema`,
插件须负责对应的提示词转换及普通响应、错误、流式响应还原。`required` 为额外上游需求,不能覆盖正文推导出的要求。
重复项、同一项同时出现在两组、空声明、attempt 阶段使用声明均会拒绝。
@@ -0,0 +1,54 @@
//! 所选 Messages 模型的明确能力与限制,不根据模型名称推断
use serde_json::Value;
/// 转换器消费的模型目录事实;None 表示上游未声明
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct MessagesModelCapabilities {
pub thinking: Option<bool>,
pub adaptive_thinking: Option<bool>,
pub manual_thinking: Option<bool>,
pub disabled_thinking: Option<bool>,
pub efforts: Option<Vec<String>>,
pub max_tokens: Option<u64>,
}
impl MessagesModelCapabilities {
/// 从 Anthropic Models 条目提取转换所需事实,未知扩展不影响解析
pub fn from_model(model: &Value) -> Self {
Self {
thinking: model
.pointer("/capabilities/thinking/supported")
.and_then(Value::as_bool),
adaptive_thinking: model
.pointer("/capabilities/thinking/types/adaptive/supported")
.and_then(Value::as_bool),
manual_thinking: model
.pointer("/capabilities/thinking/types/enabled/supported")
.and_then(Value::as_bool),
disabled_thinking: model
.pointer("/capabilities/thinking/types/disabled/supported")
.and_then(Value::as_bool),
efforts: model
.pointer("/capabilities/effort")
.and_then(Value::as_object)
.map(|efforts| {
["low", "medium", "high", "xhigh", "max"]
.into_iter()
.filter(|level| {
efforts
.get(*level)
.and_then(|v| v.get("supported"))
.and_then(Value::as_bool)
== Some(true)
})
.map(str::to_owned)
.collect()
}),
max_tokens: model
.get("max_tokens")
.and_then(Value::as_u64)
.filter(|v| *v > 0),
}
}
}
@@ -0,0 +1,172 @@
//! 文本、多模态内容和不透明回传载荷的协议表示
use serde_json::{Value, json};
const ANTHROPIC_CARRIER: &str = "cpr:anthropic:v1:";
const OPENAI_CARRIER: &str = "cpr:openai:v1:";
const REDACTED_CARRIER: &str = "claude-redacted-thinking:";
pub(super) fn text(value: &Value) -> String {
match value {
Value::String(value) => value.clone(),
Value::Array(parts) => parts
.iter()
.filter_map(|part| {
part.get("text")
.or_else(|| part.get("thinking"))
.and_then(Value::as_str)
})
.collect::<Vec<_>>()
.join("\n"),
_ => String::new(),
}
}
pub(super) fn blocks(value: Option<&Value>) -> Vec<Value> {
match value {
Some(Value::String(text)) => vec![json!({"type":"text","text":text})],
Some(Value::Array(parts)) => parts.clone(),
_ => Vec::new(),
}
}
pub(super) fn to_responses_content(block: &Value, assistant: bool) -> Option<Value> {
match block.get("type").and_then(Value::as_str)? {
"text" => Some(
json!({"type": if assistant {"output_text"} else {"input_text"}, "text":block.get("text").and_then(Value::as_str).unwrap_or_default()}),
),
"image" => {
let source = block.get("source")?;
let url = source_url(source)?;
Some(json!({"type":"input_image","image_url":url}))
}
"document" => {
let source = block.get("source")?;
match source.get("type").and_then(Value::as_str)? {
"text" => Some(
json!({"type":"input_text","text":source.get("data").and_then(Value::as_str).unwrap_or_default()}),
),
"file" => Some(json!({"type":"input_file","file_id":source.get("file_id")?})),
"url" => Some(json!({"type":"input_file","file_url":source.get("url")?})),
"base64" => Some(
json!({"type":"input_file","filename":block.get("title").and_then(Value::as_str).unwrap_or("document.pdf"),"file_data":source_url(source)?}),
),
_ => None,
}
}
"search_result" => Some(
json!({"type":"input_text","text":text(block.get("content").unwrap_or(&Value::Null))}),
),
_ => None,
}
}
pub(super) fn to_messages_content(part: &Value) -> Option<Value> {
match part.get("type").and_then(Value::as_str)? {
"input_text" | "output_text" | "text" => Some(
json!({"type":"text","text":part.get("text").and_then(Value::as_str).unwrap_or_default()}),
),
"refusal" => Some(
json!({"type":"text","text":part.get("refusal").and_then(Value::as_str).unwrap_or_default()}),
),
"input_image" => {
let url = part
.get("image_url")
.and_then(|v| v.as_str().or_else(|| v.get("url").and_then(Value::as_str)))?;
Some(json!({"type":"image","source":url_source(url)}))
}
"input_file" => {
let source = if let Some(data) = part.get("file_data").and_then(Value::as_str) {
url_source(data)
} else if let Some(url) = part.get("file_url").and_then(Value::as_str) {
json!({"type":"url","url":url})
} else {
json!({"type":"file","file_id":part.get("file_id")?})
};
Some(json!({"type":"document","source":source}))
}
_ => None,
}
}
pub(super) fn source_url(source: &Value) -> Option<String> {
match source.get("type").and_then(Value::as_str)? {
"url" => source.get("url").and_then(Value::as_str).map(str::to_owned),
"base64" => Some(format!(
"data:{};base64,{}",
source.get("media_type").and_then(Value::as_str)?,
source.get("data").and_then(Value::as_str)?
)),
_ => None,
}
}
fn url_source(url: &str) -> Value {
if let Some(data) = url.strip_prefix("data:")
&& let Some((media_type, data)) = data.split_once(";base64,")
{
return json!({"type":"base64","media_type":media_type,"data":data});
}
json!({"type":"url","url":url})
}
pub(super) fn reasoning_text(item: &Value) -> String {
let summary = text(item.get("summary").unwrap_or(&Value::Null));
if summary.is_empty() {
text(item.get("content").unwrap_or(&Value::Null))
} else {
summary
}
}
pub(super) fn anthropic_carrier(block: &Value) -> String {
format!("{ANTHROPIC_CARRIER}{block}")
}
pub(super) fn openai_carrier(item: &Value) -> String {
format!("{OPENAI_CARRIER}{item}")
}
pub(super) fn is_openai_carrier(block: &Value) -> bool {
block.get("type").and_then(Value::as_str) == Some("thinking")
&& block
.get("signature")
.and_then(Value::as_str)
.is_some_and(|signature| signature.starts_with(OPENAI_CARRIER))
}
pub(super) fn is_anthropic_carrier(item: &Value) -> bool {
item.get("type").and_then(Value::as_str) == Some("reasoning")
&& item
.get("encrypted_content")
.and_then(Value::as_str)
.is_some_and(|carrier| carrier.starts_with(ANTHROPIC_CARRIER))
}
pub(super) fn restore_anthropic(item: &Value) -> Option<Value> {
let carrier = item.get("encrypted_content")?.as_str()?;
if let Some(raw) = carrier.strip_prefix(ANTHROPIC_CARRIER) {
return serde_json::from_str(raw).ok();
}
if let Some(data) = carrier.strip_prefix(REDACTED_CARRIER) {
return Some(json!({"type":"redacted_thinking","data":data}));
}
// CPA 识别来源后回放签名,CPR 自己发出的载荷携带完整块以保留精确回传内容
if carrier.starts_with("claude#") || carrier.starts_with("anthropic#") {
return Some(
json!({"type":"thinking","thinking":reasoning_text(item),"signature":carrier.split_once('#')?.1}),
);
}
None
}
pub(super) fn restore_openai(block: &Value) -> Option<Value> {
let signature = block.get("signature")?.as_str()?;
if let Some(raw) = signature.strip_prefix(OPENAI_CARRIER) {
return serde_json::from_str(raw).ok();
}
if signature.starts_with("gAAAA") {
return Some(json!({"type":"reasoning","summary":[],"encrypted_content":signature}));
}
None
}
@@ -0,0 +1,17 @@
//! 协议转换的结构错误
use thiserror::Error;
/// 可安全传递给协议边界的转换错误
#[derive(Debug, Error, Clone, PartialEq, Eq)]
pub enum TranslationError {
/// 请求结构无法解析
#[error("{0}")]
InvalidRequest(&'static str),
/// 上游事件与已建立的流状态冲突
#[error("{0}")]
InvalidEvent(&'static str),
/// 流在完整终态之前结束
#[error("The upstream stream ended before its terminal event.")]
IncompleteStream,
}
@@ -0,0 +1,30 @@
//! Messages 编解码、用量事实和 Responses 双向转换
mod capabilities;
mod content;
mod error;
mod request;
mod response;
mod stream;
mod thinking;
mod tools;
mod usage;
pub use capabilities::MessagesModelCapabilities;
pub use error::TranslationError;
pub use request::{
messages_to_responses_count_request, messages_to_responses_request,
responses_to_messages_request, strip_foreign_reasoning_for_responses,
strip_foreign_thinking_for_messages, validate_count_request, validate_request,
};
pub use response::{
messages_to_responses_event, messages_to_responses_response, responses_to_messages_response,
};
pub use stream::{
MessagesAccumulator, MessagesToResponsesStream, ResponsesToMessagesStream,
message_to_stream_events,
};
pub use usage::MessageUsage;
/// Messages 载荷的协议标识
pub const ANTHROPIC_PROTOCOL: &str = "anthropic";
@@ -0,0 +1,555 @@
//! Messages 与 Responses 请求的无状态转换
use std::collections::BTreeSet;
use serde_json::{Map, Value, json};
use super::{
MessagesModelCapabilities, TranslationError, content, thinking,
tools::{ToolSet, messages_tools},
};
/// 原生 Messages 上游不能消费本网关封装的 OpenAI 思考,仅删除已知外来源载荷
pub fn strip_foreign_thinking_for_messages(request: &mut Map<String, Value>) {
let Some(messages) = request.get_mut("messages").and_then(Value::as_array_mut) else {
return;
};
messages.retain_mut(|message| {
let Some(blocks) = message.get_mut("content").and_then(Value::as_array_mut) else {
return true;
};
let previous_len = blocks.len();
blocks.retain(|block| !content::is_openai_carrier(block));
blocks.len() == previous_len || !blocks.is_empty()
});
}
/// 原生 Responses 上游不能消费本网关封装的 Anthropic 思考
pub fn strip_foreign_reasoning_for_responses(request: &mut Map<String, Value>) {
if let Some(input) = request.get_mut("input").and_then(Value::as_array_mut) {
input.retain(|item| !content::is_anthropic_carrier(item));
}
}
/// 校验 Messages 生成请求的必需字段
pub fn validate_request(request: &Map<String, Value>) -> Result<(), TranslationError> {
validate_count_request(request)?;
if request.get("max_tokens").and_then(Value::as_u64).is_none() {
return Err(TranslationError::InvalidRequest(
"The max_tokens field must be a non-negative integer.",
));
}
Ok(())
}
/// 计数请求没有生成预算要求
pub fn validate_count_request(request: &Map<String, Value>) -> Result<(), TranslationError> {
if !request
.get("model")
.and_then(Value::as_str)
.is_some_and(|v| !v.trim().is_empty())
{
return Err(TranslationError::InvalidRequest(
"The model field must be a non-empty string.",
));
}
let messages = request.get("messages").and_then(Value::as_array).ok_or(
TranslationError::InvalidRequest("The messages field must be an array."),
)?;
if messages.is_empty() {
return Err(TranslationError::InvalidRequest(
"The messages field must not be empty.",
));
}
for message in messages {
if !message
.get("role")
.and_then(Value::as_str)
.is_some_and(|v| matches!(v, "user" | "assistant" | "system"))
{
return Err(TranslationError::InvalidRequest(
"Each message role must be user, assistant, or system.",
));
}
if message
.get("content")
.and_then(Value::as_array)
.is_some_and(|blocks| {
blocks
.iter()
.any(|block| block.get("type").and_then(Value::as_str).is_none())
})
{
return Err(TranslationError::InvalidRequest(
"Each content block must contain a type string.",
));
}
if !message
.get("content")
.is_some_and(|v| v.is_string() || v.is_array())
{
return Err(TranslationError::InvalidRequest(
"Each message content must be a string or an array.",
));
}
}
if request.get("stream").is_some_and(|v| !v.is_boolean()) {
return Err(TranslationError::InvalidRequest(
"The stream field must be a boolean.",
));
}
if request.get("tools").is_some_and(|v| !v.is_array()) {
return Err(TranslationError::InvalidRequest(
"The tools field must be an array.",
));
}
Ok(())
}
/// Messages 请求转换为 Responses,外来 thinking 仅通过明确来源载荷恢复
pub fn messages_to_responses_request(
request: &Map<String, Value>,
) -> Result<Map<String, Value>, TranslationError> {
validate_request(request)?;
if request
.get("tools")
.and_then(Value::as_array)
.is_some_and(|tools| {
tools.iter().any(|tool| {
tool["type"]
.as_str()
.is_some_and(|kind| kind.starts_with("web_search_"))
&& !tool["max_uses"].is_null()
})
})
{
return Err(TranslationError::InvalidRequest(
"The Responses upstream cannot enforce the web search usage limit.",
));
}
messages_to_responses_body(request)
}
/// 计数请求复用内容转换,不引入生成预算
pub fn messages_to_responses_count_request(
request: &Map<String, Value>,
) -> Result<Map<String, Value>, TranslationError> {
validate_count_request(request)?;
messages_to_responses_body(request)
}
fn messages_to_responses_body(
request: &Map<String, Value>,
) -> Result<Map<String, Value>, TranslationError> {
let mut result = Map::new();
copy_fields(
request,
&mut result,
&["model", "stream", "temperature", "top_p"],
);
// speed 与服务档位不是同一概念,按 CPA 映射显式 fast,其余使用目标协议的档位
if request.get("speed").and_then(Value::as_str) == Some("fast") {
result.insert("service_tier".into(), json!("priority"));
} else if let Some(tier) = request.get("service_tier").and_then(Value::as_str) {
match tier {
"auto" => {
result.insert("service_tier".into(), json!("auto"));
}
"standard_only" => {
result.insert("service_tier".into(), json!("default"));
}
_ => {}
}
}
if let Some(max_tokens) = request.get("max_tokens") {
result.insert("max_output_tokens".into(), max_tokens.clone());
}
let mut input = Vec::new();
let system = content::blocks(request.get("system"))
.iter()
.filter_map(|block| content::to_responses_content(block, false))
.collect::<Vec<_>>();
if !system.is_empty() {
input.push(json!({"type":"message","role":"developer","content":system}));
}
for message in request
.get("messages")
.and_then(Value::as_array)
.into_iter()
.flatten()
{
let role = message
.get("role")
.and_then(Value::as_str)
.unwrap_or("user");
let mut parts = Vec::new();
for block in content::blocks(message.get("content")) {
match block
.get("type")
.and_then(Value::as_str)
.unwrap_or_default()
{
"tool_use" => {
flush_responses(&mut input, role, &mut parts);
input.push(json!({"type":"function_call","call_id":block.get("id"),"name":block.get("name"),"arguments":block.get("input").cloned().unwrap_or_else(||json!({})).to_string()}));
}
"tool_result" => {
flush_responses(&mut input, role, &mut parts);
let output = tool_output_to_responses(block.get("content"));
input.push(json!({"type":"function_call_output","call_id":block.get("tool_use_id"),"output":output}));
}
"thinking" | "redacted_thinking" => {
flush_responses(&mut input, role, &mut parts);
if let Some(item) = content::restore_openai(&block) {
input.push(item);
}
}
_ => {
if let Some(part) = content::to_responses_content(&block, role == "assistant") {
parts.push(part);
}
}
}
}
flush_responses(&mut input, role, &mut parts);
}
result.insert("input".into(), Value::Array(input));
if let Some(tools) = request.get("tools").and_then(Value::as_array) {
result.insert("tools".into(), Value::Array(messages_tools(tools)));
}
if let Some(choice) = request.get("tool_choice") {
let choice = match choice.get("type").and_then(Value::as_str).unwrap_or("auto") {
"any" => json!("required"),
"none" => json!("none"),
"tool" => json!({"type":"function","name":choice.get("name")}),
_ => json!("auto"),
};
result.insert("tool_choice".into(), choice);
}
if let Some(disabled) = request
.get("tool_choice")
.and_then(|v| v.get("disable_parallel_tool_use"))
.and_then(Value::as_bool)
{
result.insert("parallel_tool_calls".into(), json!(!disabled));
}
result.insert("reasoning".into(), thinking::to_responses(request));
result.insert("include".into(), json!(["reasoning.encrypted_content"]));
if let Some(format) = request.get("output_config").and_then(|v| v.get("format")) {
let mut format = format.clone();
if format.get("type").and_then(Value::as_str) == Some("json_schema") {
format["name"] = json!("response");
}
result.insert("text".into(), json!({"format":format}));
}
Ok(result)
}
/// Responses 请求转换为 Messages,工具结果采用 CPA 的配对与孤立结果降级规则
pub fn responses_to_messages_request(
request: &Map<String, Value>,
capabilities: &MessagesModelCapabilities,
) -> Result<Map<String, Value>, TranslationError> {
let tools = ToolSet::from_responses(request);
let mut result = Map::new();
copy_fields(
request,
&mut result,
&["model", "stream", "temperature", "top_p"],
);
let requested_maximum =
match request.get("max_output_tokens") {
None | Some(Value::Null) => 32000,
Some(value) => value.as_u64().filter(|value| *value > 0).ok_or(
TranslationError::InvalidRequest(
"The max_output_tokens field must be a positive integer.",
),
)?,
};
let maximum = capabilities
.max_tokens
.map_or(requested_maximum, |limit| requested_maximum.min(limit));
result.insert("max_tokens".into(), json!(maximum));
match request.get("service_tier").and_then(Value::as_str) {
Some("priority") => {
result.insert("speed".into(), json!("fast"));
}
Some("default") => {
result.insert("service_tier".into(), json!("standard_only"));
}
Some("auto") => {
result.insert("service_tier".into(), json!("auto"));
}
_ => {}
}
let mut system = Vec::new();
if let Some(instructions) = request.get("instructions").and_then(Value::as_str)
&& !instructions.is_empty()
{
system.push(json!({"type":"text","text":instructions}));
}
let mut messages = Vec::new();
let inputs = match request.get("input") {
Some(Value::String(input)) => {
append_message(
&mut messages,
"user",
vec![json!({"type":"text","text":input})],
);
&[][..]
}
Some(Value::Array(input)) => input.as_slice(),
Some(Value::Null) | None => &[],
_ => {
return Err(TranslationError::InvalidRequest(
"The input field must be a string or an array.",
));
}
};
for (position, item) in inputs.iter().enumerate() {
match item
.get("type")
.and_then(Value::as_str)
.unwrap_or("message")
{
"function_call" | "custom_tool_call" => {
let custom = item.get("type").and_then(Value::as_str) == Some("custom_tool_call");
let input = if custom {
json!({"input":item.get("input").and_then(Value::as_str).unwrap_or_default()})
} else {
item.get("arguments")
.and_then(Value::as_str)
.and_then(|v| serde_json::from_str::<Value>(v).ok())
.filter(Value::is_object)
.unwrap_or_else(|| json!({}))
};
let name = item.get("name").and_then(Value::as_str).unwrap_or_default();
let wire_name =
tools.wire_name(name, item.get("namespace").and_then(Value::as_str));
append_message(
&mut messages,
"assistant",
vec![
json!({"type":"tool_use","id":item.get("call_id").cloned().unwrap_or_else(||json!(format!("call_{position}"))),"name":wire_name,"input":input}),
],
);
}
"function_call_output" | "custom_tool_call_output" => {
let call_id = item
.get("call_id")
.and_then(Value::as_str)
.unwrap_or_default();
let output = item.get("output").unwrap_or(&Value::Null);
let mut block = json!({"type":"tool_result","tool_use_id":call_id,"content":tool_output_to_messages(output)});
if item.get("status").and_then(Value::as_str) == Some("incomplete") {
block["is_error"] = json!(true);
}
append_message(&mut messages, "user", vec![block]);
}
"reasoning" => {
if let Some(block) = content::restore_anthropic(item) {
append_message(&mut messages, "assistant", vec![block]);
}
}
"message" => {
let role = item.get("role").and_then(Value::as_str).unwrap_or("user");
let parts = match item.get("content") {
Some(Value::String(text)) => vec![json!({"type":"text","text":text})],
Some(Value::Array(parts)) => parts
.iter()
.filter_map(content::to_messages_content)
.collect(),
_ => Vec::new(),
};
if matches!(role, "system" | "developer") {
system.extend(parts);
} else {
append_message(&mut messages, role, parts);
}
}
_ => {}
}
}
if !system.is_empty() {
result.insert("system".into(), Value::Array(system));
}
result.insert(
"messages".into(),
Value::Array(normalize_tool_pairing(messages)),
);
tools.write_messages_tools(request, &mut result)?;
thinking::apply_to_messages(request, &mut result, capabilities, maximum);
if request
.get("tool_choice")
.is_some_and(|c| c["type"] == "allowed_tools" && c["mode"] == "required")
&& result["tool_choice"]["type"] != "any"
{
return Err(TranslationError::InvalidRequest(
"The Messages upstream cannot require an allowed tool with this thinking mode.",
));
}
if matches!(
result
.get("thinking")
.and_then(|value| value.get("type"))
.and_then(Value::as_str),
Some("enabled" | "adaptive")
) {
// CPA 在生成推理配置后移除不相容的采样参数;原生 Messages 不经过此转换
result.shift_remove("temperature");
result.shift_remove("top_p");
}
if let Some(format) = request.get("text").and_then(|v| v.get("format"))
&& format.get("type").and_then(Value::as_str) == Some("json_schema")
{
let config = result.entry("output_config").or_insert_with(|| json!({}));
config["format"] = json!({"type":"json_schema","schema":format.get("schema").cloned().unwrap_or_else(||json!({}))});
}
Ok(result)
}
fn copy_fields(source: &Map<String, Value>, target: &mut Map<String, Value>, fields: &[&str]) {
for field in fields {
if let Some(value) = source.get(*field) {
target.insert((*field).into(), value.clone());
}
}
}
fn flush_responses(input: &mut Vec<Value>, role: &str, parts: &mut Vec<Value>) {
if !parts.is_empty() {
input.push(json!({"type":"message","role":role,"content":std::mem::take(parts)}));
}
}
fn append_message(messages: &mut Vec<Value>, role: &str, parts: Vec<Value>) {
if parts.is_empty() {
return;
}
if let Some(last) = messages.last_mut()
&& last.get("role").and_then(Value::as_str) == Some(role)
&& let Some(content) = last.get_mut("content").and_then(Value::as_array_mut)
{
content.extend(parts);
return;
}
messages.push(json!({"role":role,"content":parts}));
}
fn tool_output_to_responses(value: Option<&Value>) -> Value {
match value {
Some(Value::String(text)) => json!(text),
Some(Value::Array(blocks)) => Value::Array(
blocks
.iter()
.filter_map(|block| content::to_responses_content(block, false))
.collect(),
),
Some(value) => json!(value.to_string()),
None => json!(""),
}
}
fn tool_output_to_messages(value: &Value) -> Value {
match value {
Value::String(text) => json!(text),
Value::Array(parts) => Value::Array(
parts
.iter()
.filter_map(content::to_messages_content)
.collect(),
),
_ => json!(value.to_string()),
}
}
// Messages 要求每次工具调用在紧邻用户轮次闭合,不能用历史中的任意同 ID 调用配对
fn normalize_tool_pairing(messages: Vec<Value>) -> Vec<Value> {
let mut normalized = Vec::with_capacity(messages.len());
let mut pending = Vec::<String>::new();
for mut message in messages {
if message["role"] == "user" {
if let Some(blocks) = message.get_mut("content").and_then(Value::as_array_mut) {
normalize_tool_results(blocks, &pending);
}
pending.clear();
} else {
if !pending.is_empty() {
normalized.push(interrupted_tools_message(&pending));
}
pending = message
.get("content")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter(|block| message["role"] == "assistant" && block["type"] == "tool_use")
.filter_map(|block| block.get("id").and_then(Value::as_str))
.filter(|id| !id.is_empty())
.map(str::to_owned)
.collect();
}
normalized.push(message);
}
if !pending.is_empty() {
normalized.push(interrupted_tools_message(&pending));
}
normalized
}
fn normalize_tool_results(blocks: &mut Vec<Value>, pending: &[String]) {
// 只在本轮保留同 ID 的最后一个结果;延迟结果不能抹掉更早轮次已经闭合的调用
let mut seen = BTreeSet::new();
blocks.reverse();
blocks.retain(|block| tool_result_id(block).is_none_or(|id| seen.insert(id.to_owned())));
blocks.reverse();
let mut unanswered = pending.iter().map(String::as_str).collect::<BTreeSet<_>>();
let mut results = Vec::new();
let mut ordinary = Vec::new();
for mut block in std::mem::take(blocks) {
match tool_result_id(&block) {
Some(id) if unanswered.remove(id) => results.push(block),
Some(_) => {
let content = block.get_mut("content").map(Value::take);
let parts = content::blocks(content.as_ref())
.into_iter()
.filter(|part| {
part["type"] != "text"
|| part
.get("text")
.and_then(Value::as_str)
.is_some_and(|text| !text.trim().is_empty())
})
.collect::<Vec<_>>();
if parts.is_empty() {
ordinary.push(json!({"type":"text","text":"Tool result was empty."}));
} else {
ordinary.extend(parts);
}
}
None => ordinary.push(block),
}
}
blocks.extend(
pending
.iter()
.filter(|id| unanswered.contains(id.as_str()))
.map(|id| interrupted_tool_result(id)),
);
blocks.extend(results);
blocks.extend(ordinary);
}
fn tool_result_id(block: &Value) -> Option<&str> {
(block["type"] == "tool_result")
.then(|| block.get("tool_use_id").and_then(Value::as_str))
.flatten()
}
fn interrupted_tool_result(id: &str) -> Value {
json!({"type":"tool_result","tool_use_id":id,"is_error":true,"content":"Tool call was interrupted before any output was recorded."})
}
fn interrupted_tools_message(pending: &[String]) -> Value {
json!({"role":"user","content":pending.iter().map(|id| interrupted_tool_result(id)).collect::<Vec<_>>()})
}
@@ -0,0 +1,228 @@
//! Messages 与 Responses 完整响应的映射
use serde_json::{Map, Value, json};
use super::{MessageUsage, TranslationError, content, tools::ToolSet, usage};
/// 将完整 Messages JSON 转换为单个 Responses 终态事件
pub fn messages_to_responses_event(
message: &Value,
original_request: &Map<String, Value>,
) -> Result<Value, TranslationError> {
messages_to_responses_response(message, original_request).map(terminal_response_event)
}
pub(super) fn terminal_response_event(response: Value) -> Value {
let event_type = match response.get("status").and_then(Value::as_str) {
Some("incomplete") => "response.incomplete",
Some("failed") => "response.failed",
_ => "response.completed",
};
json!({"type":event_type,"response":response})
}
/// Messages 完整响应转为 Responses,原始请求用于 custom 工具与模型身份恢复
pub fn messages_to_responses_response(
message: &Value,
original_request: &Map<String, Value>,
) -> Result<Value, TranslationError> {
complete_response(
message,
original_request.get("model"),
&ToolSet::identities(original_request),
)
}
pub(super) fn complete_response(
message: &Value,
model: Option<&Value>,
tools: &ToolSet,
) -> Result<Value, TranslationError> {
if message.get("type").and_then(Value::as_str) == Some("error") {
return Ok(response_from_message(message, model, Vec::new()));
}
let blocks =
message
.get("content")
.and_then(Value::as_array)
.ok_or(TranslationError::InvalidEvent(
"The Messages response content must be an array.",
))?;
let id = message
.get("id")
.and_then(Value::as_str)
.unwrap_or("resp_messages");
let output = blocks
.iter()
.enumerate()
.filter_map(|(index, block)| {
messages_block_to_response(block, tools, &format!("{id}_{index}"))
})
.collect::<Vec<_>>();
Ok(response_from_message(message, model, output))
}
pub(super) fn response_from_message(
message: &Value,
model: Option<&Value>,
output: Vec<Value>,
) -> Value {
if message.get("type").and_then(Value::as_str) == Some("error") {
return json!({"object":"response","status":"failed","error":messages_error_to_responses(message.get("error").unwrap_or(&Value::Null)),"output":[]});
}
let id = message
.get("id")
.and_then(Value::as_str)
.unwrap_or("resp_messages");
let reason = message
.get("stop_reason")
.and_then(Value::as_str)
.unwrap_or_default();
let incomplete = match reason {
"max_tokens" | "model_context_window_exceeded" => Some("max_output_tokens"),
"refusal" => Some("content_filter"),
_ => None,
};
let mut response = json!({"id":id,"object":"response","created_at":0,"status":if incomplete.is_some(){"incomplete"}else{"completed"},"model":model.or_else(||message.get("model")),"output":output,"error":null,"incomplete_details":incomplete.map(|reason|json!({"reason":reason})),"usage":MessageUsage::from_value(message.get("usage").unwrap_or(&Value::Null)).responses()});
if reason == "pause_turn" {
response["end_turn"] = json!(false);
}
response
}
pub(super) fn messages_block_to_response(
block: &Value,
tools: &ToolSet,
id: &str,
) -> Option<Value> {
match block.get("type").and_then(Value::as_str)? {
"text" => Some(
json!({"id":id,"type":"message","role":"assistant","status":"completed","content":[{"type":"output_text","text":block.get("text").and_then(Value::as_str).unwrap_or_default(),"annotations":block.get("citations").cloned().unwrap_or_else(||json!([]))}]}),
),
"tool_use" => Some(tools.call(block, id)),
"thinking" | "redacted_thinking" => Some(
json!({"id":id,"type":"reasoning","summary":if block.get("type").and_then(Value::as_str)==Some("thinking") {vec![json!({"type":"summary_text","text":block.get("thinking").and_then(Value::as_str).unwrap_or_default()})]}else{vec![]},"encrypted_content":content::anthropic_carrier(block)}),
),
// 服务端工具块作为有来源的不透明项保留,可随续接请求恢复
"server_tool_use"
| "web_search_tool_result"
| "web_fetch_tool_result"
| "code_execution_tool_result"
| "bash_code_execution_tool_result"
| "text_editor_code_execution_tool_result"
| "tool_search_tool_result" => Some(
json!({"id":id,"type":"reasoning","summary":[],"encrypted_content":content::anthropic_carrier(block)}),
),
_ => None,
}
}
/// Responses 完整响应转为 Messages,推理载荷保留其来源供后续轮次回传
pub fn responses_to_messages_response(
response: &Value,
original_request: &Map<String, Value>,
) -> Result<Value, TranslationError> {
complete_message(response, original_request.get("model"))
}
pub(super) fn complete_message(
response: &Value,
model: Option<&Value>,
) -> Result<Value, TranslationError> {
if response.get("error").is_some_and(|v| !v.is_null())
|| response.get("status").and_then(Value::as_str) == Some("failed")
{
return Ok(
json!({"type":"error","error":responses_error_to_messages(response.get("error").unwrap_or(&Value::Null))}),
);
}
let output =
response
.get("output")
.and_then(Value::as_array)
.ok_or(TranslationError::InvalidEvent(
"The Responses output must be an array.",
))?;
let content = output
.iter()
.flat_map(responses_item_to_messages)
.collect::<Vec<_>>();
let has_tool = content
.iter()
.any(|block| block.get("type").and_then(Value::as_str) == Some("tool_use"));
let stop = responses_stop_reason(response, has_tool);
Ok(
json!({"id":response.get("id").and_then(Value::as_str).unwrap_or("msg_responses"),"type":"message","role":"assistant","model":model.or_else(||response.get("model")),"content":content,"stop_reason":stop,"stop_sequence":null,"usage":usage::responses_usage(response.get("usage").unwrap_or(&Value::Null))}),
)
}
pub(super) fn responses_stop_reason(response: &Value, has_tool: bool) -> &'static str {
if response.get("status").and_then(Value::as_str) == Some("incomplete") {
match response
.pointer("/incomplete_details/reason")
.and_then(Value::as_str)
{
Some("content_filter") => "refusal",
_ => "max_tokens",
}
} else if response.get("end_turn").and_then(Value::as_bool) == Some(false) {
"pause_turn"
} else if has_tool {
"tool_use"
} else {
"end_turn"
}
}
pub(super) fn responses_error_to_messages(error: &Value) -> Value {
let source = error
.get("type")
.or_else(|| error.get("code"))
.and_then(Value::as_str)
.unwrap_or_default();
let kind = match source {
"invalid_request_error" | "invalid_prompt" => "invalid_request_error",
"authentication_error" => "authentication_error",
"permission_error" => "permission_error",
"not_found_error" => "not_found_error",
"rate_limit_error" | "rate_limit_exceeded" => "rate_limit_error",
"overloaded_error" => "overloaded_error",
_ => "api_error",
};
json!({"type":kind,"message":error.get("message").and_then(Value::as_str).unwrap_or("The upstream response failed.")})
}
fn messages_error_to_responses(error: &Value) -> Value {
let code = match error
.get("type")
.and_then(Value::as_str)
.unwrap_or_default()
{
"rate_limit_error" => "rate_limit_exceeded",
"invalid_request_error" => "invalid_prompt",
_ => "server_error",
};
json!({"code":code,"message":error.get("message").and_then(Value::as_str).unwrap_or("The upstream response failed.")})
}
pub(super) fn responses_item_to_messages(item: &Value) -> Vec<Value> {
match item.get("type").and_then(Value::as_str).unwrap_or_default() {
"message" => item
.get("content")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(content::to_messages_content)
.collect(),
"function_call" => vec![
json!({"type":"tool_use","id":item.get("call_id").or_else(||item.get("id")),"name":item.get("name"),"input":item.get("arguments").and_then(Value::as_str).and_then(|v|serde_json::from_str::<Value>(v).ok()).filter(Value::is_object).unwrap_or_else(||json!({}))}),
],
"custom_tool_call" => vec![
json!({"type":"tool_use","id":item.get("call_id").or_else(||item.get("id")),"name":item.get("name"),"input":{"input":item.get("input").and_then(Value::as_str).unwrap_or_default()}}),
],
"reasoning" => vec![
json!({"type":"thinking","thinking":content::reasoning_text(item),"signature":content::openai_carrier(item)}),
],
_ => Vec::new(),
}
}
@@ -0,0 +1,254 @@
//! Messages SSE 的完整响应聚合与终态校验
use std::collections::BTreeMap;
use serde_json::{Value, json};
use super::super::TranslationError;
#[derive(Debug)]
pub(super) struct Block {
pub value: Value,
pub input_json: String,
pub invalid_input: bool,
stopped: bool,
}
#[derive(Debug)]
pub(super) struct MessageSnapshot {
pub message: Value,
pub blocks: BTreeMap<u64, Block>,
}
impl MessageSnapshot {
fn into_json(mut self) -> Result<Value, TranslationError> {
if self.blocks.values().any(|block| block.invalid_input) {
return Err(TranslationError::InvalidEvent(
"The Messages tool input is not valid JSON.",
));
}
if self.message.get("type").and_then(Value::as_str) != Some("error") {
self.message["content"] =
Value::Array(self.blocks.into_values().map(|block| block.value).collect());
}
Ok(self.message)
}
}
/// 非流式调用的 Messages 聚合器,每个上游执行独立创建
#[derive(Debug, Default)]
pub struct MessagesAccumulator {
message: Option<Value>,
blocks: BTreeMap<u64, Block>,
terminal: bool,
}
impl MessagesAccumulator {
/// message_stop 返回完整响应,error 返回原生错误终态,未知事件不改变状态
pub fn push(&mut self, event: &Value) -> Result<Option<Value>, TranslationError> {
self.accumulate(event)?
.map(MessageSnapshot::into_json)
.transpose()
}
// 原生 JSON 要求工具输入可解析,跨协议转换还需要保留合法截断的原始参数
pub(super) fn accumulate(
&mut self,
event: &Value,
) -> Result<Option<MessageSnapshot>, TranslationError> {
let kind =
event
.get("type")
.and_then(Value::as_str)
.ok_or(TranslationError::InvalidEvent(
"The Messages event type is missing.",
))?;
if self.terminal {
return Err(TranslationError::InvalidEvent(
"The Messages stream contains events after its terminal event.",
));
}
match kind {
"error" => {
self.terminal = true;
return Ok(Some(MessageSnapshot {
message: event.clone(),
blocks: BTreeMap::new(),
}));
}
"message_start" => {
if self.message.is_some() {
return Err(TranslationError::InvalidEvent(
"The Messages stream contains duplicate message_start events.",
));
}
let message = event.get("message").filter(|v| v.is_object()).ok_or(
TranslationError::InvalidEvent(
"The message_start event must contain a message object.",
),
)?;
self.message = Some(message.clone());
}
"content_block_start" => {
self.require_message()?;
let index = index(event)?;
if self.blocks.contains_key(&index) {
return Err(TranslationError::InvalidEvent(
"The Messages content block index is duplicated.",
));
}
let value = event
.get("content_block")
.filter(|v| v.is_object())
.ok_or(TranslationError::InvalidEvent(
"The content_block_start event must contain a content block.",
))?
.clone();
self.blocks.insert(
index,
Block {
value,
input_json: String::new(),
invalid_input: false,
stopped: false,
},
);
}
"content_block_delta" => {
let block = self.active_block(event)?;
let delta = event.get("delta").ok_or(TranslationError::InvalidEvent(
"The content block delta is missing.",
))?;
match delta
.get("type")
.and_then(Value::as_str)
.unwrap_or_default()
{
"text_delta" => append(&mut block.value, "text", delta.get("text")),
"thinking_delta" => append(&mut block.value, "thinking", delta.get("thinking")),
"signature_delta" => {
append(&mut block.value, "signature", delta.get("signature"))
}
"input_json_delta" => block.input_json.push_str(
delta
.get("partial_json")
.and_then(Value::as_str)
.unwrap_or_default(),
),
"citations_delta" => {
if block.value.get("citations").is_none() {
block.value["citations"] = json!([]);
}
if let Some(citation) = delta.get("citation")
&& let Some(citations) = block
.value
.get_mut("citations")
.and_then(Value::as_array_mut)
{
citations.push(citation.clone());
}
}
_ => {}
}
}
"content_block_stop" => {
let block = self.active_block(event)?;
if !block.input_json.is_empty() {
match serde_json::from_str(&block.input_json) {
Ok(input) => block.value["input"] = input,
Err(_) => block.invalid_input = true,
}
}
block.stopped = true;
}
"message_delta" => {
let message = self.message.as_mut().ok_or(TranslationError::InvalidEvent(
"The Messages delta arrived before message_start.",
))?;
if let Some(delta) = event.get("delta").and_then(Value::as_object) {
for (key, value) in delta {
message[key] = value.clone();
}
}
if let Some(usage) = event.get("usage").and_then(Value::as_object) {
if !message.get("usage").is_some_and(Value::is_object) {
message["usage"] = json!({});
}
for (key, value) in usage {
message["usage"][key] = value.clone();
}
}
}
"message_stop" => {
self.require_message()?;
if self.blocks.values().any(|block| !block.stopped) {
return Err(TranslationError::InvalidEvent(
"The Messages stream ended with an open content block.",
));
}
let message = self
.message
.take()
.ok_or(TranslationError::IncompleteStream)?;
self.terminal = true;
return Ok(Some(MessageSnapshot {
message,
blocks: std::mem::take(&mut self.blocks),
}));
}
_ => {}
}
Ok(None)
}
/// 必须消费成功或失败终态,连接结束不能被当作成功
pub fn finish(&self) -> Result<(), TranslationError> {
if self.terminal {
Ok(())
} else {
Err(TranslationError::IncompleteStream)
}
}
pub(super) fn block(&self, index: u64) -> Option<&Block> {
self.blocks.get(&index)
}
fn require_message(&self) -> Result<(), TranslationError> {
if self.message.is_some() {
Ok(())
} else {
Err(TranslationError::InvalidEvent(
"The Messages content arrived before message_start.",
))
}
}
fn active_block(&mut self, event: &Value) -> Result<&mut Block, TranslationError> {
self.blocks
.get_mut(&index(event)?)
.filter(|block| !block.stopped)
.ok_or(TranslationError::InvalidEvent(
"The Messages delta references a content block that is not open.",
))
}
}
pub(super) fn index(event: &Value) -> Result<u64, TranslationError> {
event
.get("index")
.and_then(Value::as_u64)
.ok_or(TranslationError::InvalidEvent(
"The content block index is missing.",
))
}
fn append(block: &mut Value, key: &str, fragment: Option<&Value>) {
if let Some(fragment) = fragment.and_then(Value::as_str) {
if let Some(Value::String(value)) = block.get_mut(key) {
value.push_str(fragment);
} else {
block[key] = Value::String(fragment.to_owned());
}
}
}
@@ -0,0 +1,43 @@
//! 每次执行独立持有的 SSE 聚合与转换状态
mod accumulator;
mod to_messages;
mod to_responses;
pub use accumulator::MessagesAccumulator;
pub use to_messages::ResponsesToMessagesStream;
pub use to_responses::MessagesToResponsesStream;
use super::TranslationError;
use serde_json::{Value, json};
/// 将已收到的完整原生消息交付给请求 SSE 的客户端,保留内容块与扩展字段
///
/// # Errors
///
/// 对象不是完整 Messages 响应或缺少内容数组时返回错误
pub fn message_to_stream_events(mut message: Value) -> Result<Vec<Value>, TranslationError> {
if message.get("type").and_then(Value::as_str) != Some("message") {
return Err(TranslationError::InvalidEvent(
"The upstream response is not a message.",
));
}
let content = message
.get_mut("content")
.and_then(Value::as_array_mut)
.map(std::mem::take)
.ok_or(TranslationError::InvalidEvent(
"The upstream message content is missing.",
))?;
let stop_reason = message["stop_reason"].take();
let stop_sequence = message["stop_sequence"].take();
let usage = message.get("usage").cloned().unwrap_or_else(|| json!({}));
let mut events = vec![json!({"type":"message_start","message":message})];
for (index, block) in content.into_iter().enumerate() {
events.push(json!({"type":"content_block_start","index":index,"content_block":block}));
events.push(json!({"type":"content_block_stop","index":index}));
}
events.push(json!({"type":"message_delta","delta":{"stop_reason":stop_reason,"stop_sequence":stop_sequence},"usage":usage}));
events.push(json!({"type":"message_stop"}));
Ok(events)
}
@@ -0,0 +1,368 @@
//! Responses SSE 到 Messages SSE 的增量转换与签名终态回传
use std::collections::BTreeMap;
use serde_json::{Map, Value, json};
use super::super::{
TranslationError, content,
response::{responses_error_to_messages, responses_item_to_messages, responses_stop_reason},
usage,
};
#[derive(Debug)]
struct Block {
index: usize,
kind: String,
emitted: String,
signature_sent: bool,
stopped: bool,
last_summary_index: Option<u64>,
}
/// 每次 Responses 执行独立持有输出块与结束状态
#[derive(Debug)]
pub struct ResponsesToMessagesStream {
model: Option<Value>,
blocks: BTreeMap<(u64, usize), Block>,
started: bool,
terminal: bool,
}
impl ResponsesToMessagesStream {
/// 原始 Messages 请求用于保留客户端模型身份
#[must_use]
pub fn new(original_request: &Map<String, Value>) -> Self {
Self {
model: original_request.get("model").cloned(),
blocks: BTreeMap::new(),
started: false,
terminal: false,
}
}
/// 完整 JSON 响应只需要客户端模型名
pub fn complete_json(&self, response: &Value) -> Result<Value, TranslationError> {
super::super::response::complete_message(response, self.model.as_ref())
}
/// 输入已解码 Responses 事件,返回 Messages 事件
pub fn push(&mut self, event: &Value) -> Result<Vec<Value>, TranslationError> {
if self.terminal {
return Err(TranslationError::InvalidEvent(
"The Responses stream contains events after its terminal event.",
));
}
let kind =
event
.get("type")
.and_then(Value::as_str)
.ok_or(TranslationError::InvalidEvent(
"The Responses event type is missing.",
))?;
let mut events = Vec::new();
if matches!(kind, "error" | "response.failed") {
let error = event.get("error").or_else(||event.pointer("/response/error")).cloned().unwrap_or_else(||json!({"type":"api_error","message":event.get("message").and_then(Value::as_str).unwrap_or("The upstream response failed.")}));
self.terminal = true;
return Ok(vec![
json!({"type":"error","error":responses_error_to_messages(&error)}),
]);
}
if kind.starts_with("response.") {
self.start(event.get("response"), &mut events);
}
let output_index = event
.get("output_index")
.and_then(Value::as_u64)
.unwrap_or_default();
let content_index = event
.get("content_index")
.and_then(Value::as_u64)
.unwrap_or_default() as usize;
match kind {
"response.output_item.added" => {
let item = event.get("item").filter(|v| v.is_object()).ok_or(
TranslationError::InvalidEvent("The output item event must contain an item."),
)?;
match item.get("type").and_then(Value::as_str).unwrap_or_default() {
"function_call" | "custom_tool_call" | "reasoning" => {
if let Some(block) = responses_item_to_messages(item).first() {
self.ensure_block((output_index, 0), block, &mut events);
}
}
_ => {}
}
}
"response.content_part.added" => {
if let Some(part) = event.get("part").and_then(content::to_messages_content) {
self.ensure_block((output_index, content_index), &part, &mut events);
}
}
"response.output_text.delta" | "response.refusal.delta" => {
let key = (output_index, content_index);
self.ensure_block(key, &json!({"type":"text","text":""}), &mut events);
self.emit_delta(
key,
"text_delta",
"text",
event
.get("delta")
.and_then(Value::as_str)
.unwrap_or_default(),
&mut events,
)?;
}
"response.reasoning_summary_text.delta" | "response.reasoning_text.delta" => {
let key = (output_index, 0);
self.ensure_block(key, &json!({"type":"thinking","thinking":""}), &mut events);
let part_index = event
.get("summary_index")
.or_else(|| event.get("content_index"))
.and_then(Value::as_u64)
.unwrap_or_default();
let separator = self.blocks.get(&key).is_some_and(|block| {
!block.emitted.is_empty()
&& block
.last_summary_index
.is_some_and(|previous| previous != part_index)
});
if separator {
self.emit_delta(key, "thinking_delta", "thinking", "\n", &mut events)?;
}
if let Some(block) = self.blocks.get_mut(&key) {
block.last_summary_index = Some(part_index);
}
self.emit_delta(
key,
"thinking_delta",
"thinking",
event
.get("delta")
.and_then(Value::as_str)
.unwrap_or_default(),
&mut events,
)?;
}
"response.function_call_arguments.delta" => {
let key = (output_index, 0);
if !self.blocks.contains_key(&key) {
return Err(TranslationError::InvalidEvent(
"The tool arguments arrived before the output item.",
));
}
self.emit_delta(
key,
"input_json_delta",
"partial_json",
event
.get("delta")
.and_then(Value::as_str)
.unwrap_or_default(),
&mut events,
)?;
}
// custom 输入在完整 item 中一次包装为 JSON,不能逐片转义成独立参数
"response.custom_tool_call_input.delta" => {
if !self.blocks.contains_key(&(output_index, 0)) {
return Err(TranslationError::InvalidEvent(
"The custom tool input arrived before the output item.",
));
}
}
"response.output_item.done" => {
let item = event.get("item").filter(|v| v.is_object()).ok_or(
TranslationError::InvalidEvent("The output item event must contain an item."),
)?;
self.complete_item(output_index, item, false, &mut events)?;
}
"response.completed" | "response.incomplete" => {
let response = event
.get("response")
.filter(|response| response.is_object())
.ok_or(TranslationError::InvalidEvent(
"The terminal Responses event must contain a response.",
))?;
if let Some(output) = response.get("output") {
let output = output.as_array().ok_or(TranslationError::InvalidEvent(
"The Responses output must be an array.",
))?;
for (index, item) in output.iter().enumerate() {
self.complete_item(index as u64, item, true, &mut events)?;
}
}
let open = self.blocks.values_mut().filter(|block| !block.stopped);
for block in open {
block.stopped = true;
events.push(json!({"type":"content_block_stop","index":block.index}));
}
if !response["error"].is_null() || response["status"] == "failed" {
events.push(json!({"type":"error","error":responses_error_to_messages(&response["error"])}));
} else {
// 终态可以省略已经交付的 output,停止原因由客户端实际收到的块决定
let has_tool = self.blocks.values().any(|block| block.kind == "tool_use");
events.push(json!({"type":"message_delta","delta":{"stop_reason":responses_stop_reason(response,has_tool),"stop_sequence":null},"usage":usage::responses_usage(&response["usage"])}));
events.push(json!({"type":"message_stop"}));
}
self.terminal = true;
}
_ => {}
}
Ok(events)
}
/// 连接关闭仅在已消费终态时成功
pub fn finish(&self) -> Result<(), TranslationError> {
if self.terminal {
Ok(())
} else {
Err(TranslationError::IncompleteStream)
}
}
fn start(&mut self, response: Option<&Value>, events: &mut Vec<Value>) {
if self.started {
return;
}
let response = response.unwrap_or(&Value::Null);
events.push(json!({"type":"message_start","message":{"id":response.get("id").and_then(Value::as_str).unwrap_or("msg_responses"),"type":"message","role":"assistant","model":self.model.as_ref().or_else(||response.get("model")),"content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}}));
self.started = true;
}
fn ensure_block(&mut self, key: (u64, usize), block: &Value, events: &mut Vec<Value>) {
if self.blocks.contains_key(&key) {
return;
}
let kind = block.get("type").and_then(Value::as_str).unwrap_or("text");
let mut start = block.clone();
match kind {
"text" => start["text"] = json!(""),
"thinking" => {
start["thinking"] = json!("");
if let Some(object) = start.as_object_mut() {
object.remove("signature");
}
}
"tool_use" => start["input"] = json!({}),
_ => {}
}
let index = self.blocks.len();
self.blocks.insert(
key,
Block {
index,
kind: kind.to_owned(),
emitted: String::new(),
signature_sent: false,
stopped: false,
last_summary_index: None,
},
);
events.push(json!({"type":"content_block_start","index":index,"content_block":start}));
}
fn emit_delta(
&mut self,
key: (u64, usize),
kind: &str,
field: &str,
fragment: &str,
events: &mut Vec<Value>,
) -> Result<(), TranslationError> {
let block = self
.blocks
.get_mut(&key)
.filter(|block| !block.stopped)
.ok_or(TranslationError::InvalidEvent(
"The Responses delta references a closed content block.",
))?;
block.emitted.push_str(fragment);
if !fragment.is_empty() {
events.push(json!({"type":"content_block_delta","index":block.index,"delta":{"type":kind,field:fragment}}));
}
Ok(())
}
fn complete_item(
&mut self,
output_index: u64,
item: &Value,
terminal: bool,
events: &mut Vec<Value>,
) -> Result<(), TranslationError> {
let contents = if item.get("type").and_then(Value::as_str) == Some("message") {
item.get("content")
.and_then(Value::as_array)
.into_iter()
.flatten()
.enumerate()
.filter_map(|(index, part)| {
content::to_messages_content(part).map(|content| (index, content))
})
.collect::<Vec<_>>()
} else {
responses_item_to_messages(item)
.into_iter()
.enumerate()
.collect()
};
for (content_index, content) in &contents {
let key = (output_index, *content_index);
self.ensure_block(key, content, events);
let Some(block) = self.blocks.get(&key) else {
continue;
};
if block.stopped {
continue;
}
let full = match block.kind.as_str() {
"text" => content
.get("text")
.and_then(Value::as_str)
.unwrap_or_default()
.to_owned(),
"thinking" => content
.get("thinking")
.and_then(Value::as_str)
.unwrap_or_default()
.to_owned(),
"tool_use" => content
.get("input")
.cloned()
.unwrap_or_else(|| json!({}))
.to_string(),
_ => String::new(),
};
let delta = full
.strip_prefix(&block.emitted)
.unwrap_or_default()
.to_owned();
let (kind, field) = match block.kind.as_str() {
"text" => ("text_delta", "text"),
"thinking" => ("thinking_delta", "thinking"),
_ => ("input_json_delta", "partial_json"),
};
if !delta.is_empty() {
self.emit_delta(key, kind, field, &delta, events)?;
}
let Some(block) = self.blocks.get_mut(&key) else {
continue;
};
if block.kind == "thinking" && !block.signature_sent {
if item
.get("encrypted_content")
.and_then(Value::as_str)
.is_some()
|| terminal
{
events.push(json!({"type":"content_block_delta","index":block.index,"delta":{"type":"signature_delta","signature":content::openai_carrier(item)}}));
block.signature_sent = true;
} else {
continue;
}
}
block.stopped = true;
events.push(json!({"type":"content_block_stop","index":block.index}));
}
Ok(())
}
}
@@ -0,0 +1,329 @@
//! Messages SSE 到 Responses SSE 的逐块转换
use std::collections::BTreeMap;
use serde_json::{Map, Value, json};
use super::super::{
TranslationError,
response::{
complete_response, messages_block_to_response, response_from_message,
terminal_response_event,
},
tools::ToolSet,
};
use super::{
MessagesAccumulator,
accumulator::{Block, index},
};
/// 单次 Messages 上游执行对应的 Responses 转换状态
#[derive(Debug)]
pub struct MessagesToResponsesStream {
model: Option<Value>,
tools: ToolSet,
accumulator: MessagesAccumulator,
response_id: String,
output_indices: BTreeMap<u64, usize>,
sequence: u64,
}
impl MessagesToResponsesStream {
/// 原始 Responses 请求用于工具身份与模型恢复
#[must_use]
pub fn new(original_request: &Map<String, Value>) -> Self {
Self {
model: original_request.get("model").cloned(),
tools: ToolSet::identities(original_request),
accumulator: MessagesAccumulator::default(),
response_id: String::new(),
output_indices: BTreeMap::new(),
sequence: 0,
}
}
/// JSON 和事件流共用同一份模型及工具身份,不持有客户端历史
pub fn complete_json_event(&self, message: &Value) -> Result<Value, TranslationError> {
complete_response(message, self.model.as_ref(), &self.tools).map(terminal_response_event)
}
/// 输入已解码事件,返回携带 type 的 Responses 事件
pub fn push(&mut self, event: &Value) -> Result<Vec<Value>, TranslationError> {
let terminal = self.accumulator.accumulate(event)?;
let kind = event
.get("type")
.and_then(Value::as_str)
.unwrap_or_default();
let mut events = Vec::new();
match kind {
"message_start" => {
let message = event.get("message").ok_or(TranslationError::InvalidEvent(
"The message_start event must contain a message.",
))?;
self.response_id = message
.get("id")
.and_then(Value::as_str)
.unwrap_or("resp_messages")
.to_owned();
let mut response = complete_response(message, self.model.as_ref(), &self.tools)?;
response["status"] = json!("in_progress");
response["output"] = json!([]);
response["usage"] = Value::Null;
events.push(json!({"type":"response.created","response":response}));
events.push(json!({"type":"response.in_progress","response":response}));
}
"content_block_start" => {
let index = index(event)?;
if let Some(block) = self.accumulator.block(index)
&& let Some(mut item) = self.block_item(index, block)
{
let block = &block.value;
let output_index = self.output_indices.len();
self.output_indices.insert(index, output_index);
let item_type = item
.get("type")
.and_then(Value::as_str)
.unwrap_or_default()
.to_owned();
item["status"] = json!("in_progress");
match item_type.as_str() {
"message" => item["content"] = json!([]),
"function_call" => item["arguments"] = json!(""),
"custom_tool_call" => item["input"] = json!(""),
"reasoning" => {
item["summary"] = json!([]);
if let Some(object) = item.as_object_mut() {
object.remove("encrypted_content");
}
}
_ => {}
}
events.push(json!({"type":"response.output_item.added","output_index":output_index,"item":item}));
if item_type == "message" {
events.push(json!({"type":"response.content_part.added","output_index":output_index,"item_id":self.item_id(index),"content_index":0,"part":{"type":"output_text","text":"","annotations":[]}}));
if let Some(text) = block
.get("text")
.and_then(Value::as_str)
.filter(|v| !v.is_empty())
{
events.push(self.delta(
index,
output_index,
"response.output_text.delta",
"delta",
text,
));
}
} else if block.get("type").and_then(Value::as_str) == Some("thinking") {
events.push(json!({"type":"response.reasoning_summary_part.added","output_index":output_index,"item_id":self.item_id(index),"summary_index":0,"part":{"type":"summary_text","text":""}}));
if let Some(text) = block
.get("thinking")
.and_then(Value::as_str)
.filter(|v| !v.is_empty())
{
events.push(self.delta(
index,
output_index,
"response.reasoning_summary_text.delta",
"delta",
text,
));
}
}
}
}
"content_block_delta" => {
let index = index(event)?;
if let Some(output_index) = self.output_indices.get(&index).copied() {
let delta = event.get("delta").unwrap_or(&Value::Null);
let (kind, key) = match delta
.get("type")
.and_then(Value::as_str)
.unwrap_or_default()
{
"text_delta" => ("response.output_text.delta", "text"),
"thinking_delta" => ("response.reasoning_summary_text.delta", "thinking"),
"input_json_delta" => {
("response.function_call_arguments.delta", "partial_json")
}
_ => ("", ""),
};
let custom = self
.accumulator
.block(index)
.and_then(|block| block.value.get("name"))
.and_then(Value::as_str)
.and_then(|name| self.tools.tools.get(name))
.is_some_and(|tool| tool.custom);
if !kind.is_empty() && !(custom && key == "partial_json") {
events.push(self.delta(
index,
output_index,
kind,
"delta",
delta.get(key).and_then(Value::as_str).unwrap_or_default(),
));
}
}
}
"content_block_stop" => {
let index = index(event)?;
if let Some(output_index) = self.output_indices.get(&index).copied()
&& let Some(block) = self.accumulator.block(index)
&& !block.invalid_input
&& let Some(item) = self.block_item(index, block)
{
match item.get("type").and_then(Value::as_str).unwrap_or_default() {
"message" => {
let part = &item["content"][0];
events.push(self.delta(
index,
output_index,
"response.output_text.done",
"text",
part.get("text").and_then(Value::as_str).unwrap_or_default(),
));
events.push(json!({"type":"response.content_part.done","output_index":output_index,"item_id":self.item_id(index),"content_index":0,"part":part}));
}
"function_call" => events.push(
self.delta(
index,
output_index,
"response.function_call_arguments.done",
"arguments",
item.get("arguments")
.and_then(Value::as_str)
.unwrap_or_default(),
),
),
"custom_tool_call" => {
let input = item
.get("input")
.and_then(Value::as_str)
.unwrap_or_default();
events.push(self.delta(
index,
output_index,
"response.custom_tool_call_input.delta",
"delta",
input,
));
events.push(self.delta(
index,
output_index,
"response.custom_tool_call_input.done",
"input",
input,
));
}
"reasoning" => {
if let Some(part) = item
.get("summary")
.and_then(Value::as_array)
.and_then(|parts| parts.first())
{
events.push(self.delta(
index,
output_index,
"response.reasoning_summary_text.done",
"text",
part.get("text").and_then(Value::as_str).unwrap_or_default(),
));
events.push(json!({"type":"response.reasoning_summary_part.done","output_index":output_index,"item_id":self.item_id(index),"summary_index":0,"part":part}));
}
}
_ => {}
}
events.push(json!({"type":"response.output_item.done","output_index":output_index,"item":item}));
}
}
"message_stop" | "error" => {
if let Some(snapshot) = terminal {
let mut response =
response_from_message(&snapshot.message, self.model.as_ref(), Vec::new());
let mut output = Vec::new();
for (index, block) in &snapshot.blocks {
if block.invalid_input && block.value["type"] != "tool_use" {
return Err(TranslationError::InvalidEvent(
"The Messages tool input is not valid JSON.",
));
}
if let Some(mut item) = self.block_item(*index, block) {
if block.invalid_input {
item["status"] = response["status"].clone();
let output_index = self.output_indices.get(index).copied().ok_or(
TranslationError::InvalidEvent(
"The tool output item is missing.",
),
)?;
let (event_type, field) = if item["type"] == "custom_tool_call" {
events.push(self.delta(
*index,
output_index,
"response.custom_tool_call_input.delta",
"delta",
item["input"].as_str().unwrap_or_default(),
));
("response.custom_tool_call_input.done", "input")
} else {
("response.function_call_arguments.done", "arguments")
};
events.push(self.delta(
*index,
output_index,
event_type,
field,
item[field].as_str().unwrap_or_default(),
));
events.push(json!({"type":"response.output_item.done","output_index":output_index,"item":item}));
}
output.push(item);
}
}
response["output"] = json!(output);
if kind == "error" {
response["id"] = json!(self.response_id);
}
events.push(terminal_response_event(response));
}
}
_ => {}
}
for event in &mut events {
event["sequence_number"] = json!(self.sequence);
self.sequence += 1;
}
Ok(events)
}
/// 验证流收到了原生终态
pub fn finish(&self) -> Result<(), TranslationError> {
self.accumulator.finish()
}
fn item_id(&self, index: u64) -> String {
format!("{}_{index}", self.response_id)
}
fn block_item(&self, index: u64, block: &Block) -> Option<Value> {
let mut item = messages_block_to_response(&block.value, &self.tools, &self.item_id(index))?;
if item["type"] == "function_call" && !block.input_json.is_empty() {
item["arguments"] = json!(block.input_json);
}
if block.invalid_input && item["type"] == "custom_tool_call" {
item["input"] = json!(super::super::tools::partial_custom_input(&block.input_json));
}
Some(item)
}
fn delta(&self, index: u64, output_index: usize, kind: &str, key: &str, text: &str) -> Value {
let mut event =
json!({"type":kind,"item_id":self.item_id(index),"output_index":output_index,key:text});
if kind.contains("reasoning_summary") {
event["summary_index"] = json!(0);
} else if kind.contains("output_text") {
event["content_index"] = json!(0);
}
event
}
}
@@ -0,0 +1,163 @@
//! 按目标模型能力映射推理等级与预算;未知兼容上游沿用 CPA 手动预算
use serde_json::{Map, Value, json};
use super::MessagesModelCapabilities;
pub(super) fn to_responses(request: &Map<String, Value>) -> Value {
let configured = request
.get("output_config")
.and_then(|value| value.get("effort"))
.and_then(Value::as_str)
.map(|value| value.trim().to_ascii_lowercase())
.filter(|value| !value.is_empty());
let thinking = request.get("thinking");
let effort = match thinking
.and_then(|value| value.get("type"))
.and_then(Value::as_str)
{
Some("disabled") => "none".to_owned(),
Some("enabled") => {
let budget = thinking
.and_then(|value| value.get("budget_tokens"))
.and_then(Value::as_i64);
match budget {
Some(-1) => "auto",
Some(0) => "none",
Some(1..=512) => "minimal",
Some(513..=1024) => "low",
Some(1025..=8192) => "medium",
Some(8193..=24576) => "high",
Some(24577..) => "xhigh",
_ => "medium",
}
.to_owned()
}
Some("adaptive" | "auto") => configured.unwrap_or_else(|| "xhigh".to_owned()),
_ => configured.unwrap_or_else(|| "medium".to_owned()),
};
json!({"effort":effort})
}
pub(super) fn apply_to_messages(
request: &Map<String, Value>,
target: &mut Map<String, Value>,
capabilities: &MessagesModelCapabilities,
maximum: u64,
) {
let effort = request
.get("reasoning")
.and_then(|v| v.get("effort"))
.and_then(Value::as_str)
.map(|v| v.trim().to_ascii_lowercase());
let forced = matches!(
target
.get("tool_choice")
.and_then(|v| v.get("type"))
.and_then(Value::as_str),
Some("any" | "tool")
);
let adaptive = capabilities.adaptive_thinking == Some(true);
if forced && adaptive {
// 新版 adaptive 模型可能不支持强制工具;沿 CPA 降级为 auto,保留并行限制与推理
if let Some(choice) = target.get_mut("tool_choice").and_then(Value::as_object_mut) {
choice.insert("type".into(), json!("auto"));
choice.shift_remove("name");
}
} else if forced || (effort.is_none() && continues_without_thinking(target)) {
// 默认开启推理的上游要求工具结果回传思考块;无思考的工具轮次保持关闭,直到用户开始新轮次
if capabilities.thinking != Some(false) && capabilities.disabled_thinking != Some(false) {
target.insert("thinking".into(), json!({"type":"disabled"}));
}
return;
}
let Some(effort) = effort else {
return;
};
if capabilities.thinking == Some(false) {
return;
}
if effort == "none" && capabilities.disabled_thinking != Some(false) {
target.insert("thinking".into(), json!({"type":"disabled"}));
return;
}
if adaptive {
target.insert("thinking".into(), json!({"type":"adaptive"}));
if let Some(effort) = adaptive_effort(&effort, capabilities.efforts.as_deref()) {
target.entry("output_config").or_insert_with(|| json!({}))["effort"] = json!(effort);
}
return;
}
if capabilities.manual_thinking == Some(false) {
return;
}
let requested: u64 = match effort.as_str() {
"minimal" => 512,
"low" => 1024,
"medium" => 8192,
"high" => 24576,
"xhigh" => 32768,
"max" => 128000,
"auto" => 8192,
_ => return,
};
// 手动预算至少 1024 且小于输出上限,adaptive 不受此预算下限约束
let budget = requested.max(1024).min(maximum.saturating_sub(1));
if budget >= 1024 {
target.insert(
"thinking".into(),
json!({"type":"enabled","budget_tokens":budget}),
);
} else if capabilities.disabled_thinking != Some(false) {
target.insert("thinking".into(), json!({"type":"disabled"}));
}
}
fn continues_without_thinking(target: &Map<String, Value>) -> bool {
let Some([.., assistant, user]) = target
.get("messages")
.and_then(Value::as_array)
.map(Vec::as_slice)
else {
return false;
};
target.contains_key("tools")
&& user["role"] == "user"
&& user["content"].as_array().is_some_and(|blocks| {
!blocks.is_empty() && blocks.iter().all(|block| block["type"] == "tool_result")
})
&& assistant["role"] == "assistant"
&& assistant["content"].as_array().is_some_and(|blocks| {
blocks.iter().any(|block| block["type"] == "tool_use")
&& !blocks.iter().any(|block| {
matches!(
block["type"].as_str(),
Some("thinking" | "redacted_thinking")
)
})
})
}
fn adaptive_effort<'a>(requested: &str, supported: Option<&'a [String]>) -> Option<&'a str> {
const LEVELS: [&str; 5] = ["low", "medium", "high", "xhigh", "max"];
let requested = match requested {
"none" | "minimal" => "low",
"auto" => return None,
other => other,
};
let rank = LEVELS.iter().position(|level| *level == requested)?;
let Some(supported) = supported else {
return Some(LEVELS[rank]);
};
// 目录明确列出的等级优先,超出范围收敛到最近的较低档,全部更高时取最低可用档
LEVELS[..=rank]
.iter()
.rev()
.chain(LEVELS[rank + 1..].iter())
.find_map(|level| {
supported
.iter()
.find(|value| value.as_str() == *level)
.map(String::as_str)
})
}
@@ -0,0 +1,292 @@
//! 工具名称、custom 参数和原生工具声明的双向映射
use std::collections::BTreeMap;
use super::TranslationError;
use serde_json::{Map, Value, json};
#[derive(Debug, Clone)]
pub(super) struct Tool<D> {
pub name: String,
pub namespace: Option<String>,
pub custom: bool,
pub definition: D,
}
#[derive(Debug, Clone, Default)]
pub(super) struct ToolSet<D = ()> {
pub tools: BTreeMap<String, Tool<D>>,
}
impl<D> ToolSet<D> {
fn collect<'a>(request: &'a Map<String, Value>, definition: impl Fn(&'a Value) -> D) -> Self {
let mut result = Self {
tools: BTreeMap::new(),
};
for tool in request
.get("tools")
.and_then(Value::as_array)
.into_iter()
.flatten()
{
if tool.get("type").and_then(Value::as_str) == Some("namespace") {
let namespace = tool.get("name").and_then(Value::as_str).unwrap_or_default();
for child in tool
.get("tools")
.and_then(Value::as_array)
.into_iter()
.flatten()
{
result.insert(child, Some(namespace), definition(child));
}
} else if !is_web_search(tool) {
result.insert(tool, None, definition(tool));
}
}
result
}
fn insert(&mut self, definition: &Value, namespace: Option<&str>, retained: D) {
let custom = definition.get("type").and_then(Value::as_str) == Some("custom");
let Some(name) = definition.get("name").and_then(Value::as_str) else {
return;
};
let qualified = namespace.map_or_else(|| name.to_owned(), |ns| format!("{ns}__{name}"));
let mut wire_name = qualified;
if wire_name.len() > 64
|| !wire_name
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'-')
{
wire_name = format!("tool_{}", self.tools.len());
}
let mut alias_index = self.tools.len();
while self.tools.contains_key(&wire_name) {
wire_name = format!("tool_{alias_index}");
alias_index += 1;
}
self.tools.insert(
wire_name,
Tool {
name: name.to_owned(),
namespace: namespace.map(str::to_owned),
custom,
definition: retained,
},
);
}
pub fn wire_name<'a>(&'a self, name: &'a str, namespace: Option<&str>) -> &'a str {
self.tools
.iter()
.find_map(|(wire, tool)| {
(tool.name == name && tool.namespace.as_deref() == namespace)
.then_some(wire.as_str())
})
.unwrap_or(name)
}
pub fn call(&self, block: &Value, item_id: &str) -> Value {
let wire_name = block
.get("name")
.and_then(Value::as_str)
.unwrap_or_default();
let tool = self.tools.get(wire_name);
let name = tool.map_or(wire_name, |tool| tool.name.as_str());
let call_id = block.get("id").and_then(Value::as_str).unwrap_or_default();
let input = block.get("input").cloned().unwrap_or_else(|| json!({}));
let mut item = if tool.is_some_and(|tool| tool.custom) {
json!({"type":"custom_tool_call","id":item_id,"call_id":call_id,"name":name,"input":input.get("input").and_then(Value::as_str).unwrap_or_default(),"status":"completed"})
} else {
json!({"type":"function_call","id":item_id,"call_id":call_id,"name":name,"arguments":input.to_string(),"status":"completed"})
};
if let Some(namespace) = tool.and_then(|tool| tool.namespace.as_deref()) {
item["namespace"] = json!(namespace);
}
item
}
}
impl ToolSet {
pub fn identities(request: &Map<String, Value>) -> Self {
Self::collect(request, |_| ())
}
}
impl<'a> ToolSet<&'a Value> {
pub fn from_responses(request: &'a Map<String, Value>) -> Self {
Self::collect(request, |tool| tool)
}
fn definitions(&self, allowed: Option<&[Value]>) -> Vec<Value> {
self.tools.iter().filter(|(_, tool)| {
allowed.is_none_or(|choices| choices.iter().any(|choice|
matches!(choice["type"].as_str(), Some("function" | "custom"))
&& choice["type"] == tool.definition["type"]
&& choice.get("name").and_then(Value::as_str) == Some(tool.name.as_str())
&& choice.get("namespace").and_then(Value::as_str) == tool.namespace.as_deref()
))
}).map(|(name, tool)| {
let schema = if tool.custom {
json!({"type":"object","properties":{"input":{"type":"string"}},"required":["input"]})
} else {
tool.definition.get("parameters").cloned().unwrap_or_else(|| json!({"type":"object","properties":{}}))
};
let mut definition = json!({"name":name,"input_schema":schema});
for field in ["description", "strict", "cache_control", "defer_loading"] {
if let Some(value) = tool.definition.get(field) { definition[field] = value.clone(); }
}
definition
}).collect()
}
pub fn write_messages_tools(
&self,
request: &Map<String, Value>,
target: &mut Map<String, Value>,
) -> Result<(), TranslationError> {
let choice = request.get("tool_choice").unwrap_or(&Value::Null);
let restricted = choice["type"] == "allowed_tools";
let allowed = if restricted {
Some(
choice["tools"]
.as_array()
.filter(|v| !v.is_empty())
.ok_or(TranslationError::InvalidRequest(
"Allowed tools must contain at least one tool.",
))?
.as_slice(),
)
} else {
None
};
let mut definitions = self.definitions(allowed);
for tool in request
.get("tools")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter(|t| is_web_search(t))
{
// Messages 的搜索是实时联网;缓存或索引模式不能升级为实时访问
if tool
.get("external_web_access")
.is_some_and(|v| !v.is_null() && v != true && v != "live")
|| allowed.is_some_and(|choices| !choices.iter().any(|c| c["type"] == tool["type"]))
{
continue;
}
let mut search = json!({"type":"web_search_20250305","name":"web_search"});
if let Some(filters) = tool.get("filters").filter(|v| !v.is_null()) {
let filters = filters.as_object().ok_or(TranslationError::InvalidRequest(
"Web search filters must be an object.",
))?;
for field in ["allowed_domains", "blocked_domains"] {
if let Some(value) = filters.get(field) {
search[field] = value.clone();
}
}
}
for field in ["max_uses", "user_location"] {
if let Some(value) = tool.get(field) {
search[field] = value.clone();
}
}
definitions.push(search);
}
if definitions.is_empty() {
if restricted {
return Err(TranslationError::InvalidRequest(
"No allowed tool can be used with the Messages upstream.",
));
}
return Ok(());
}
target.insert("tools".into(), Value::Array(definitions));
let serial = request.get("parallel_tool_calls").and_then(Value::as_bool) == Some(false);
if choice.is_null() && !serial {
return Ok(());
}
let kind = if restricted {
match choice["mode"].as_str() {
Some(mode @ ("auto" | "required")) => mode,
_ => {
return Err(TranslationError::InvalidRequest(
"Allowed tools mode must be auto or required.",
));
}
}
} else {
choice
.as_str()
.or_else(|| choice.get("type").and_then(Value::as_str))
.unwrap_or("auto")
};
let mut mapped = match kind {
"required" => json!({"type":"any"}),
"none" => json!({"type":"none"}),
"function" | "custom" => {
json!({"type":"tool","name":self.wire_name(choice["name"].as_str().unwrap_or_default(),choice["namespace"].as_str())})
}
_ => json!({"type":"auto"}),
};
if serial && kind != "none" {
mapped["disable_parallel_tool_use"] = json!(true);
}
target.insert("tool_choice".into(), mapped);
Ok(())
}
}
fn is_web_search(tool: &Value) -> bool {
matches!(
tool["type"].as_str(),
Some("web_search" | "web_search_preview")
)
}
pub(super) fn messages_tools(tools: &[Value]) -> Vec<Value> {
tools.iter().map(|tool| {
let kind = tool.get("type").and_then(Value::as_str).unwrap_or_default();
if kind.starts_with("web_search_") {
let mut search = json!({"type":"web_search"});
for field in ["allowed_domains", "blocked_domains"] {
if let Some(v) = tool.get(field) { search["filters"][field] = v.clone(); }
}
if let Some(v) = tool.get("user_location") { search["user_location"] = v.clone(); }
return search;
}
let mut result = json!({"type":"function","name":tool.get("name").and_then(Value::as_str).unwrap_or_default(),"parameters":tool.get("input_schema").cloned().unwrap_or_else(||json!({"type":"object","properties":{}}))});
for field in ["description", "strict"] {
if let Some(value) = tool.get(field) { result[field] = value.clone(); }
}
result
}).collect()
}
// 截断的 custom 包装仍可携带已生成的字符串,未完成的转义按原片段保留
pub(super) fn partial_custom_input(arguments: &str) -> String {
let Some((_, rest)) = arguments.split_once("\"input\"") else {
return arguments.to_owned();
};
let Some(value) = rest.trim_start().strip_prefix(':').map(str::trim_start) else {
return arguments.to_owned();
};
if let Some(Ok(input)) = serde_json::Deserializer::from_str(value)
.into_iter::<String>()
.next()
{
return input;
}
// 一个未完成的 UTF-16 代理对最多占 12 字节,只尝试修复字符串尾部
for end in std::iter::once(value.len())
.chain(value.char_indices().rev().take(12).map(|(index, _)| index))
{
if let Ok(mut input) = serde_json::from_str::<String>(&format!("{}\"", &value[..end])) {
input.push_str(&value[end..]);
return input;
}
}
arguments.to_owned()
}
@@ -0,0 +1,77 @@
//! Messages 累计用量的字段合并与 Responses 投影
use serde_json::{Value, json};
/// 原生 Messages 用量,缺失字段保留未知状态
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub struct MessageUsage {
/// 未命中缓存的输入量
pub input_tokens: Option<u64>,
/// 输出量
pub output_tokens: Option<u64>,
/// 缓存读取量
pub cache_read_input_tokens: Option<u64>,
/// 缓存写入量
pub cache_creation_input_tokens: Option<u64>,
}
impl MessageUsage {
/// 从原生 usage 对象解析字段
#[must_use]
pub fn from_value(value: &Value) -> Self {
Self {
input_tokens: value.get("input_tokens").and_then(Value::as_u64),
output_tokens: value.get("output_tokens").and_then(Value::as_u64),
cache_read_input_tokens: value.get("cache_read_input_tokens").and_then(Value::as_u64),
cache_creation_input_tokens: value
.get("cache_creation_input_tokens")
.and_then(Value::as_u64),
}
}
/// Messages 增量上报的是累计值,仅覆盖本次实际出现的字段
pub fn merge(&mut self, value: &Value) {
let newer = Self::from_value(value);
self.input_tokens = newer.input_tokens.or(self.input_tokens);
self.output_tokens = newer.output_tokens.or(self.output_tokens);
self.cache_read_input_tokens = newer
.cache_read_input_tokens
.or(self.cache_read_input_tokens);
self.cache_creation_input_tokens = newer
.cache_creation_input_tokens
.or(self.cache_creation_input_tokens);
}
/// 包含缓存读取与写入的总输入量
#[must_use]
pub fn total_input_tokens(self) -> Option<u64> {
self.input_tokens.map(|input| {
input
.saturating_add(self.cache_read_input_tokens.unwrap_or_default())
.saturating_add(self.cache_creation_input_tokens.unwrap_or_default())
})
}
pub(super) fn responses(self) -> Value {
let input = self.total_input_tokens().unwrap_or_default();
let output = self.output_tokens.unwrap_or_default();
// Messages 没有独立的推理 token 计数,省略详情,避免空对象违反 Responses 客户端合同
json!({"input_tokens": input, "output_tokens": output, "total_tokens": input.saturating_add(output), "input_tokens_details": {"cached_tokens": self.cache_read_input_tokens.unwrap_or_default(), "cache_write_tokens": self.cache_creation_input_tokens.unwrap_or_default()}})
}
}
pub(super) fn responses_usage(value: &Value) -> Value {
let input = value
.get("input_tokens")
.and_then(Value::as_u64)
.unwrap_or_default();
let cached = value
.pointer("/input_tokens_details/cached_tokens")
.and_then(Value::as_u64)
.unwrap_or_default();
let written = value
.pointer("/input_tokens_details/cache_write_tokens")
.and_then(Value::as_u64)
.unwrap_or_default();
json!({"input_tokens": input.saturating_sub(cached).saturating_sub(written), "output_tokens": value.get("output_tokens").and_then(Value::as_u64).unwrap_or_default(), "cache_read_input_tokens": cached, "cache_creation_input_tokens": written})
}
@@ -5,5 +5,11 @@
/// OpenAI wire contract
pub mod openai;
/// Anthropic Messages 与 Responses 的线协议转换
pub mod anthropic;
/// 协议请求中的共享能力事实
pub mod request;
/// CPR 互联只读观测协议
pub mod peer;
@@ -0,0 +1,80 @@
//! 从协议正文提取调度需要的纯请求事实
use serde_json::{Map, Value};
/// 请求正文表达的能力要求
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct RequestFacts {
/// 显式输出预算
pub max_output_tokens: Option<u64>,
/// 工具声明
pub tools: bool,
/// 图片输入
pub vision: bool,
/// 推理配置
pub reasoning: bool,
/// JSON Schema 输出
pub json_schema: bool,
/// 原生服务端续接
pub native_continuation: bool,
}
/// 按协议提取能力事实,未知协议保留空事实供其 owner 补齐
#[must_use]
pub fn request_facts(protocol: &str, body: &Map<String, Value>) -> RequestFacts {
let mut facts = RequestFacts {
tools: body
.get("tools")
.and_then(Value::as_array)
.is_some_and(|v| !v.is_empty()),
..RequestFacts::default()
};
match protocol {
"openai" => {
facts.max_output_tokens = body
.get("max_output_tokens")
.and_then(Value::as_u64)
.filter(|n| *n > 0);
facts.vision = contains_type(body.get("input"), "input_image");
facts.reasoning = body.get("reasoning").is_some_and(Value::is_object);
facts.json_schema = body
.get("text")
.and_then(|v| v.get("format"))
.and_then(|v| v.get("type"))
.and_then(Value::as_str)
== Some("json_schema");
facts.native_continuation = body
.get("previous_response_id")
.and_then(Value::as_str)
.is_some();
}
"anthropic" => {
facts.max_output_tokens = body.get("max_tokens").and_then(Value::as_u64);
facts.vision = contains_type(body.get("messages"), "image");
facts.reasoning = body
.get("thinking")
.and_then(|v| v.get("type"))
.and_then(Value::as_str)
.is_some_and(|v| matches!(v, "enabled" | "adaptive"));
facts.json_schema = body
.get("output_config")
.and_then(|v| v.get("format"))
.and_then(|v| v.get("type"))
.and_then(Value::as_str)
== Some("json_schema");
}
_ => {}
}
facts
}
fn contains_type(value: Option<&Value>, expected: &str) -> bool {
match value {
Some(Value::Array(values)) => values.iter().any(|v| contains_type(Some(v), expected)),
Some(Value::Object(object)) => {
object.get("type").and_then(Value::as_str) == Some(expected)
|| object.values().any(|v| contains_type(Some(v), expected))
}
_ => false,
}
}
@@ -0,0 +1,31 @@
//! 模型目录能力的缺失、显式支持与限制解析
use gateway_protocol::anthropic::MessagesModelCapabilities;
use serde_json::json;
#[test]
fn directory_distinguishes_unknown_from_unsupported_capabilities() {
assert_eq!(
MessagesModelCapabilities::from_model(&json!({"id":"alias"})),
Default::default()
);
let capabilities = MessagesModelCapabilities::from_model(&json!({
"id":"any-alias", "max_tokens":64000,
"capabilities":{
"thinking":{"supported":true,"types":{"adaptive":{"supported":true},"enabled":{"supported":false},"disabled":{"supported":false}}},
"effort":{"supported":true,"low":{"supported":true},"high":{"supported":true},"max":{"supported":false},"future":{"supported":true}}
}
}));
assert_eq!(capabilities.adaptive_thinking, Some(true));
assert_eq!(capabilities.manual_thinking, Some(false));
assert_eq!(capabilities.disabled_thinking, Some(false));
assert_eq!(
capabilities.efforts,
Some(vec!["low".into(), "high".into()])
);
assert_eq!(capabilities.max_tokens, Some(64000));
assert_eq!(
MessagesModelCapabilities::from_model(&json!({"max_tokens":0})).max_tokens,
None
);
}
@@ -0,0 +1,7 @@
//! Messages 转换与聚合行为测试入口
mod capabilities;
mod request;
mod response;
mod stream;
mod usage;
@@ -0,0 +1,590 @@
//! 验证请求内容、工具配对和签名来源
use gateway_protocol::anthropic::{
messages_to_responses_count_request, messages_to_responses_request,
messages_to_responses_response, responses_to_messages_request, responses_to_messages_response,
validate_count_request, validate_request,
};
use serde_json::{Map, Value, json};
use gateway_protocol::anthropic::{
strip_foreign_reasoning_for_responses, strip_foreign_thinking_for_messages,
};
fn object(value: Value) -> Map<String, Value> {
value.as_object().expect("测试正文必须是对象").clone()
}
#[test]
fn mid_conversation_system_messages_keep_their_role_and_position() {
let request = object(json!({
"model":"claude", "max_tokens":128,
"messages":[
{"role":"user", "content":"hello"},
{"role":"system", "content":"Be brief."},
{"role":"system", "content":[], "output_config":{"effort":"medium"}}
]
}));
assert!(validate_request(&request).is_ok());
let converted = messages_to_responses_request(&request).expect("转换会话中的 system 消息");
assert_eq!(converted["input"].as_array().unwrap().len(), 2);
assert_eq!(converted["input"][0]["role"], "user");
assert_eq!(converted["input"][1]["role"], "system");
assert_eq!(converted["input"][1]["content"][0]["text"], "Be brief.");
}
#[test]
fn counting_does_not_require_or_invent_generation_budget() {
let request = object(json!({"model":"model","messages":[{"role":"user","content":"hello"}]}));
assert!(validate_count_request(&request).is_ok());
assert!(validate_request(&request).is_err());
let converted = messages_to_responses_count_request(&request).expect("计数转换");
assert!(!converted.contains_key("max_output_tokens"));
assert_eq!(converted["input"][0]["content"][0]["text"], "hello");
}
#[test]
fn system_images_tools_and_structured_output_map_without_losing_order() {
let request = object(
json!({"model":"claude","max_tokens":4096,"system":"brief","messages":[{"role":"user","content":[{"type":"text","text":"look"},{"type":"image","source":{"type":"base64","media_type":"image/png","data":"AA=="}}]},{"role":"assistant","content":[{"type":"text","text":"calling"},{"type":"tool_use","id":"call_1","name":"lookup","input":{"q":"x"}}]},{"role":"user","content":[{"type":"tool_result","tool_use_id":"call_1","content":"found"}]}],"tools":[{"name":"lookup","input_schema":{"type":"object"}}],"tool_choice":{"type":"tool","name":"lookup","disable_parallel_tool_use":true},"output_config":{"format":{"type":"json_schema","schema":{"type":"object"}}}}),
);
let converted = messages_to_responses_request(&request).expect("转换");
assert_eq!(converted["input"][0]["role"], "developer");
assert_eq!(
converted["input"][1]["content"][1]["image_url"],
"data:image/png;base64,AA=="
);
assert_eq!(converted["input"][3]["type"], "function_call");
assert_eq!(converted["input"][4]["output"], "found");
assert_eq!(converted["parallel_tool_calls"], false);
assert_eq!(converted["text"]["format"]["name"], "response");
}
#[test]
fn custom_tools_round_trip_and_orphan_outputs_follow_cpa_fallback() {
let request = object(
json!({"model":"model","tools":[{"type":"custom","name":"shell","description":"run a command"}],"input":[{"type":"custom_tool_call","call_id":"call_1","name":"shell","input":"echo ok"},{"type":"custom_tool_call_output","call_id":"call_1","output":"old"},{"type":"custom_tool_call_output","call_id":"call_1","output":"new"},{"type":"function_call_output","call_id":"missing","output":"orphan"}]}),
);
let converted = responses_to_messages_request(&request, &Default::default()).expect("转换");
assert_eq!(
converted["messages"][0]["content"][0]["input"]["input"],
"echo ok"
);
assert_eq!(converted["messages"][1]["content"][0]["content"], "new");
assert_eq!(converted["messages"][1]["content"][1]["text"], "orphan");
let native = json!({"id":"m1","content":[{"type":"tool_use","id":"call_2","name":"shell","input":{"input":"pwd"}}],"stop_reason":"tool_use","usage":{}});
let response = messages_to_responses_response(&native, &request).expect("返回转换");
assert_eq!(response["output"][0]["type"], "custom_tool_call");
assert_eq!(response["output"][0]["input"], "pwd");
}
#[test]
fn parallel_tool_results_precede_text_and_keep_custom_input_and_errors() {
let request = object(json!({
"model":"model",
"tools":[
{"type":"function","name":"read","parameters":{"type":"object"}},
{"type":"custom","name":"patch"}
],
"input":[
{"type":"function_call","call_id":"read_1","name":"read","arguments":"{}"},
{"type":"custom_tool_call","call_id":"patch_1","name":"patch","input":"patch text"},
{"role":"user","content":"before"},
{"type":"custom_tool_call_output","call_id":"patch_1","output":"patch failed","status":"incomplete"},
{"role":"user","content":"between"},
{"type":"function_call_output","call_id":"read_1","output":"read result"}
]
}));
let converted = responses_to_messages_request(&request, &Default::default()).unwrap();
assert_eq!(
converted["messages"][0]["content"][1]["input"],
json!({"input":"patch text"})
);
assert_eq!(
converted["messages"][1]["content"],
json!([
{"type":"tool_result","tool_use_id":"patch_1","content":"patch failed","is_error":true},
{"type":"tool_result","tool_use_id":"read_1","content":"read result"},
{"type":"text","text":"before"},
{"type":"text","text":"between"}
])
);
}
#[test]
fn interrupted_parallel_calls_close_before_the_conversation_continues() {
let request = object(json!({"model":"model","input":[
{"type":"function_call","call_id":"first","name":"read","arguments":"{}"},
{"type":"function_call","call_id":"second","name":"read","arguments":"{}"},
{"type":"function_call_output","call_id":"first","output":"available"},
{"role":"user","content":"continue without waiting"},
{"role":"assistant","content":"continuing"},
{"type":"function_call_output","call_id":"second","output":"late result"}
]}));
let converted = responses_to_messages_request(&request, &Default::default()).unwrap();
assert_eq!(
converted["messages"][1]["content"],
json!([
{"type":"tool_result","tool_use_id":"second","is_error":true,"content":"Tool call was interrupted before any output was recorded."},
{"type":"tool_result","tool_use_id":"first","content":"available"},
{"type":"text","text":"continue without waiting"}
])
);
assert_eq!(converted["messages"][2]["content"][0]["text"], "continuing");
assert_eq!(
converted["messages"][3]["content"],
json!([
{"type":"text","text":"late result"}
])
);
}
#[test]
fn trailing_tool_calls_get_explicit_interrupted_results() {
let request = object(json!({"model":"model","input":[
{"role":"user","content":"read files"},
{"type":"function_call","call_id":"second","name":"read","arguments":"{}"},
{"type":"function_call","call_id":"first","name":"read","arguments":"{}"}
]}));
let converted = responses_to_messages_request(&request, &Default::default()).unwrap();
assert_eq!(converted["messages"][2]["role"], "user");
let results = converted["messages"][2]["content"].as_array().unwrap();
assert_eq!(results.len(), 2);
assert_eq!(results[0]["tool_use_id"], "second");
assert_eq!(results[1]["tool_use_id"], "first");
assert!(results.iter().all(|result| result["is_error"] == true));
}
#[test]
fn duplicate_results_do_not_break_an_earlier_completed_round() {
let request = object(json!({"model":"model","input":[
{"type":"function_call","call_id":"call","name":"read","arguments":"{}"},
{"type":"function_call_output","call_id":"call","output":"old"},
{"type":"function_call_output","call_id":"call","output":"new"},
{"role":"assistant","content":"completed"},
{"type":"function_call_output","call_id":"call","output":"late duplicate"}
]}));
let converted = responses_to_messages_request(&request, &Default::default()).unwrap();
assert_eq!(
converted["messages"][1]["content"],
json!([
{"type":"tool_result","tool_use_id":"call","content":"new"}
])
);
assert_eq!(
converted["messages"][3]["content"],
json!([
{"type":"text","text":"late duplicate"}
])
);
}
#[test]
fn orphan_results_reuse_multimodal_content_and_empty_results_keep_a_marker() {
let request = object(json!({"model":"model","input":[
{"type":"function_call_output","call_id":"missing","output":[
{"type":"input_text","text":" "},
{"type":"input_image","image_url":"data:image/png;base64,AA=="},
{"type":"input_file","file_url":"https://example.com/file.pdf"},
{"type":"input_text","text":"caption"}
]},
{"type":"function_call_output","call_id":"empty","output":""}
]}));
let converted = responses_to_messages_request(&request, &Default::default()).unwrap();
assert_eq!(
converted["messages"][0]["content"],
json!([
{"type":"image","source":{"type":"base64","media_type":"image/png","data":"AA=="}},
{"type":"document","source":{"type":"url","url":"https://example.com/file.pdf"}},
{"type":"text","text":"caption"},
{"type":"text","text":"Tool result was empty."}
])
);
}
#[test]
fn closed_tool_history_is_unchanged_after_another_round_trip() {
let request = object(json!({"model":"model","input":[
{"role":"user","content":"read"},
{"type":"function_call","call_id":"call","name":"read","arguments":"{\"path\":\"file\"}"},
{"type":"function_call_output","call_id":"call","output":"result"},
{"role":"user","content":"summarize"},
{"role":"assistant","content":"summary"}
]}));
let converted = responses_to_messages_request(&request, &Default::default()).unwrap();
let replay = messages_to_responses_request(&converted).unwrap();
let restored = responses_to_messages_request(&replay, &Default::default()).unwrap();
assert_eq!(restored["messages"], converted["messages"]);
assert_eq!(
converted["messages"][2]["content"],
json!([
{"type":"tool_result","tool_use_id":"call","content":"result"},
{"type":"text","text":"summarize"}
])
);
}
#[test]
fn anthropic_thinking_and_redacted_blocks_return_to_their_origin() {
let request = object(json!({"model":"model","input":"hi"}));
let blocks = json!([{"type":"thinking","thinking":"private","signature":"signed-native"},{"type":"redacted_thinking","data":"opaque"}]);
let response = messages_to_responses_response(
&json!({"id":"m1","content":blocks,"stop_reason":"end_turn","usage":{}}),
&request,
)
.expect("响应转换");
let mut followup = request;
followup.insert("input".into(), response["output"].clone());
let restored = responses_to_messages_request(&followup, &Default::default()).expect("回传转换");
assert_eq!(restored["messages"][0]["content"], blocks);
}
#[test]
fn openai_reasoning_returns_to_its_origin_and_foreign_signatures_are_dropped() {
let request = object(
json!({"model":"model","max_tokens":100,"messages":[{"role":"user","content":"hi"}]}),
);
let item = json!({"type":"reasoning","id":"r1","summary":[{"type":"summary_text","text":"reason"}],"encrypted_content":"gAAAAopaque"});
let response = responses_to_messages_response(
&json!({"id":"r0","status":"completed","output":[item],"usage":{}}),
&request,
)
.expect("响应转换");
let mut followup = request;
followup.insert(
"messages".into(),
json!([{"role":"assistant","content":response["content"]}]),
);
let restored = messages_to_responses_request(&followup).expect("回传转换");
assert_eq!(restored["input"][0], item);
followup.insert("messages".into(),json!([{"role":"assistant","content":[{"type":"thinking","thinking":"thought","signature":"foreign-anthropic"},{"type":"text","text":"answer"}]}]));
let foreign = messages_to_responses_request(&followup).expect("外来源降级");
assert_eq!(foreign["input"].as_array().expect("数组").len(), 1);
assert_eq!(foreign["input"][0]["type"], "message");
}
#[test]
fn reasoning_budget_stays_inside_explicit_output_limit() {
let request = object(
json!({"model":"model","input":"hi","max_output_tokens":2048,"reasoning":{"effort":"high"}}),
);
let converted = responses_to_messages_request(&request, &Default::default()).expect("预算转换");
assert_eq!(
converted["thinking"],
json!({"type":"enabled","budget_tokens":2047})
);
assert_eq!(converted["max_tokens"], 2048);
}
#[test]
fn switching_to_native_messages_only_removes_our_openai_carrier() {
let source = object(
json!({"model":"model","max_tokens":100,"messages":[{"role":"user","content":"hi"}]}),
);
let response=responses_to_messages_response(&json!({"id":"r1","status":"completed","output":[{"type":"reasoning","id":"reason1","summary":[{"type":"summary_text","text":"thinking"}],"encrypted_content":"gAAAAopaque"},{"type":"message","role":"assistant","content":[{"type":"output_text","text":"answer"}]}],"usage":{}}),&source).expect("第一次走Responses上游");
let mut next = source;
let native = json!({"type":"thinking","thinking":"native","signature":"unknown-native-signature","future_field":9});
next.insert("messages".into(),json!([{"role":"assistant","content":response["content"]},{"role":"assistant","content":[native]},{"role":"user","content":"continue"}]));
strip_foreign_thinking_for_messages(&mut next);
assert_eq!(
next["messages"][0]["content"],
json!([{"type":"text","text":"answer"}])
);
assert_eq!(next["messages"][1]["content"][0], native);
assert_eq!(next["messages"][2]["content"], "continue");
}
#[test]
fn switching_to_native_responses_only_removes_our_anthropic_carrier() {
let source = object(json!({"model":"model","input":"hi"}));
let response=messages_to_responses_response(&json!({"id":"m1","content":[{"type":"thinking","thinking":"thought","signature":"native"},{"type":"text","text":"answer"}],"stop_reason":"end_turn","usage":{}}),&source).expect("第一次走Messages上游");
let mut next = source;
let native = json!({"type":"reasoning","encrypted_content":"unknown-native","future_field":7});
let mut input = response["output"].as_array().expect("输出数组").clone();
input.push(native.clone());
next.insert("input".into(), json!(input));
strip_foreign_reasoning_for_responses(&mut next);
assert_eq!(next["input"].as_array().expect("输入数组").len(), 2);
assert_eq!(next["input"][0]["type"], "message");
assert_eq!(next["input"][1], native);
}
#[test]
fn aliased_tool_names_never_overwrite_an_existing_declaration() {
let source = object(
json!({"model":"model","input":"hi","tools":[{"type":"function","name":"invalid.name","parameters":{}},{"type":"function","name":"tool_0","parameters":{}}]}),
);
let converted = responses_to_messages_request(&source, &Default::default()).expect("工具别名");
assert_eq!(converted["tools"].as_array().expect("工具数组").len(), 2);
let wire = converted["tools"][1]["name"].as_str().expect("工具名称");
let response = messages_to_responses_response(
&json!({"content":[{"type":"tool_use","id":"c1","name":wire,"input":{}}],"usage":{}}),
&source,
)
.expect("反向工具别名");
assert_eq!(response["output"][0]["name"], "tool_0");
}
#[test]
fn explicit_thinking_switches_and_cpa_budget_levels_survive_conversion() {
for (effort, budget) in [
("minimal", 1024),
("low", 1024),
("medium", 8192),
("high", 24576),
("xhigh", 32768),
("max", 128000),
] {
let request = object(
json!({"model":"model","input":"hi","max_output_tokens":200000,"reasoning":{"effort":effort}}),
);
let converted = responses_to_messages_request(&request, &Default::default()).unwrap();
assert_eq!(
converted["thinking"],
json!({"type":"enabled","budget_tokens":budget})
);
}
let disabled = object(json!({"model":"model","input":"hi","reasoning":{"effort":"none"}}));
assert_eq!(
responses_to_messages_request(&disabled, &Default::default()).unwrap()["thinking"],
json!({"type":"disabled"})
);
let no_budget = object(
json!({"model":"model","input":"hi","max_output_tokens":1024,"reasoning":{"effort":"high"}}),
);
assert_eq!(
responses_to_messages_request(&no_budget, &Default::default()).unwrap()["thinking"],
json!({"type":"disabled"})
);
for (thinking, effort) in [
(json!({"type":"disabled"}), "none"),
(json!({"type":"enabled","budget_tokens":1024}), "low"),
(json!({"type":"enabled","budget_tokens":8192}), "medium"),
(json!({"type":"enabled","budget_tokens":24576}), "high"),
(json!({"type":"enabled","budget_tokens":32768}), "xhigh"),
] {
let request = object(
json!({"model":"model","messages":[{"role":"user","content":"hi"}],"max_tokens":200000,"thinking":thinking}),
);
assert_eq!(
messages_to_responses_request(&request).unwrap()["reasoning"]["effort"],
effort
);
}
for thinking in [None, Some(json!({"type":"adaptive"}))] {
let mut request = object(
json!({"model":"model","messages":[{"role":"user","content":"hi"}],"max_tokens":1024,"output_config":{"effort":"low"}}),
);
if let Some(thinking) = thinking {
request.insert("thinking".into(), thinking);
}
assert_eq!(
messages_to_responses_request(&request).unwrap()["reasoning"]["effort"],
"low"
);
}
}
#[test]
fn adaptive_capabilities_drive_thinking_effort_and_output_limit_without_model_guessing() {
let capabilities = gateway_protocol::anthropic::MessagesModelCapabilities::from_model(&json!({
"max_tokens":512,
"capabilities":{"thinking":{"supported":true,"types":{"adaptive":{"supported":true},"enabled":{"supported":false},"disabled":{"supported":false}}},"effort":{"low":{"supported":true},"high":{"supported":true}}}
}));
for (effort, expected) in [
("none", Some("low")),
("minimal", Some("low")),
("medium", Some("low")),
("high", Some("high")),
("max", Some("high")),
("auto", None),
] {
let source = object(
json!({"model":"arbitrary-alias","input":"hello","max_output_tokens":1000,"temperature":0.3,"top_p":0.9,"reasoning":{"effort":effort},"text":{"format":{"type":"json_schema","schema":{"type":"object"}}}}),
);
let converted = responses_to_messages_request(&source, &capabilities).unwrap();
assert_eq!(converted["thinking"], json!({"type":"adaptive"}));
assert_eq!(converted["max_tokens"], 512);
assert!(!converted.contains_key("temperature"));
assert!(!converted.contains_key("top_p"));
assert_eq!(
converted["output_config"]
.get("effort")
.and_then(Value::as_str),
expected
);
assert_eq!(
converted["output_config"]["format"]["schema"]["type"],
"object"
);
}
}
#[test]
fn forced_tools_respect_manual_and_adaptive_thinking_modes() {
let source = object(
json!({"model":"alias","input":"hello","tools":[{"type":"function","name":"echo","parameters":{"type":"object"}}],"reasoning":{"effort":"high"},"tool_choice":{"type":"function","name":"echo"},"parallel_tool_calls":false}),
);
let converted = responses_to_messages_request(&source, &Default::default()).unwrap();
assert_eq!(
converted["tool_choice"],
json!({"type":"tool","name":"echo","disable_parallel_tool_use":true})
);
assert_eq!(converted["thinking"], json!({"type":"disabled"}));
let adaptive = gateway_protocol::anthropic::MessagesModelCapabilities {
adaptive_thinking: Some(true),
disabled_thinking: Some(false),
..Default::default()
};
let converted = responses_to_messages_request(&source, &adaptive).unwrap();
assert_eq!(
converted["tool_choice"],
json!({"type":"auto","disable_parallel_tool_use":true})
);
assert_eq!(converted["thinking"], json!({"type":"adaptive"}));
assert_eq!(converted["output_config"]["effort"], "high");
}
#[test]
fn serial_tools_get_default_choice_but_none_has_no_parallel_option() {
for (choice, expected) in [
(
None,
json!({"type":"auto","disable_parallel_tool_use":true}),
),
(Some(json!("none")), json!({"type":"none"})),
(
Some(json!("required")),
json!({"type":"any","disable_parallel_tool_use":true}),
),
] {
let mut source = object(
json!({"input":"hello","tools":[{"type":"function","name":"echo"}],"parallel_tool_calls":false}),
);
if let Some(choice) = choice {
source.insert("tool_choice".into(), choice);
}
assert_eq!(
responses_to_messages_request(&source, &Default::default()).unwrap()["tool_choice"],
expected
);
source.remove("tools");
assert!(
!responses_to_messages_request(&source, &Default::default())
.unwrap()
.contains_key("tool_choice")
);
}
}
#[test]
fn service_tier_and_speed_map_by_protocol_meaning() {
for (tier, speed, target_tier) in [
("priority", Some("fast"), None),
("default", None, Some("standard_only")),
("auto", None, Some("auto")),
("flex", None, None),
] {
let converted = responses_to_messages_request(
&object(json!({"input":"hello","service_tier":tier})),
&Default::default(),
)
.unwrap();
assert_eq!(converted.get("speed").and_then(Value::as_str), speed);
assert_eq!(
converted.get("service_tier").and_then(Value::as_str),
target_tier
);
}
for (tier, speed, expected) in [
("auto", None, "auto"),
("standard_only", None, "default"),
("standard_only", Some("fast"), "priority"),
] {
let mut source = object(
json!({"model":"alias","max_tokens":1000,"messages":[{"role":"user","content":"hello"}],"service_tier":tier}),
);
if let Some(speed) = speed {
source.insert("speed".into(), json!(speed));
}
assert_eq!(
messages_to_responses_request(&source).unwrap()["service_tier"],
expected
);
}
}
#[test]
fn hosted_search_never_widens_network_access() {
for access in [json!(false), json!("cached"), json!("indexed")] {
let req = object(
json!({"tools":[{"type":"web_search","name":"web_search","external_web_access":access}]}),
);
assert!(
!responses_to_messages_request(&req, &Default::default())
.unwrap()
.contains_key("tools")
);
}
let limited = object(
json!({"model":"m","max_tokens":12,"messages":[{"role":"user","content":"hi"}],"tools":[{"type":"web_search_20250305","name":"web_search","max_uses":1}]}),
);
assert!(messages_to_responses_request(&limited).is_err());
assert!(messages_to_responses_count_request(&limited).is_ok());
for field in ["allowed_domains", "blocked_domains"] {
let req = object(
json!({"model":"m","max_tokens":12,"messages":[{"role":"user","content":"hi"}],"tools":[{"type":"web_search_20250305","name":"web_search",field:["docs.example"]}]}),
);
let converted = messages_to_responses_request(&req).unwrap();
assert_eq!(
converted["tools"][0]["filters"][field],
json!(["docs.example"])
);
let back = responses_to_messages_request(&converted, &Default::default()).unwrap();
assert_eq!(back["tools"], req["tools"]);
}
}
#[test]
fn allowed_tools_limit_current_turn_without_renaming_history() {
let mut req = object(
json!({"tools":[{"type":"function","name":"delete"},{"type":"namespace","name":"fs","tools":[{"type":"function","name":"read"}]},{"type":"custom","name":"read"},{"type":"web_search"}],"tool_choice":{"type":"allowed_tools","mode":"required","tools":[{"type":"function","name":"read","namespace":"fs"}]},"parallel_tool_calls":false,"input":[{"type":"function_call","call_id":"c","name":"delete","arguments":"{}"},{"type":"function_call_output","call_id":"c","output":"done"}]}),
);
let converted = responses_to_messages_request(&req, &Default::default()).unwrap();
assert_eq!(converted["tools"].as_array().unwrap().len(), 1);
assert_eq!(converted["tools"][0]["name"], "fs__read");
assert_eq!(
converted["tool_choice"],
json!({"type":"any","disable_parallel_tool_use":true})
);
assert_eq!(converted["messages"][0]["content"][0]["name"], "delete");
req["tool_choice"]["tools"] = json!([{"type":"web_search"}]);
req["tool_choice"]["mode"] = json!("auto");
let converted = responses_to_messages_request(&req, &Default::default()).unwrap();
assert_eq!(
converted["tools"],
json!([{"type":"web_search_20250305","name":"web_search"}])
);
req["tool_choice"]["tools"] = json!([{"type":"function","name":"missing"}]);
assert!(responses_to_messages_request(&req, &Default::default()).is_err());
}
#[test]
fn tool_result_continuation_without_thinking_keeps_the_current_mode() {
let mut req = object(json!({
"tools":[{"type":"function","name":"read"}],
"input":[{"type":"function_call","call_id":"c","name":"read","arguments":"{}"},
{"type":"function_call_output","call_id":"c","output":"ok"}]
}));
let convert =
|req: &Map<String, Value>| responses_to_messages_request(req, &Default::default()).unwrap();
assert_eq!(convert(&req)["thinking"], json!({"type":"disabled"}));
req.insert("reasoning".into(), json!({"effort":"high"}));
assert_eq!(convert(&req)["thinking"]["type"], "enabled");
req.remove("reasoning");
req["input"]
.as_array_mut()
.unwrap()
.push(json!({"role":"user","content":"new question"}));
assert!(!convert(&req).contains_key("thinking"));
}
@@ -0,0 +1,50 @@
//! 验证完整响应的停止语义与错误终态
use gateway_protocol::anthropic::{messages_to_responses_response, responses_to_messages_response};
use serde_json::{Map, json};
#[test]
fn stop_reasons_distinguish_incomplete_refusal_pause_and_tools() {
for (reason, status, incomplete) in [
("max_tokens", "incomplete", Some("max_output_tokens")),
(
"model_context_window_exceeded",
"incomplete",
Some("max_output_tokens"),
),
("refusal", "incomplete", Some("content_filter")),
("pause_turn", "completed", None),
("tool_use", "completed", None),
("end_turn", "completed", None),
] {
let converted = messages_to_responses_response(
&json!({"id":"m1","content":[],"stop_reason":reason,"usage":{}}),
&Map::new(),
)
.expect("停止转换");
assert_eq!(converted["status"], status);
assert_eq!(
converted
.pointer("/incomplete_details/reason")
.and_then(|v| v.as_str()),
incomplete
);
assert_eq!(
converted.get("end_turn").and_then(|v| v.as_bool()),
(reason == "pause_turn").then_some(false)
);
}
}
#[test]
fn upstream_errors_remain_errors_in_both_directions() {
let response = messages_to_responses_response(
&json!({"type":"error","error":{"type":"overloaded_error","message":"Busy."}}),
&Map::new(),
)
.expect("错误转换");
assert_eq!(response["status"], "failed");
let message = responses_to_messages_response(&response, &Map::new()).expect("错误回转");
assert_eq!(message["type"], "error");
assert_eq!(message["error"]["message"], "Busy.");
}
@@ -0,0 +1,57 @@
//! 验证聚合器的未知字段、累计用量与截断检查
use gateway_protocol::anthropic::MessagesAccumulator;
use serde_json::json;
#[test]
fn accumulator_preserves_native_fields_and_merges_usage() {
let mut stream = MessagesAccumulator::default();
for event in [
json!({"type":"message_start","message":{"id":"m1","type":"message","content":[],"future_field":{"enabled":true},"usage":{"input_tokens":4,"cache_read_input_tokens":5}}}),
json!({"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"c1","name":"lookup","input":{},"future_tool_field":7}}),
json!({"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"{\"q\":"}}),
json!({"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"\"hi\"}"}}),
json!({"type":"content_block_stop","index":0}),
json!({"type":"message_delta","delta":{"stop_reason":"tool_use","stop_sequence":null},"usage":{"output_tokens":9}}),
] {
assert!(stream.push(&event).expect("聚合事件").is_none());
}
let message = stream
.push(&json!({"type":"message_stop"}))
.expect("正常结束")
.expect("完整消息");
stream.finish().expect("终态完整");
assert_eq!(message["future_field"]["enabled"], true);
assert_eq!(message["content"][0]["future_tool_field"], 7);
assert_eq!(message["content"][0]["input"], json!({"q":"hi"}));
assert_eq!(
message["usage"],
json!({"input_tokens":4,"cache_read_input_tokens":5,"output_tokens":9})
);
}
#[test]
fn explicit_errors_finish_but_transport_truncation_does_not() {
let mut stream = MessagesAccumulator::default();
assert!(stream.finish().is_err());
let error = json!({"type":"error","error":{"type":"api_error","message":"Interrupted."}});
assert_eq!(stream.push(&error).expect("错误终态"), Some(error));
assert!(stream.finish().is_ok());
assert!(stream.push(&json!({"type":"message_stop"})).is_err());
}
#[test]
fn native_json_rejects_unparseable_tool_input_at_message_stop() {
let mut stream = MessagesAccumulator::default();
for event in [
json!({"type":"message_start","message":{"content":[]}}),
json!({"type":"content_block_start","index":0,"content_block":{"type":"tool_use","input":{}}}),
json!({"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"{"}}),
json!({"type":"content_block_stop","index":0}),
json!({"type":"message_delta","delta":{"stop_reason":"max_tokens"}}),
] {
stream.push(&event).expect("输入分片");
}
assert!(stream.finish().is_err());
assert!(stream.push(&json!({"type":"message_stop"})).is_err());
}
@@ -0,0 +1,4 @@
//! SSE 增量转换和聚合的测试入口
mod accumulator;
mod translation;
@@ -0,0 +1,292 @@
//! 验证双向增量输出与完整 JSON 语义一致
use gateway_protocol::anthropic::{
MessagesAccumulator, MessagesToResponsesStream, ResponsesToMessagesStream,
messages_to_responses_response, responses_to_messages_response,
};
use serde_json::{Map, Value, json};
#[test]
fn messages_stream_emits_live_text_and_final_cache_usage() {
let request = Map::from_iter([("model".into(), json!("alias"))]);
let mut stream = MessagesToResponsesStream::new(&request);
let mut events = Vec::new();
for event in [
json!({"type":"message_start","message":{"id":"m1","model":"upstream","content":[],"usage":{"input_tokens":4,"output_tokens":0,"cache_read_input_tokens":8}}}),
json!({"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}),
json!({"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"hello"}}),
json!({"type":"content_block_stop","index":0}),
json!({"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":3}}),
json!({"type":"message_stop"}),
] {
events.extend(stream.push(&event).expect("转换事件"));
}
stream.finish().expect("终态完整");
assert!(events.iter().any(|event|event["type"]=="response.output_text.delta" && event["delta"]=="hello"));
for (index, event) in events.iter().enumerate() {
assert_eq!(event["sequence_number"], index);
}
let final_response = &events.last().expect("结束事件")["response"];
let expected=messages_to_responses_response(&json!({"id":"m1","content":[{"type":"text","text":"hello"}],"stop_reason":"end_turn","usage":{"input_tokens":4,"output_tokens":3,"cache_read_input_tokens":8}}),&request).expect("JSON响应");
assert_eq!(final_response, &expected);
}
#[test]
fn custom_tools_use_custom_events_and_restore_string_input() {
let request = json!({"model":"alias","tools":[{"type":"custom","name":"shell"}]})
.as_object()
.expect("请求对象")
.clone();
let mut stream = MessagesToResponsesStream::new(&request);
let mut events = Vec::new();
for event in [
json!({"type":"message_start","message":{"id":"m1","content":[],"usage":{}}}),
json!({"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"c1","name":"shell","input":{}}}),
json!({"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"{\"input\":\"pwd\"}"}}),
json!({"type":"content_block_stop","index":0}),
json!({"type":"message_delta","delta":{"stop_reason":"tool_use"},"usage":{}}),
json!({"type":"message_stop"}),
] {
events.extend(stream.push(&event).expect("工具转换"));
}
assert!(events.iter().any(
|event| event["type"] == "response.custom_tool_call_input.delta" && event["delta"] == "pwd"
));
assert!(
!events
.iter()
.any(|event| event["type"] == "response.function_call_arguments.delta")
);
assert_eq!(
events.last().expect("结束事件")["response"]["output"][0]["input"],
"pwd"
);
}
#[test]
fn responses_thinking_uses_final_signature_without_replaying_text() {
let request = Map::from_iter([("model".into(), json!("alias"))]);
let item = json!({"type":"reasoning","id":"reason1","summary":[{"type":"summary_text","text":"thought"}],"encrypted_content":"gAAAAsigned"});
let response = json!({"id":"r1","model":"upstream","status":"completed","output":[item],"usage":{"input_tokens":12,"output_tokens":4,"input_tokens_details":{"cached_tokens":2}}});
let mut stream = ResponsesToMessagesStream::new(&request);
let mut events = Vec::new();
for event in [
json!({"type":"response.created","response":{"id":"r1"}}),
json!({"type":"response.output_item.added","output_index":0,"item":{"type":"reasoning","id":"reason1","summary":[]}}),
json!({"type":"response.reasoning_summary_text.delta","output_index":0,"summary_index":0,"delta":"thought"}),
json!({"type":"response.output_item.done","output_index":0,"item":item}),
json!({"type":"response.completed","response":response}),
] {
events.extend(stream.push(&event).expect("思考转换"));
}
stream.finish().expect("终态完整");
assert_eq!(
events
.iter()
.filter(|event| event.pointer("/delta/type") == Some(&json!("thinking_delta")))
.count(),
1
);
assert_eq!(
events
.iter()
.filter(|event| event.pointer("/delta/type") == Some(&json!("signature_delta")))
.count(),
1
);
let mut accumulator = MessagesAccumulator::default();
let mut final_message = None;
for event in events {
if let Some(message) = accumulator.push(&event).expect("聚合转换流") {
final_message = Some(message);
}
}
assert_eq!(
final_message.expect("终态消息"),
responses_to_messages_response(&response, &request).expect("完整响应转换")
);
}
#[test]
fn responses_json_only_terminal_synthesizes_content_and_stops() {
let request = Map::from_iter([("model".into(), json!("alias"))]);
let response = json!({"id":"r1","status":"incomplete","incomplete_details":{"reason":"max_output_tokens"},"output":[{"type":"message","role":"assistant","content":[{"type":"output_text","text":"partial"}]}],"usage":{"input_tokens":2,"output_tokens":1}});
let mut stream = ResponsesToMessagesStream::new(&request);
let events = stream
.push(&json!({"type":"response.incomplete","response":response}))
.expect("完整终态");
let mut accumulator = MessagesAccumulator::default();
let mut final_message = Value::Null;
for event in events {
if let Some(message) = accumulator.push(&event).expect("聚合消息") {
final_message = message;
}
}
assert_eq!(final_message["content"][0]["text"], "partial");
assert_eq!(final_message["stop_reason"], "max_tokens");
stream.finish().expect("不完整生成也是完整协议终态");
}
#[test]
fn explicit_errors_and_truncated_streams_are_distinct() {
let mut to_messages = ResponsesToMessagesStream::new(&Map::new());
assert!(to_messages.finish().is_err());
let events=to_messages.push(&json!({"type":"response.failed","response":{"error":{"type":"server_error","message":"Failed."}}})).expect("错误转换");
assert_eq!(events[0]["type"], "error");
assert!(to_messages.finish().is_ok());
let mut to_responses = MessagesToResponsesStream::new(&Map::new());
assert!(to_responses.finish().is_err());
let events = to_responses
.push(&json!({"type":"error","error":{"type":"overloaded_error","message":"Busy."}}))
.expect("错误转换");
assert_eq!(events[0]["type"], "response.failed");
assert!(to_responses.finish().is_ok());
}
#[test]
fn interrupted_function_arguments_wait_for_stop_reason_and_keep_raw_input() {
for reason in ["max_tokens", "model_context_window_exceeded", "tool_use"] {
let mut stream = MessagesToResponsesStream::new(&Map::new());
let mut events = Vec::new();
let arguments = "{\n \"value\": \"未完成";
for event in [
json!({"type":"message_start","message":{"id":"m1","content":[],"usage":{"input_tokens":7}}}),
json!({"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"c1","name":"lookup","input":{}}}),
json!({"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":arguments}}),
json!({"type":"content_block_stop","index":0}),
json!({"type":"content_block_start","index":1,"content_block":{"type":"text","text":"partial answer"}}),
json!({"type":"content_block_stop","index":1}),
json!({"type":"message_delta","delta":{"stop_reason":reason},"usage":{"output_tokens":5}}),
] {
events.extend(stream.push(&event).expect("等待消息终态"));
}
assert!(stream.finish().is_err());
assert!(
!events
.iter()
.any(|event| event["type"] == "response.function_call_arguments.done")
);
events.extend(
stream
.push(&json!({"type":"message_stop"}))
.expect("保留上游终态"),
);
stream.finish().expect("工具输入不影响协议终态");
let final_event = events.last().unwrap();
let expected_status = if reason == "tool_use" {
"completed"
} else {
"incomplete"
};
assert_eq!(final_event["type"], format!("response.{expected_status}"));
if reason != "tool_use" {
assert_eq!(
final_event["response"]["incomplete_details"]["reason"],
"max_output_tokens"
);
}
assert_eq!(final_event["response"]["output"][0]["arguments"], arguments);
assert_eq!(
final_event["response"]["output"][0]["status"],
expected_status
);
assert_eq!(
final_event["response"]["output"][1]["content"][0]["text"],
"partial answer"
);
assert_eq!(final_event["response"]["usage"]["output_tokens"], 5);
assert!(events.iter().any(|event| event["type"]
== "response.function_call_arguments.done"
&& event["arguments"] == arguments));
for (index, event) in events.iter().enumerate() {
assert_eq!(event["sequence_number"], index);
}
}
}
#[test]
fn incomplete_custom_input_preserves_decoded_prefix_and_unfinished_escapes() {
let request = json!({"tools":[{"type":"custom","name":"shell"}]})
.as_object()
.unwrap()
.clone();
for (arguments, expected) in [
(
r#"{"input":"printf\n值\uD83D\uDE00tail\"#,
"printf\n值😀tail\\",
),
(r#"{"input":"x\uD83D\u"#, r"x\uD83D\u"),
(r#"{"input":"finished""#, "finished"),
("{", "{"),
] {
let mut stream = MessagesToResponsesStream::new(&request);
let mut events = Vec::new();
for event in [
json!({"type":"message_start","message":{"id":"m1","content":[],"usage":{}}}),
json!({"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"c1","name":"shell","input":{}}}),
json!({"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":arguments}}),
json!({"type":"content_block_stop","index":0}),
json!({"type":"message_delta","delta":{"stop_reason":"max_tokens"},"usage":{}}),
json!({"type":"message_stop"}),
] {
events.extend(stream.push(&event).expect("截断 custom 工具"));
}
let item = &events.last().unwrap()["response"]["output"][0];
assert_eq!(item["type"], "custom_tool_call");
assert_eq!(item["status"], "incomplete");
assert_eq!(item["input"], expected);
assert!(events.iter().any(|event| event["type"]
== "response.custom_tool_call_input.delta"
&& event["delta"] == expected));
}
}
#[test]
fn complete_function_arguments_keep_the_original_serialization() {
let arguments = "{ \"number\": 1.00, \"text\": \"\\u0061\" }";
let mut stream = MessagesToResponsesStream::new(&Map::new());
let mut events = Vec::new();
for event in [
json!({"type":"message_start","message":{"id":"m1","content":[],"usage":{}}}),
json!({"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"c1","name":"lookup","input":{}}}),
json!({"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":arguments}}),
json!({"type":"content_block_stop","index":0}),
json!({"type":"message_delta","delta":{"stop_reason":"tool_use"},"usage":{}}),
json!({"type":"message_stop"}),
] {
events.extend(stream.push(&event).unwrap());
}
assert!(events.iter().any(
|event| event["type"] == "response.function_call_arguments.done"
&& event["arguments"] == arguments
));
assert_eq!(
events.last().unwrap()["response"]["output"][0]["arguments"],
arguments
);
}
#[test]
fn terminal_uses_delivered_tool_when_output_is_not_repeated() {
for (terminal, expected) in [
(json!({"id":"r","status":"completed"}), "tool_use"),
(
json!({"id":"r","status":"completed","output":[]}),
"tool_use",
),
(
json!({"id":"r","status":"incomplete","incomplete_details":{"reason":"max_output_tokens"}}),
"max_tokens",
),
] {
let mut stream = ResponsesToMessagesStream::new(&Map::new());
let done=stream.push(&json!({"type":"response.output_item.done","output_index":0,"item":{"type":"function_call","call_id":"c","name":"read","arguments":"{}"}})).unwrap();
assert!(
done.iter()
.any(|e| e.pointer("/content_block/type") == Some(&json!("tool_use")))
);
let events=stream.push(&json!({"type":format!("response.{}",terminal["status"].as_str().unwrap()),"response":terminal})).unwrap();
assert_eq!(events[0]["delta"]["stop_reason"], expected);
assert_eq!(events[1]["type"], "message_stop");
}
}
@@ -0,0 +1,27 @@
//! 验证 Messages 缓存用量合并与统一输入量
use gateway_protocol::anthropic::{MessageUsage, messages_to_responses_response};
use gateway_protocol::openai::events::{billable_usage_is_complete, extract_usage};
use serde_json::{Map, json};
#[test]
fn usage_deltas_replace_counters_and_keep_cache_facts() {
let mut usage = MessageUsage::from_value(
&json!({"input_tokens":4,"output_tokens":1,"cache_read_input_tokens":20,"cache_creation_input_tokens":10}),
);
usage.merge(&json!({"output_tokens":9}));
assert_eq!(usage.total_input_tokens(), Some(34));
assert_eq!(usage.output_tokens, Some(9));
}
#[test]
fn converted_usage_matches_canonical_cache_write_accounting() {
let converted=messages_to_responses_response(&json!({"id":"m1","content":[],"stop_reason":"end_turn","usage":{"input_tokens":4,"output_tokens":9,"cache_read_input_tokens":20,"cache_creation_input_tokens":10}}),&Map::new()).expect("用量转换");
assert!(converted["usage"].get("output_tokens_details").is_none());
let usage = extract_usage(&converted).expect("提取统一用量");
assert_eq!(usage.input_tokens, 34);
assert_eq!(usage.cache_write_input_tokens, 10);
assert_eq!(usage.cached_input_tokens, 20);
assert_eq!(usage.total_tokens, 43);
assert!(billable_usage_is_complete(&converted, usage));
}
@@ -1,3 +1,5 @@
//! 共享协议解析与编码的测试入口
mod anthropic;
mod openai;
mod request;
@@ -0,0 +1,22 @@
//! 验证不同协议的共享请求事实
use gateway_protocol::request::request_facts;
use serde_json::json;
#[test]
fn messages_facts_include_images_inside_tool_results() {
let body = json!({"max_tokens":0,"messages":[{"role":"user","content":[{"type":"tool_result","content":[{"type":"image","source":{"type":"url","url":"https://example.com/image.png"}}]}]}],"tools":[{"name":"search"}],"thinking":{"type":"adaptive"},"output_config":{"format":{"type":"json_schema","schema":{"type":"object"}}}});
let facts = request_facts("anthropic", body.as_object().expect("请求正文"));
assert_eq!(facts.max_output_tokens, Some(0));
assert!(facts.vision && facts.tools && facts.reasoning && facts.json_schema);
assert!(!facts.native_continuation);
}
#[test]
fn responses_facts_keep_native_continuation_separate_from_history() {
let body = json!({"max_output_tokens":123,"input":[],"previous_response_id":"resp_1"});
let facts = request_facts("openai", body.as_object().expect("请求正文"));
assert_eq!(facts.max_output_tokens, Some(123));
assert!(facts.native_continuation);
assert!(!facts.tools && !facts.vision && !facts.reasoning && !facts.json_schema);
}
@@ -23,6 +23,7 @@ gateway-core = { path = "../../gateway-core" }
gateway-protocol = { path = "../../gateway-protocol" }
getrandom = "0.4.3"
hex = "0.4.3"
lru = "0.18.3"
# TLS 依赖以官方 Core 锁文件为基线,安全补丁经握手特征核验后精确固定
# 包含用于约束传递依赖的直接声明
# hyper-util 固定到包含 SOCKS IPv6 修复的正式版
@@ -51,6 +52,7 @@ sha2 = "0.11.0"
subtle = "2.6.1"
tar = { version = "0.4.46", default-features = false }
thiserror = "2.0.18"
tiktoken-rs = "=0.12.1"
tokio = { version = "=1.53.3", default-features = false, features = ["fs", "macros", "rt", "sync", "time"] }
tokio-rustls = { version = "=0.26.4", default-features = false }
tokio-util = { version = "0.7.18", features = ["rt"] }
@@ -0,0 +1,44 @@
//! 跨协议生成的 Messages fast 请求补充协议头,不改写原生 Messages 请求
use bytes::Bytes;
use gateway_core::engine::middleware::MiddlewareHeader;
use reqwest::header::HeaderMap;
pub(crate) fn add_translated_fast_beta(headers: &mut Vec<MiddlewareHeader>, forwarded: &HeaderMap) {
const BETA: &[u8] = b"fast-mode-2026-02-01";
let values = if headers
.iter()
.any(|header| header.name().eq_ignore_ascii_case("anthropic-beta"))
{
headers
.iter()
.filter(|header| header.name().eq_ignore_ascii_case("anthropic-beta"))
.map(|header| header.value().as_ref())
.collect::<Vec<_>>()
} else {
forwarded
.get_all("anthropic-beta")
.iter()
.map(|value| value.as_bytes())
.collect()
};
let mut joined = Vec::new();
for value in values {
if !joined.is_empty() {
joined.push(b',');
}
joined.extend_from_slice(value);
}
if !joined
.split(|byte| *byte == b',')
.any(|token| token.trim_ascii() == BETA)
{
if !joined.is_empty() {
joined.push(b',');
}
joined.extend_from_slice(BETA);
}
// 出站中间件头优先于透传头,合并后一次写入,保留调用方已有 beta
headers.retain(|header| !header.name().eq_ignore_ascii_case("anthropic-beta"));
headers.push(MiddlewareHeader::new("anthropic-beta", Bytes::from(joined)));
}
@@ -2,6 +2,7 @@
//! 规则只处理请求事实;身份保护、会话状态和连接生命周期由对应职责模块维护
mod headers;
mod messages;
mod request;
mod search_history;
mod search_tools;
@@ -10,6 +11,7 @@ use gateway_core::engine::middleware::MiddlewareHeader;
use serde_json::{Map, Value};
pub(crate) use headers::is_non_codex_request_header;
pub(crate) use messages::add_translated_fast_beta;
pub(crate) use request::normalize_codex_request_body;
pub(crate) use search_tools::declares_hosted_search;
@@ -35,6 +35,13 @@ pub(super) fn normalize_non_codex_request_body(body: &mut Map<String, Value>) {
}
fn normalize_codex_oauth_options(body: &mut Map<String, Value>) {
// Codex Core 省略默认档位,OAuth 不接受公开 API 的 auto/default 字面值
if matches!(
body.get("service_tier").and_then(Value::as_str),
Some("auto" | "default")
) {
body.shift_remove("service_tier");
}
// Codex OAuth 拒绝这些客户端选项,即使采样参数取默认值
for field in [
"top_p",
@@ -24,7 +24,7 @@ use serde::Serialize;
use serde_json::Value;
use thiserror::Error;
use super::api_key::{ApiKeyCredentialData, CODEX_AUTHENTICATION_KIND_API_KEY};
use super::api_key::{ApiKeyCredentialData, ApiKeyProtocol, CODEX_AUTHENTICATION_KIND_API_KEY};
use super::codec::CodexCredentialCodec;
use super::recovery_log::{CodexOAuthRecoveryOperation, record_oauth_recovery};
use super::token_client::{
@@ -256,6 +256,7 @@ struct CodexCprApiKeyExportAccount {
provider: &'static str,
authentication_kind: &'static str,
base_url: String,
protocol: ApiKeyProtocol,
api_key: String,
transport: ResponsesTransport,
}
@@ -433,6 +434,7 @@ impl CodexCredentialAdmin {
#[serde(deny_unknown_fields)]
struct Rotation {
base_url: String,
protocol: Option<ApiKeyProtocol>,
transport: ResponsesTransport,
api_key: Option<String>,
}
@@ -445,6 +447,9 @@ impl CodexCredentialAdmin {
return Err(CodexCredentialAdminError::InvalidCredential);
};
data.base_url = rotation.base_url;
if let Some(protocol) = rotation.protocol {
data.protocol = protocol;
}
data.transport = rotation.transport;
if let Some(api_key) = rotation.api_key {
data.api_key = api_key;
@@ -673,6 +678,7 @@ impl CodexCredentialAdmin {
provider: PROVIDER_NAME,
authentication_kind: CODEX_AUTHENTICATION_KIND_API_KEY,
base_url: data.base_url,
protocol: data.protocol,
api_key: data.api_key,
transport: data.transport,
})
@@ -1453,6 +1459,12 @@ fn parse_api_key_import(value: &Value) -> Result<ApiKeyCredentialData, CodexCred
schema_version: 1,
installation_id: uuid::Uuid::new_v4().to_string(),
base_url,
protocol: credentials
.get("protocol")
.map(|value| serde_json::from_value(value.clone()))
.transpose()
.map_err(|_| CodexCredentialAdminError::InvalidInput)?
.unwrap_or_default(),
api_key: first_string(credentials, &["api_key"])
.ok_or(CodexCredentialAdminError::InvalidCredential)?,
transport: credentials
@@ -1,4 +1,4 @@
//! API Key 账号的凭据合同;地址与传输策略随凭据 revision 一起更新
//! API Key 账号的凭据合同;地址、协议与传输策略随凭据 revision 一起更新
use std::fmt;
@@ -9,12 +9,23 @@ pub(super) use crate::CODEX_AUTHENTICATION_KIND_API_KEY;
use super::types::ResponsesTransport;
/// API Key 账号采用的上游推理协议
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ApiKeyProtocol {
#[default]
Responses,
Messages,
}
/// 可在管理端展示的上游设置,不包含密钥
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ApiKeyConfiguration {
pub base_url: String,
#[serde(default)]
pub protocol: ApiKeyProtocol,
#[serde(default)]
pub transport: ResponsesTransport,
}
@@ -23,6 +34,8 @@ impl ApiKeyConfiguration {
self.base_url.len() <= 2048
&& !self.base_url.chars().any(char::is_control)
&& crate::transport::parse_upstream_base_url(&self.base_url).is_some()
&& (self.protocol == ApiKeyProtocol::Responses
|| self.transport == ResponsesTransport::Http)
}
}
@@ -34,6 +47,8 @@ pub struct ApiKeyCredentialData {
pub api_key: String,
pub base_url: String,
#[serde(default)]
pub protocol: ApiKeyProtocol,
#[serde(default)]
pub transport: ResponsesTransport,
}
@@ -41,6 +56,7 @@ impl ApiKeyCredentialData {
pub fn configuration(&self) -> ApiKeyConfiguration {
ApiKeyConfiguration {
base_url: self.base_url.clone(),
protocol: self.protocol,
transport: self.transport,
}
}
@@ -39,6 +39,7 @@ const MAX_CLIENT_CATALOGS: usize = 32;
const MAX_CLIENT_CATALOG_CACHE_BYTES: usize = 32 * 1024 * 1024;
const MODEL_CATALOG_TIMEOUT: Duration = Duration::from_secs(15);
const MAX_CONCURRENT_API_CATALOGS: usize = 4;
const CAPABILITY_LOOKUP_BUDGET: Duration = Duration::from_millis(500);
const CLIENT_CATALOG_ERROR_TTL: Duration = Duration::from_secs(5);
/// OpenAI 以套餐划分的模型目录作用域
@@ -217,11 +218,12 @@ struct ClientCatalogKey {
}
type ClientCatalogResult = Result<Vec<ProviderModelDescriptor>, CodexCredentialCatalogError>;
type AccountModelsResult = Result<Arc<[CodexCatalogModel]>, CodexCredentialCatalogError>;
struct CachedClientCatalog {
// 负缓存从请求结束计时,不能让一次慢失败耗尽后续请求的退避窗口
completed_at: Instant,
result: ClientCatalogResult,
result: AccountModelsResult,
}
impl CachedClientCatalog {
@@ -229,10 +231,7 @@ impl CachedClientCatalog {
self.result.as_ref().map_or(0, |models| {
models
.iter()
.map(|model| match &model.content {
ProviderModelContent::Native(payload) => payload.body().len(),
ProviderModelContent::Adapted(_) => 0,
})
.map(|model| model.document().body().len())
.sum()
})
}
@@ -283,6 +282,7 @@ pub struct CodexCredentialCatalogService {
plan_catalog_cache: Arc<dyn ProviderCatalogCachePort>,
cache: Arc<RwLock<CatalogCacheState>>,
client_catalogs: Arc<Mutex<Vec<ClientCatalogEntry>>>,
background_capabilities: Arc<tokio::sync::Semaphore>,
etags: Arc<Mutex<CatalogEtagState>>,
etag_notification: Arc<Notify>,
}
@@ -303,6 +303,9 @@ impl CodexCredentialCatalogService {
plan_catalog_cache,
cache: Arc::new(RwLock::new(CatalogCacheState::default())),
client_catalogs: Arc::new(Mutex::new(Vec::new())),
background_capabilities: Arc::new(tokio::sync::Semaphore::new(
MAX_CONCURRENT_API_CATALOGS,
)),
etags: Arc::new(Mutex::new(CatalogEtagState::default())),
etag_notification: Arc::new(Notify::new()),
}
@@ -421,17 +424,81 @@ impl CodexCredentialCatalogService {
client_version: &str,
profile: CodexWireProfile,
) -> ClientCatalogResult {
self.cached_account_catalog(account, Some((client_key_id, client_version)), profile)
.await
.map(|models| {
models
.iter()
.map(|model| ProviderModelDescriptor {
model: model.request_model().clone(),
content: if model.document().protocol() == "codex" {
ProviderModelContent::Native(model.document().clone())
} else {
let model_id = model.request_model().as_str();
ProviderModelContent::Adapted(
ModelPresentation::new(Some(model_id.to_owned()), None)
.with_agent_tools(true, false)
.with_hidden(is_specialized_api_model(model_id)),
)
},
})
.collect()
})
}
/// 在既有账号、revision 隔离及负缓存边界内读取 Messages 转换能力
pub(crate) async fn messages_model_capabilities(
&self,
account: &ProviderAccount,
model: &UpstreamModelId,
) -> Result<
Option<gateway_protocol::anthropic::MessagesModelCapabilities>,
CodexCredentialCatalogError,
> {
let service = self.clone();
let account = account.clone();
let mut lookup = Box::pin(async move {
service
.cached_account_catalog(&account, None, service.profile.snapshot())
.await
});
let models = match tokio::time::timeout(CAPABILITY_LOOKUP_BUDGET, &mut lookup).await {
Ok(result) => result?,
Err(_) => {
// 目录不阻塞本轮生成;保留同一查询及负缓存,慢上游完成后供后续轮次使用
if let Ok(permit) = self.background_capabilities.clone().try_acquire_owned() {
tokio::spawn(async move {
let _permit = permit;
let _ = lookup.await;
});
}
return Ok(None);
}
};
Ok(models
.iter()
.find(|entry| entry.request_model() == model)
.and_then(CodexCatalogModel::messages_capabilities)
.cloned())
}
async fn cached_account_catalog(
&self,
account: &ProviderAccount,
identity: Option<(&ClientApiKeyId, &str)>,
profile: CodexWireProfile,
) -> AccountModelsResult {
let key = ClientCatalogKey {
// 无种子时沿用账号级目录缓存,启用后按 Key 隔离出站身份
client_key_id: profile
.installation_seed
.as_ref()
.map(|_| client_key_id.clone()),
.and(identity.map(|(key, _)| key.clone())),
account_id: account.id().clone(),
revision: account.revision(),
plan: account.plan_type().map(str::to_owned),
upstream_account_id: account.upstream_account_id().map(str::to_owned),
client_version: client_version.to_owned(),
client_version: identity.map_or("", |(_, version)| version).to_owned(),
profile: profile.clone(),
};
let value = {
@@ -469,27 +536,9 @@ impl CodexCredentialCatalogService {
CodexWireProfileState::new(profile),
);
let result = self
.fetch_account_models(&client, account, Some((client_key_id, client_version)))
.fetch_account_models(&client, account, identity)
.await
.map(|fetched| {
fetched
.models
.into_iter()
.map(|model| ProviderModelDescriptor {
model: model.request_model().clone(),
content: if model.document().protocol() == "codex" {
ProviderModelContent::Native(model.document().clone())
} else {
let model_id = model.request_model().as_str();
ProviderModelContent::Adapted(
ModelPresentation::new(Some(model_id.to_owned()), None)
.with_agent_tools(true, false)
.with_hidden(is_specialized_api_model(model_id)),
)
},
})
.collect()
});
.map(|fetched| Arc::from(fetched.models));
CachedClientCatalog {
completed_at: Instant::now(),
result,
@@ -844,12 +893,18 @@ impl CodexCredentialCatalogService {
.authentication
.authorization_header()
.map_err(|_| CodexCredentialCatalogError::InvalidCredentialData)?;
let result = client
let mut client = client
.for_account(account)
.map_err(|error| CodexCredentialCatalogError::Upstream {
detail: error.to_string(),
})?
.with_responses_api_base_url(credential.authentication.responses_api_base_url())
.with_responses_api_base_url(credential.authentication.responses_api_base_url());
if let super::CodexRuntimeAuthentication::ApiKey(auth) = &credential.authentication
&& auth.configuration.protocol == super::ApiKeyProtocol::Messages
{
client = client.with_messages_api_base_url(&auth.configuration.base_url);
}
let result = client
.fetch_models_with_context(
CodexRequestContext::auxiliary(
authorization.expose_secret(),
@@ -46,6 +46,13 @@ pub enum CodexRuntimeAuthentication {
}
impl CodexRuntimeAuthentication {
pub(crate) const fn api_protocol(&self) -> super::ApiKeyProtocol {
match self {
Self::ApiKey(auth) => auth.configuration.protocol,
Self::OAuth(_) => super::ApiKeyProtocol::Responses,
}
}
/// 传输只消费公开连接设置,不读取凭据枚举或秘密
pub(crate) fn responses_api_base_url(&self) -> Option<&str> {
match self {
@@ -30,7 +30,9 @@ pub(crate) use types::parse_access_token_expiration;
pub(crate) use crate::CODEX_AUTHENTICATION_KIND_API_KEY;
pub use api_key::{ApiKeyAuthentication, ApiKeyConfiguration, ApiKeyCredentialData};
pub use api_key::{
ApiKeyAuthentication, ApiKeyConfiguration, ApiKeyCredentialData, ApiKeyProtocol,
};
pub use admin::{
CodexCprExportDocument, CodexCredentialAdmin, CodexCredentialAdminError,
@@ -5,6 +5,8 @@ use std::fmt;
use std::sync::{Arc, Mutex};
use std::time::{Duration, SystemTime};
use super::api_key::ApiKeyProtocol;
use gateway_core::account::CredentialRevision;
use gateway_core::error::ErrorSource;
use gateway_core::account::{
@@ -148,6 +150,8 @@ pub struct CodexCredentialSelector {
risk_recovery: Mutex<HashMap<String, RiskRecoveryState>>,
account_feedback: Arc<AccountFeedbackStats>,
scheduling_projection: SchedulingProjectionCache,
endpoint_protocols:
Mutex<lru::LruCache<ProviderAccountId, (CredentialRevision, ApiKeyProtocol)>>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -309,6 +313,9 @@ impl CodexCredentialSelector {
reserved_waiting: ConcurrencyWaitQueue::default(),
account_feedback,
scheduling_projection: SchedulingProjectionCache::default(),
endpoint_protocols: Mutex::new(lru::LruCache::new(
std::num::NonZeroUsize::new(8192).expect("positive capacity"),
)),
}
}
@@ -815,10 +822,29 @@ impl CodexCredentialSelector {
}
native_accounts.insert(account.id().clone());
}
if request.requires_websocket
&& adapter.is_none()
&& pinned_account.as_ref().is_none_or(|id| id == account.id())
{
let endpoint_requires_responses =
!matches!(model, CodexSelectionModel::Requested(_))
&& account.authentication_kind()
== super::CODEX_AUTHENTICATION_KIND_API_KEY;
let check_ws = request.requires_websocket
&& pinned_account.as_ref().is_none_or(|id| id == account.id());
if adapter.is_none() && (endpoint_requires_responses || check_ws) {
// 只复用同 revision 的协议类型;选中后仍以完整账号快照重读凭据
if endpoint_requires_responses && !check_ws {
let cached = self
.endpoint_protocols
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.get(account.id())
.copied()
.filter(|(rev, _)| *rev == account.revision());
if let Some((_, protocol)) = cached {
if protocol == ApiKeyProtocol::Responses {
eligible.push(account);
}
continue;
}
}
let runtime = match self.repository.reload_selected_credential(&account).await {
Ok((_, runtime)) => runtime,
Err(CredentialRepositoryError::RevisionConflict(_)) => {
@@ -841,7 +867,21 @@ impl CodexCredentialSelector {
}
Err(error) => return Err(error.into()),
};
if runtime.transport == super::ResponsesTransport::Http {
if endpoint_requires_responses {
self.endpoint_protocols
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.put(
account.id().clone(),
(account.revision(), runtime.authentication.api_protocol()),
);
}
if (request.requires_websocket
&& runtime.transport == super::ResponsesTransport::Http)
|| (endpoint_requires_responses
&& runtime.authentication.api_protocol()
== super::ApiKeyProtocol::Messages)
{
continue;
}
}
@@ -16,6 +16,7 @@ const OPENAI_ACCOUNT_SCORE_FAILURE_REASONS: &[&str] = &[
"rate_limit_error",
"server_error",
"service_unavailable_error",
"overloaded_error",
];
fn is_openai_account_score_failure_reason(value: &str) -> bool {
@@ -0,0 +1,338 @@
//! 官方 Messages 使用原生计数,其他上游按 CPA 的内容投影做本地 BPE 估算
use std::sync::OnceLock;
use gateway_core::operation::TokenCountRequest;
use super::*;
impl CodexProvider {
pub(in crate::provider) async fn execute_count_tokens(
self: Arc<Self>,
request: &TokenCountRequest,
candidate: &ProviderCandidate,
context: AttemptContext,
) -> Result<ProviderStream, ProviderError> {
let response_protocol = match request.payload().protocol() {
ANTHROPIC_PROTOCOL => ANTHROPIC_PROTOCOL,
"token-count" => "token-count",
_ => return Err(invalid_request()),
};
let model = candidate
.upstream_model()
.cloned()
.ok_or_else(invalid_request)?;
let started = Instant::now();
let lease = self
.selector
.select(&SelectCodexCredential {
upstream_model: model.as_str(),
request_url: &self.responses_url,
attempt: &context,
session_affinity_key: None,
})
.await
.map_err(map_selection_error)?;
let account_selection_wait_ms =
u64::try_from(started.elapsed().as_millis()).unwrap_or(u64::MAX);
let provider_kind = ProviderKind::new(PROVIDER_NAME).map_err(|_| invalid_request())?;
let account_id = lease.account_id().clone();
let terminal_context = context.clone();
context
.execute_middleware(
Operation::CountTokens(request.clone()),
provider_kind,
Some(model.as_str().to_owned()),
account_id,
Box::new(move |operation, headers| {
Box::pin(async move {
let Operation::CountTokens(count) = operation else {
return Err(invalid_request());
};
if count.payload().protocol() != response_protocol {
return Err(invalid_request());
}
let mut body: Map<String, Value> =
serde_json::from_slice(count.payload().body())
.map_err(|_| invalid_request())?;
// 通用 Provider 计数入口的模型来自路径,正文仍使用 Messages 输入合同
body.insert("model".to_owned(), Value::String(model.as_str().to_owned()));
gateway_protocol::anthropic::validate_count_request(&body)
.map_err(|_| invalid_request())?;
let native = match lease.authentication() {
CodexRuntimeAuthentication::ApiKey(auth)
if auth.configuration.protocol == ApiKeyProtocol::Messages =>
{
Url::parse(&auth.configuration.base_url)
.ok()
.is_some_and(|url| {
url.scheme() == "https"
&& url.host_str() == Some("api.anthropic.com")
&& url.port_or_known_default() == Some(443)
})
}
_ => false,
};
if native {
self.messages_stream(
body,
count.payload().context().clone(),
headers,
model,
terminal_context,
lease,
account_selection_wait_ms,
Some(response_protocol),
)
} else {
self.local_count_stream(
body,
model,
terminal_context,
lease,
account_selection_wait_ms,
response_protocol,
)
}
})
}),
)
.await
}
fn local_count_stream(
&self,
body: Map<String, Value>,
model: UpstreamModelId,
context: AttemptContext,
lease: CodexCredentialLease,
account_selection_wait_ms: u64,
response_protocol: &'static str,
) -> Result<ProviderStream, ProviderError> {
let protocol = lease.authentication().api_protocol();
let metadata = ProviderCallMetadata::new(
ProviderKind::new(PROVIDER_NAME).map_err(|_| invalid_request())?,
model.clone(),
lease.account_id().clone(),
UpstreamTransport::new("local_tokenizer").map_err(|_| invalid_request())?,
)
.with_credential_revision(lease.account().revision())
.with_account_snapshot(Some(
gateway_core::account::AccountHistorySnapshot::from_account(lease.account()),
))
.with_selection_observation(ProviderSelectionObservation::new(
account_selection_wait_ms,
lease.capacity_snapshot(),
));
let tokenizer_model = model.as_str().to_ascii_lowercase();
let events: EventStream = Box::pin(async_stream::try_stream! {
// BPE 是 CPU 密集任务,按可用核数限制进程内并发;断开后由工作线程持有名额直到退出
static WORKERS: OnceLock<tokio::sync::Semaphore> = OnceLock::new();
let workers = WORKERS.get_or_init(|| tokio::sync::Semaphore::new(
std::thread::available_parallelism().map_or(1, std::num::NonZeroUsize::get)
));
let permit = tokio::select! {
biased;
_ = context.cancellation().cancelled() => Err(provider_error(ProviderErrorKind::Cancelled, UpstreamSendState::NotSent)),
_ = context.deadline().wait() => Err(provider_error(ProviderErrorKind::Timeout, UpstreamSendState::NotSent)),
result = workers.acquire() => result.map_err(|_| provider_error(ProviderErrorKind::Protocol, UpstreamSendState::NotSent)),
}?;
let cancellation = context.cancellation().clone();
let deadline = context.deadline();
let count = tokio::task::spawn_blocking(move || {
let _permit = permit;
let check = || {
if cancellation.is_cancelled() { Err(provider_error(ProviderErrorKind::Cancelled, UpstreamSendState::NotSent)) }
else if deadline.is_elapsed() { Err(provider_error(ProviderErrorKind::Timeout, UpstreamSendState::NotSent)) }
else { Ok(()) }
};
check()?;
let segments = if protocol == ApiKeyProtocol::Responses {
let translated = gateway_protocol::anthropic::messages_to_responses_count_request(&body).map_err(|_| invalid_request())?;
responses_segments(&translated)
} else {
messages_segments(&body)
};
static O200K: OnceLock<Result<tiktoken_rs::CoreBPE, ()>> = OnceLock::new();
static CL100K: OnceLock<Result<tiktoken_rs::CoreBPE, ()>> = OnceLock::new();
// 与 CPA 的 Codex 映射一致,未知 Responses 模型使用 cl100k
let modern = protocol == ApiKeyProtocol::Messages || ["gpt-5", "gpt-4.1", "gpt-4o"].iter().any(|prefix| tokenizer_model.starts_with(prefix));
let encoder = if modern {
O200K.get_or_init(|| tiktoken_rs::o200k_base().map_err(|_| ()))
} else {
CL100K.get_or_init(|| tiktoken_rs::cl100k_base().map_err(|_| ()))
}.as_ref().map_err(|_| {
provider_error(ProviderErrorKind::Protocol, UpstreamSendState::NotSent)
})?;
check()?;
Ok::<u64, ProviderError>(u64::try_from(encoder.encode_ordinary(&segments.join("\n")).len()).unwrap_or(u64::MAX))
});
let count = tokio::select! {
biased;
_ = context.cancellation().cancelled() => Err(provider_error(ProviderErrorKind::Cancelled, UpstreamSendState::NotSent)),
_ = context.deadline().wait() => Err(provider_error(ProviderErrorKind::Timeout, UpstreamSendState::NotSent)),
result = count => result.map_err(|_| provider_error(ProviderErrorKind::Protocol, UpstreamSendState::NotSent)).and_then(std::convert::identity),
}?;
let meta = ResponseMeta::new(context.request_id().as_str(), model.as_str());
yield ProviderEvent::canonical(GatewayEvent::Started(meta.clone()));
let wire = ProtocolWireEvent::raw_json(response_protocol, serde_json::to_vec(&serde_json::json!({"input_tokens":count})).map_err(|_| protocol_error())?.into()).map_err(|_| protocol_error())?;
yield ProviderEvent::wire(wire).with_fact(GatewayEvent::Completed(meta.with_finish_reason(FinishReason::Stop)));
});
// 估算没有发送上游请求,不能计入账号响应成功率或上游用量
Ok(ProviderStream::new(metadata, events, lease))
}
}
fn push(segments: &mut Vec<String>, value: &Value) {
if value.is_null() {
return;
}
let text = value
.as_str()
.map(str::to_owned)
.unwrap_or_else(|| value.to_string());
let text = text.trim();
if !text.is_empty() {
segments.push(text.to_owned());
}
}
fn fields(segments: &mut Vec<String>, value: &Value, names: &[&str]) {
for name in names {
push(segments, &value[name]);
}
}
fn messages_segments(body: &Map<String, Value>) -> Vec<String> {
let mut segments = Vec::new();
if let Some(system) = body.get("system") {
content_segments(system, &mut segments);
}
for message in body
.get("messages")
.and_then(Value::as_array)
.into_iter()
.flatten()
{
push(&mut segments, &message["role"]);
content_segments(&message["content"], &mut segments);
}
for tool in body
.get("tools")
.and_then(Value::as_array)
.into_iter()
.flatten()
{
fields(
&mut segments,
tool,
&["type", "name", "description", "input_schema"],
);
}
if let Some(choice) = body.get("tool_choice") {
if choice.is_string() {
push(&mut segments, choice);
} else {
fields(&mut segments, choice, &["type", "name"]);
}
}
segments
}
fn content_segments(content: &Value, segments: &mut Vec<String>) {
if content.is_string() {
push(segments, content);
return;
}
if let Some(parts) = content.as_array() {
for part in parts {
content_segments(part, segments);
}
return;
}
if !content.is_object() {
return;
}
match content
.get("type")
.and_then(Value::as_str)
.unwrap_or_default()
{
"text" => push(segments, &content["text"]),
"thinking" => push(segments, &content["thinking"]),
"tool_use" | "server_tool_use" | "mcp_tool_use" => {
fields(segments, content, &["id", "name", "input"])
}
kind if kind.ends_with("tool_result") => {
fields(segments, content, &["tool_use_id", "tool_call_id"]);
content_segments(&content["content"], segments);
}
"document" if content.pointer("/source/type").and_then(Value::as_str) == Some("text") => {
fields(segments, content, &["title", "context"]);
fields(segments, &content["source"], &["data", "content"]);
}
"web_search_result" | "search_result" => {
fields(segments, content, &["source", "title", "url", "page_age"]);
content_segments(&content["content"], segments);
}
"web_fetch_result" => {
fields(segments, content, &["url", "retrieved_at"]);
content_segments(&content["content"], segments);
}
"code_execution_result"
| "bash_code_execution_result"
| "text_editor_code_execution_result" => {
fields(segments, content, &["stdout", "stderr", "return_code"]);
content_segments(&content["content"], segments);
content_segments(&content["output"], segments);
}
"tool_reference" => push(segments, &content["tool_name"]),
"image" | "input_audio" | "audio" | "video" | "redacted_thinking" | "document" => {}
"" => push(segments, content),
_ => push(segments, &content["text"]),
}
}
fn responses_segments(body: &Map<String, Value>) -> Vec<String> {
let mut segments = Vec::new();
if let Some(instructions) = body.get("instructions") {
push(&mut segments, instructions);
}
for item in body
.get("input")
.and_then(Value::as_array)
.into_iter()
.flatten()
{
match item.get("type").and_then(Value::as_str) {
Some("message") | None => {
if item["content"].is_string() {
push(&mut segments, &item["content"]);
}
for part in item
.get("content")
.and_then(Value::as_array)
.into_iter()
.flatten()
{
push(&mut segments, &part["text"]);
}
}
Some("function_call") => fields(&mut segments, item, &["name", "arguments"]),
Some("function_call_output") => push(&mut segments, &item["output"]),
_ => push(&mut segments, &item["text"]),
}
}
for tool in body
.get("tools")
.and_then(Value::as_array)
.into_iter()
.flatten()
{
fields(&mut segments, tool, &["name", "description", "parameters"]);
}
if let Some(format) = body.get("text").and_then(|value| value.get("format")) {
fields(&mut segments, format, &["name", "schema"]);
}
segments
}
@@ -0,0 +1,284 @@
//! 现有账号租约内按 API 协议分派;转换不改变账号选择和中间件执行顺序
mod count;
mod stream;
mod translator;
use super::*;
use crate::credential::{ApiKeyProtocol, CodexRuntimeAuthentication};
use gateway_protocol::anthropic::{
ANTHROPIC_PROTOCOL, messages_to_responses_request, responses_to_messages_request,
};
use serde_json::Map;
impl CodexProvider {
pub(super) async fn execute_selected_protocol_generate(
self: Arc<Self>,
operation: Operation,
mut headers: Vec<MiddlewareHeader>,
model: UpstreamModelId,
context: AttemptContext,
mut selected: SelectedGenerate,
) -> Result<ProviderStream, ProviderError> {
if operation.capability_requirements() != selected.frozen_requirements {
return Err(invalid_request());
}
let Operation::Generate(generate) = &operation else {
return Err(invalid_request());
};
let source = generate.protocol_payload().protocol();
if !matches!(source, PROVIDER_NAME | ANTHROPIC_PROTOCOL) {
return Err(invalid_request());
}
if selected.lease.authentication().api_protocol() == ApiKeyProtocol::Messages {
if context.continuation_attempt() == ContinuationAttempt::Native
|| generate.provider_session_state(PROVIDER_NAME).is_some()
|| (source == PROVIDER_NAME
&& generate
.protocol_payload()
.body()
.get("previous_response_id")
.and_then(Value::as_str)
.is_some_and(|value| !value.is_empty()))
{
return Err(continuation_replay_required_error("scope_unavailable"));
}
let original = generate.protocol_payload().body();
let mut body = if source == ANTHROPIC_PROTOCOL {
let mut body = original.clone();
gateway_protocol::anthropic::strip_foreign_thinking_for_messages(&mut body);
body
} else {
let capabilities = tokio::select! {
biased;
_ = context.cancellation().cancelled() => return Err(provider_error(ProviderErrorKind::Cancelled, UpstreamSendState::NotSent)),
_ = context.deadline().wait() => return Err(provider_error(ProviderErrorKind::Timeout, UpstreamSendState::NotSent)),
result = self.catalog.messages_model_capabilities(selected.lease.account(), &model) => result.ok().flatten().unwrap_or_default(),
};
let mut body = responses_to_messages_request(original, &capabilities)
.map_err(|_| invalid_request())?;
// Responses 的 HTTP JSON 和 SSE 共用事件输出,跨协议上游统一请求事件流
body.insert("stream".to_owned(), Value::Bool(true));
body
};
body.insert("model".to_owned(), Value::String(model.as_str().to_owned()));
let mut source_context = generate.protocol_payload().context().clone();
if source == PROVIDER_NAME {
retain_target_headers(source, &mut source_context, &mut headers);
if body.get("speed").and_then(Value::as_str) == Some("fast") {
crate::compat::add_translated_fast_beta(
&mut headers,
&crate::transport::request::decode_passthrough_headers(&source_context),
);
}
}
let translator = (source == PROVIDER_NAME)
.then(|| translator::MessagesResponseTranslator::new(original));
drop(operation);
let stream = self
.execute_selected_messages(body, source_context, headers, model, context, selected)
.await?;
return Ok(if let Some(translator) = translator {
stream.with_native_response_translator(translator)
} else {
stream
});
}
if source == ANTHROPIC_PROTOCOL {
let original = generate.protocol_payload().body();
let mut source_context = generate.protocol_payload().context().clone();
retain_target_headers(source, &mut source_context, &mut headers);
let translator = translator::ResponsesResponseTranslator::new(original);
let translated =
messages_to_responses_request(original).map_err(|_| invalid_request())?;
let body = serde_json::to_vec(&translated).map_err(|_| invalid_request())?;
let operation = operation
.replace_protocol_wire(None, source_context)
.map_err(|_| invalid_request())?
.translate_protocol_wire(PROVIDER_NAME, body.into())
.map_err(|_| invalid_request())?;
// 原始能力已在上面核对;Responses 终端只校验它实际消费的 wire 事实
if let Operation::Generate(generate) = &operation {
selected.frozen_requirements = generate.wire_capability_requirements();
}
let stream = self
.execute_selected_generate(operation, headers, model, context, selected)
.await?;
return Ok(stream.with_native_response_translator(translator));
}
self.execute_selected_generate(operation, headers, model, context, selected)
.await
}
async fn execute_selected_messages(
self: Arc<Self>,
body: Map<String, Value>,
source_context: Map<String, Value>,
headers: Vec<MiddlewareHeader>,
model: UpstreamModelId,
context: AttemptContext,
selected: SelectedGenerate,
) -> Result<ProviderStream, ProviderError> {
let SelectedGenerate {
mut lease,
account_selection_wait_ms,
..
} = selected;
if !context.is_diagnostic_required_account() {
self.selector
.validate_translated_selection(
&mut lease,
None,
None,
context.account_selection_policy(),
)
.await
.map_err(map_selection_error)?;
}
self.messages_stream(
body,
source_context,
headers,
model,
context,
lease,
account_selection_wait_ms,
None,
)
}
#[expect(clippy::too_many_arguments)]
fn messages_stream(
&self,
body: Map<String, Value>,
source_context: Map<String, Value>,
headers: Vec<MiddlewareHeader>,
model: UpstreamModelId,
context: AttemptContext,
lease: CodexCredentialLease,
account_selection_wait_ms: u64,
count_protocol: Option<&'static str>,
) -> Result<ProviderStream, ProviderError> {
let CodexRuntimeAuthentication::ApiKey(authentication) = lease.authentication() else {
return Err(invalid_request());
};
let provider = ProviderKind::new(PROVIDER_NAME).map_err(|_| invalid_request())?;
let transport = if body.get("stream").and_then(Value::as_bool) == Some(true) {
HTTP_SSE_TRANSPORT
} else {
HTTP_JSON_TRANSPORT
};
let metadata = ProviderCallMetadata::new(
provider.clone(),
model.clone(),
lease.account_id().clone(),
UpstreamTransport::new(transport).map_err(|_| invalid_request())?,
)
.with_credential_revision(lease.account().revision())
.with_account_snapshot(Some(
gateway_core::account::AccountHistorySnapshot::from_account(lease.account()),
))
.with_selection_observation(ProviderSelectionObservation::new(
account_selection_wait_ms,
lease.capacity_snapshot(),
));
let client = self
.client_for_request(&context)?
.for_account(lease.account())
.map_err(|error| map_client_error(error, UpstreamSendState::NotSent, None).error)?
.with_messages_api_base_url(&authentication.configuration.base_url)
.with_connection_budget(context.connection_budget().clone())
.with_middleware_headers(headers)
.with_outbound_middleware(context.outbound_middleware(
provider,
Some(model.as_str().to_owned()),
lease.account_id().clone(),
))
.with_privacy(context.privacy(), context.cancellation().clone());
let response_origin = Url::parse(&crate::transport::endpoint_url(
&authentication.configuration.base_url,
"/messages",
))
.map_err(|_| invalid_request())?;
let allows_account_state_mutation = lease.allows_account_state_mutation();
let lease = Arc::new(lease);
let events = stream::cold_messages_stream(stream::ColdMessages {
client,
fast_requested: body.get("speed").and_then(Value::as_str) == Some("fast"),
body: serde_json::to_vec(&body)
.map_err(|_| invalid_request())?
.into(),
passthrough_headers: crate::transport::request::decode_passthrough_headers(
&source_context,
),
context,
lease: Arc::clone(&lease),
selector: Arc::clone(&self.selector),
quota: Arc::clone(&self.quota),
model,
response_origin,
count_protocol,
});
let stream = ProviderStream::new(metadata, events, lease);
Ok(if allows_account_state_mutation {
stream.with_filtered_account_feedback(
Arc::clone(&self.account_feedback),
openai_failure_affects_account_score,
)
} else {
stream
})
}
}
fn invalid_request() -> ProviderError {
provider_error(
ProviderErrorKind::InvalidRequest,
UpstreamSendState::NotSent,
)
}
fn protocol_error() -> ProviderError {
provider_error(ProviderErrorKind::Protocol, UpstreamSendState::Sent)
}
fn retain_target_headers(
source: &str,
context: &mut Map<String, Value>,
headers: &mut Vec<MiddlewareHeader>,
) {
let keep = |name: &str| {
let name = name.to_ascii_lowercase();
if source == ANTHROPIC_PROTOCOL {
!name.starts_with("anthropic-") && !name.starts_with("x-anthropic-")
} else {
![
"openai-",
"x-openai-",
"x-codex-",
"x-oai-",
"x-responsesapi-",
"chatgpt-",
]
.iter()
.any(|prefix| name.starts_with(prefix))
&& !matches!(
name.as_str(),
"session-id" | "conversation-id" | "thread-id" | "turn-id" | "session_id"
)
}
};
if let Some(entries) = context
.get_mut(crate::transport::request::PASSTHROUGH_HEADERS_CONTEXT_KEY)
.and_then(Value::as_array_mut)
{
entries.retain(|entry| {
entry
.as_array()
.and_then(|entry| entry.first())
.and_then(Value::as_str)
.is_some_and(keep)
});
}
headers.retain(|header| keep(header.name()));
}
@@ -0,0 +1,487 @@
//! Messages 原生响应保留 wire,旁路产生生命周期、用量及计费事实
use std::collections::BTreeMap;
use gateway_core::{
event::{ContentItem, ContentKind, ReasoningDelta, TextDelta, ToolCallDelta},
metering::Usage,
};
use gateway_protocol::{
anthropic::MessageUsage,
openai::sse::{SseEventDecoder, SseFrame},
};
use super::*;
use crate::provider::observation::insert_first_timing;
use crate::transport::usage::{OpenAiBillingUsage, configured_token_billing_breakdown};
// 非流式上游需要完整解码后才能交付;流式交付不受此总长限制
const MAX_MESSAGES_JSON_BYTES: usize = 16 * 1024 * 1024;
pub(super) struct ColdMessages {
pub client: CodexBackendClient,
pub body: Bytes,
pub passthrough_headers: reqwest::header::HeaderMap,
pub context: AttemptContext,
pub lease: Arc<CodexCredentialLease>,
pub selector: Arc<CodexCredentialSelector>,
pub quota: Arc<CodexCredentialQuotaService>,
pub model: UpstreamModelId,
pub response_origin: Url,
pub count_protocol: Option<&'static str>,
pub fast_requested: bool,
}
pub(super) fn cold_messages_stream(mut request: ColdMessages) -> EventStream {
Box::pin(async_stream::try_stream! {
let failure_context = OpenAiFailureContext {
client: &request.client, selector: &request.selector, quota: &request.quota,
response_origin: &request.response_origin, cyber_policy_scope: None,
allows_account_state_mutation: request.lease.allows_account_state_mutation(),
image_endpoint: false, upstream_model: Some(&request.model),
};
let authorization = request.lease.authentication().authorization_header().map_err(|_| invalid_request())?;
let trace = request.context.trace().clone();
let upstream_context = CodexRequestContext::auxiliary(authorization.expose_secret(), None,
request.context.request_id().as_str(), None).with_trace(&trace);
let endpoint = if request.count_protocol.is_some() { "/messages/count_tokens" } else { "/messages" };
let response = tokio::select! {
biased;
_ = request.context.cancellation().cancelled() => Err(provider_error(ProviderErrorKind::Cancelled, UpstreamSendState::NotSent)),
_ = request.context.deadline().wait() => Err(provider_error(ProviderErrorKind::Timeout, UpstreamSendState::NotSent)),
response = request.client.post_messages(endpoint, std::mem::take(&mut request.body), &request.passthrough_headers, upstream_context) => {
match response {
Ok(response) => Ok(response),
Err(error) => {
let failure = map_client_error(error, UpstreamSendState::Sent, None);
apply_failure(&failure_context, request.lease.account(), &failure).await;
Err(failure.error)
}
}
}
}?;
let transport = if response.streaming { CodexBackendTransport::HttpSse } else { CodexBackendTransport::HttpJson };
let observation = |timings| codex_response_observation(transport, &response.diagnostics,
&response.response_metadata, &response.transport_metrics, None, timings);
let mut timings = openai_response_timings(&response.transport_metrics, &response.response_metadata);
if let Some(snapshot) = observation(timings) {
yield ProviderEvent::observation(snapshot);
}
let streaming = response.streaming;
let mut body = response.body;
let mut decoder = SseEventDecoder::default();
let mut json = Vec::new();
let mut state = MessageState::default();
loop {
let next = tokio::select! {
biased;
_ = request.context.cancellation().cancelled() => Err(provider_error(ProviderErrorKind::Cancelled, UpstreamSendState::Sent)),
_ = request.context.deadline().wait() => Err(provider_error(ProviderErrorKind::Timeout, UpstreamSendState::Sent)),
chunk = body.next() => match chunk {
Some(Ok(bytes)) => Ok(Some(bytes)),
Some(Err(error)) => Err(map_stream_error(error).error),
None => Ok(None),
},
}?;
let Some(bytes) = next else { break; };
trace.capture("upstream.response.body", &bytes);
if !bytes.is_empty() && insert_first_timing(&mut timings.first_event_ms, request.context.timing_started_at())
&& let Some(snapshot) = observation(timings) {
yield ProviderEvent::observation(snapshot);
}
if streaming {
for frame in decoder.push_frames(&bytes) {
let event = observed_frame(&mut state, frame, &request).await?;
if observe_content_timings(&event, &mut timings, request.context.timing_started_at())
&& let Some(snapshot) = observation(timings) {
yield ProviderEvent::observation(snapshot);
}
yield event;
if state.completed { break; }
}
if state.completed { break; }
} else {
if bytes.len() > MAX_MESSAGES_JSON_BYTES - json.len() { Err(protocol_error())?; }
json.extend_from_slice(&bytes);
}
}
if streaming {
if !state.completed {
for frame in decoder.finish_frames() {
let event = observed_frame(&mut state, frame, &request).await?;
if observe_content_timings(&event, &mut timings, request.context.timing_started_at())
&& let Some(snapshot) = observation(timings) {
yield ProviderEvent::observation(snapshot);
}
yield event;
if state.completed { break; }
}
}
if !state.completed { Err(protocol_error())?; }
} else {
let value: Value = serde_json::from_slice(&json).map_err(|_| protocol_error())?;
if value.get("type").and_then(Value::as_str) == Some("error") {
let error = message_error(&value);
record_message_failure(&request, &error).await;
Err(error)?;
}
let meta = if request.count_protocol.is_some() {
if value.get("input_tokens").and_then(Value::as_u64).is_none() { Err(protocol_error())?; }
ResponseMeta::new(request.context.request_id().as_str(), request.model.as_str())
} else {
message_meta(&value)?
};
let wire = ProtocolWireEvent::raw_json(
request.count_protocol.unwrap_or(ANTHROPIC_PROTOCOL), json.into(),
).map_err(|_| protocol_error())?;
// 原生出口只交付 wire,开始事实必须附在可交付正文上,避免提前提交空批次
let mut event = ProviderEvent::wire(wire).with_fact(GatewayEvent::Started(meta.clone()));
if !request.count_protocol.is_some() {
state.usage.merge(&value["usage"]);
event = with_usage(event, state.usage);
let unpriced = unpriced_usage(&value["usage"]) || value.get("content").and_then(Value::as_array).is_some_and(|blocks| {
blocks.iter().any(|block| block.get("type").and_then(Value::as_str) == Some("server_tool_use"))
});
event = with_cost(event, state.usage, unpriced, &request);
if let Some(blocks) = value.get("content").and_then(Value::as_array) {
for block in blocks {
let target = match block.get("type").and_then(Value::as_str) {
Some("text") if block.get("text").and_then(Value::as_str).is_some_and(|text| !text.is_empty()) => Some(&mut timings.first_text_ms),
Some("thinking" | "redacted_thinking") => Some(&mut timings.first_reasoning_ms),
Some("tool_use" | "server_tool_use") => Some(&mut timings.first_token_ms),
_ => None,
};
if let Some(target) = target {
insert_first_timing(target, request.context.timing_started_at());
insert_first_timing(&mut timings.first_token_ms, request.context.timing_started_at());
}
}
}
if let Some(snapshot) = observation(timings) {
event.attach_observation(snapshot);
}
}
yield event.with_fact(GatewayEvent::Completed(meta.with_finish_reason(finish_reason(value.get("stop_reason").and_then(Value::as_str)))));
}
})
}
// Messages 的首字从可消费内容开始,ping、消息元数据和空增量不计入输出延迟
fn observe_content_timings(
event: &ProviderEvent,
timings: &mut ProviderResponseTimings,
started: Instant,
) -> bool {
let mut changed = false;
for fact in event.canonical_facts() {
let target = match fact {
GatewayEvent::TextDelta(delta) if !delta.text.is_empty() => {
Some(&mut timings.first_text_ms)
}
GatewayEvent::ReasoningDelta(delta) if !delta.text.is_empty() => {
Some(&mut timings.first_reasoning_ms)
}
GatewayEvent::ToolCallDelta(delta)
if delta.name.is_some() || !delta.arguments_delta.is_empty() =>
{
Some(&mut timings.first_token_ms)
}
_ => None,
};
if let Some(target) = target {
changed |= insert_first_timing(target, started);
changed |= insert_first_timing(&mut timings.first_token_ms, started);
}
}
changed
}
#[derive(Default)]
struct MessageState {
meta: Option<ResponseMeta>,
usage: MessageUsage,
reason: Option<String>,
tools: BTreeMap<u32, String>,
completed: bool,
unpriced_usage: bool,
}
impl MessageState {
fn frame(
&mut self,
frame: SseFrame,
request: &ColdMessages,
) -> Result<ProviderEvent, ProviderError> {
let (raw, events) = frame.into_parts();
let Some(sse) = events.into_iter().next() else {
return ProtocolWireEvent::raw_sse(ANTHROPIC_PROTOCOL, raw.into())
.map(ProviderEvent::wire)
.map_err(|_| protocol_error());
};
let Ok(value) = serde_json::from_str::<Value>(&sse.data) else {
return ProtocolWireEvent::raw_sse(ANTHROPIC_PROTOCOL, raw.into())
.map(ProviderEvent::wire)
.map_err(|_| protocol_error());
};
let kind = value
.get("type")
.and_then(Value::as_str)
.or(sse.event.as_deref())
.map(str::to_owned);
if kind.as_deref() == Some("error") {
return Err(message_error(&value));
}
let wire = ProtocolWireEvent::json_with_raw_sse_metadata(
ANTHROPIC_PROTOCOL,
sse.event,
value.clone(),
raw.into(),
sse.id,
sse.retry,
)
.map_err(|_| protocol_error())?;
let mut event = ProviderEvent::wire(wire);
let index = value
.get("index")
.and_then(Value::as_u64)
.and_then(|value| u32::try_from(value).ok())
.unwrap_or_default();
match kind.as_deref() {
Some("message_start") => {
if self.meta.is_some() {
return Err(protocol_error());
}
let meta = message_meta(&value["message"])?;
self.meta = Some(meta.clone());
self.usage.merge(&value["message"]["usage"]);
self.unpriced_usage |= unpriced_usage(&value["message"]["usage"]);
event = with_usage(event.with_fact(GatewayEvent::Started(meta)), self.usage);
}
Some("content_block_start") => {
let block = &value["content_block"];
self.unpriced_usage |=
block.get("type").and_then(Value::as_str) == Some("server_tool_use");
let kind = match block.get("type").and_then(Value::as_str) {
Some("thinking" | "redacted_thinking") => ContentKind::Reasoning,
Some("tool_use" | "server_tool_use") => ContentKind::ToolCall,
_ => ContentKind::Text,
};
event = event.with_fact(GatewayEvent::ContentAdded(ContentItem::new(index, kind)));
if kind == ContentKind::ToolCall {
let id = block
.get("id")
.and_then(Value::as_str)
.unwrap_or_default()
.to_owned();
self.tools.insert(index, id.clone());
event = event.with_fact(GatewayEvent::ToolCallDelta(ToolCallDelta {
content_index: index,
call_id: id,
name: block.get("name").and_then(Value::as_str).map(str::to_owned),
arguments_delta: String::new(),
}));
}
}
Some("content_block_delta") => {
let delta = &value["delta"];
match delta.get("type").and_then(Value::as_str) {
Some("text_delta") => {
event = event.with_fact(GatewayEvent::TextDelta(TextDelta {
content_index: index,
text: delta["text"].as_str().unwrap_or_default().to_owned(),
}))
}
Some("thinking_delta") => {
event = event.with_fact(GatewayEvent::ReasoningDelta(ReasoningDelta {
content_index: index,
text: delta["thinking"].as_str().unwrap_or_default().to_owned(),
}))
}
Some("input_json_delta") => {
event = event.with_fact(GatewayEvent::ToolCallDelta(ToolCallDelta {
content_index: index,
call_id: self.tools.get(&index).cloned().unwrap_or_default(),
name: None,
arguments_delta: delta["partial_json"]
.as_str()
.unwrap_or_default()
.to_owned(),
}))
}
_ => {}
}
}
Some("message_delta") => {
self.usage.merge(&value["usage"]);
self.unpriced_usage |= unpriced_usage(&value["usage"]);
self.reason = value
.pointer("/delta/stop_reason")
.and_then(Value::as_str)
.map(str::to_owned)
.or(self.reason.take());
// 结束用量先于 message_stop 到达,费用必须同时记录,避免随后截断或取消丢账
event = with_cost(
with_usage(event, self.usage),
self.usage,
self.unpriced_usage,
request,
);
}
Some("message_stop") => {
let meta = self.meta.clone().ok_or_else(protocol_error)?;
self.completed = true;
event = with_cost(event, self.usage, self.unpriced_usage, request).with_fact(
GatewayEvent::Completed(
meta.with_finish_reason(finish_reason(self.reason.as_deref())),
),
);
}
_ => {}
}
Ok(event)
}
}
fn message_meta(value: &Value) -> Result<ResponseMeta, ProviderError> {
Ok(ResponseMeta::new(
value
.get("id")
.and_then(Value::as_str)
.ok_or_else(protocol_error)?,
value
.get("model")
.and_then(Value::as_str)
.ok_or_else(protocol_error)?,
))
}
fn finish_reason(value: Option<&str>) -> FinishReason {
match value {
Some("max_tokens" | "model_context_window_exceeded") => FinishReason::Length,
Some("tool_use") => FinishReason::ToolCall,
Some("refusal") => FinishReason::ContentFilter,
_ => FinishReason::Stop,
}
}
fn with_usage(event: ProviderEvent, usage: MessageUsage) -> ProviderEvent {
event.with_fact(GatewayEvent::Usage(Usage {
input_tokens: usage.total_input_tokens(),
output_tokens: usage.output_tokens,
cached_input_tokens: usage.cache_read_input_tokens,
cache_write_input_tokens: usage.cache_creation_input_tokens,
..Usage::new()
}))
}
fn with_cost(
event: ProviderEvent,
usage: MessageUsage,
unpriced: bool,
request: &ColdMessages,
) -> ProviderEvent {
if unpriced || request.fast_requested {
return event;
}
// Messages 的计价只能来自显式覆盖;模型别名不能隐式借用 OpenAI 内置价格
let Some(pricing) = request
.context
.pricing()
.get(PROVIDER_NAME)
.and_then(|models| models.get(request.model.as_str()))
else {
return event;
};
let (Some(input_tokens), Some(output_tokens)) =
(usage.total_input_tokens(), usage.output_tokens)
else {
return event;
};
let usage = OpenAiBillingUsage::from(gateway_protocol::openai::events::TokenUsage {
input_tokens,
output_tokens,
cached_input_tokens: usage.cache_read_input_tokens.unwrap_or_default(),
cache_write_input_tokens: usage.cache_creation_input_tokens.unwrap_or_default(),
..Default::default()
});
match configured_token_billing_breakdown(usage, pricing) {
Some(cost) => event.with_fact(GatewayEvent::CalculatedCost(cost.calculated_cost())),
None => event,
}
}
fn unpriced_usage(usage: &Value) -> bool {
usage.get("speed").and_then(Value::as_str) == Some("fast")
|| usage
.pointer("/cache_creation/ephemeral_1h_input_tokens")
.and_then(Value::as_u64)
.is_some_and(|tokens| tokens > 0)
|| usage
.get("server_tool_use")
.and_then(Value::as_object)
.is_some_and(|tools| {
tools
.values()
.any(|value| value.as_u64().is_some_and(|count| count > 0))
})
}
fn message_error(value: &Value) -> ProviderError {
let error = &value["error"];
let error_type = error.get("type").and_then(Value::as_str);
let kind = match error_type {
Some("authentication_error") => ProviderErrorKind::Unauthorized,
Some("rate_limit_error") => ProviderErrorKind::RateLimited,
Some("invalid_request_error") => ProviderErrorKind::InvalidRequest,
Some("overloaded_error") => ProviderErrorKind::UpstreamCapacityUnavailable,
Some("api_error") => ProviderErrorKind::Unavailable,
_ => ProviderErrorKind::Protocol,
};
provider_error(kind, UpstreamSendState::Sent).with_client_visible_upstream_error(
ClientVisibleUpstreamError::new(
error
.get("message")
.and_then(Value::as_str)
.unwrap_or("The Messages upstream returned an error."),
None,
error_type.map(str::to_owned),
),
)
}
async fn observed_frame(
state: &mut MessageState,
frame: SseFrame,
request: &ColdMessages,
) -> Result<ProviderEvent, ProviderError> {
match state.frame(frame, request) {
Ok(event) => Ok(event),
Err(error) => {
record_message_failure(request, &error).await;
Err(error)
}
}
}
async fn record_message_failure(request: &ColdMessages, error: &ProviderError) {
if !request.lease.allows_account_state_mutation() {
return;
}
let failure = match error.kind() {
ProviderErrorKind::Unauthorized => Some(CodexAccountFailure::CredentialExpired),
ProviderErrorKind::RateLimited => Some(CodexAccountFailure::RateLimited {
retry_after: error.retry_after(),
}),
_ => None,
};
if let Some(failure) = failure {
// 账号写回复用 selector 的凭据 revision 校验,流内错误不能污染已轮换的凭据
if let Err(error) = request
.selector
.record_failure(request.lease.account(), failure, None)
.await
{
tracing::warn!(account_id = %request.lease.account_id(), error = %error, "Failed to record Messages account failure");
}
}
}
@@ -0,0 +1,119 @@
//! 双向转换器由每条响应独占,纯协议状态不接触账号、重试或费用
use super::*;
use gateway_core::engine::provider::NativeResponseTranslator;
use gateway_protocol::anthropic::{MessagesToResponsesStream, ResponsesToMessagesStream};
pub(super) struct MessagesResponseTranslator {
stream: MessagesToResponsesStream,
}
impl MessagesResponseTranslator {
pub(super) fn new(original: &Map<String, Value>) -> Self {
Self {
stream: MessagesToResponsesStream::new(original),
}
}
}
impl NativeResponseTranslator for MessagesResponseTranslator {
fn source_protocol(&self) -> &str {
ANTHROPIC_PROTOCOL
}
fn target_protocol(&self) -> &str {
PROVIDER_NAME
}
fn translate(
&mut self,
event: &ProtocolWireEvent,
) -> Result<Vec<ProtocolWireEvent>, ProviderError> {
if let Some(raw) = event.raw_json_body() {
let message: Value = serde_json::from_slice(raw).map_err(|_| protocol_error())?;
let event = self
.stream
.complete_json_event(&message)
.map_err(|_| protocol_error())?;
return wire_events(PROVIDER_NAME, vec![event]);
}
if !event.has_json_data() {
return Ok(Vec::new());
}
let events = self
.stream
.push(event.data())
.map_err(|_| protocol_error())?;
if event.data().get("type").and_then(Value::as_str) == Some("message_stop") {
self.stream.finish().map_err(|_| protocol_error())?;
}
wire_events(PROVIDER_NAME, events)
}
}
pub(super) struct ResponsesResponseTranslator {
stream: ResponsesToMessagesStream,
}
impl ResponsesResponseTranslator {
pub(super) fn new(original: &Map<String, Value>) -> Self {
Self {
stream: ResponsesToMessagesStream::new(original),
}
}
}
impl NativeResponseTranslator for ResponsesResponseTranslator {
fn source_protocol(&self) -> &str {
PROVIDER_NAME
}
fn target_protocol(&self) -> &str {
ANTHROPIC_PROTOCOL
}
fn translate(
&mut self,
event: &ProtocolWireEvent,
) -> Result<Vec<ProtocolWireEvent>, ProviderError> {
if let Some(raw) = event.raw_json_body() {
let response = serde_json::from_slice(raw).map_err(|_| protocol_error())?;
let message = self
.stream
.complete_json(&response)
.map_err(|_| protocol_error())?;
let raw = serde_json::to_vec(&message).map_err(|_| protocol_error())?;
return Ok(vec![
ProtocolWireEvent::raw_json(ANTHROPIC_PROTOCOL, raw.into())
.map_err(|_| protocol_error())?,
]);
}
if !event.has_json_data() {
return Ok(Vec::new());
}
let events = self
.stream
.push(event.data())
.map_err(|_| protocol_error())?;
if matches!(
event.data().get("type").and_then(Value::as_str),
Some("response.completed" | "response.incomplete")
) {
self.stream.finish().map_err(|_| protocol_error())?;
}
wire_events(ANTHROPIC_PROTOCOL, events)
}
}
fn wire_events(
protocol: &str,
events: Vec<Value>,
) -> Result<Vec<ProtocolWireEvent>, ProviderError> {
events
.into_iter()
.map(|value| {
ProtocolWireEvent::json(
protocol,
value.get("type").and_then(Value::as_str).map(str::to_owned),
value,
)
.map_err(|_| protocol_error())
})
.collect()
}
@@ -106,6 +106,7 @@ mod execution;
mod failure;
mod guardian;
mod live;
mod messages;
mod observation;
mod upstream_adapter;
mod workers;
@@ -484,6 +485,9 @@ impl Provider for CodexProvider {
Operation::GenerateImage(request) => {
observation::endpoint_requested_model(request.payload())
}
Operation::CountTokens(request) => {
observation::endpoint_requested_model(request.payload())
}
_ => None,
},
continuation: ContinuationRequestObservation {
@@ -597,6 +601,9 @@ impl Provider for CodexProvider {
if let Operation::Search(search) = request.operation() {
return self.execute_search(search, candidate, context).await;
}
if let Operation::CountTokens(count) = request.operation() {
return self.execute_count_tokens(count, candidate, context).await;
}
if let Operation::ProviderHttp(request) = request.operation() {
return self
.execute_live_call(request.clone(), candidate.upstream_model(), context)
@@ -787,7 +794,7 @@ impl Provider for CodexProvider {
);
}
provider
.execute_selected_generate(
.execute_selected_protocol_generate(
operation,
middleware_headers,
terminal_model,
@@ -827,7 +834,7 @@ impl CodexProvider {
));
};
if generate.protocol_payload().protocol() != PROVIDER_NAME
|| native_request_requirements(&generate) != frozen_requirements
|| generate.wire_capability_requirements() != frozen_requirements
{
return Err(provider_error(
ProviderErrorKind::InvalidRequest,
@@ -843,6 +850,7 @@ impl CodexProvider {
);
let mut upstream = encode_generate_request(&generate, upstream_model.as_str(), None)
.map_err(map_request_error)?;
gateway_protocol::anthropic::strip_foreign_reasoning_for_responses(upstream.body_mut());
upstream.client_account_follow_only = crate::request_identity::follows_session_with_headers(
generate.protocol_payload().body(),
generate.protocol_payload().context(),
@@ -1205,11 +1213,3 @@ impl CodexProvider {
})
}
}
fn native_request_requirements(request: &GenerateRequest) -> CapabilityRequirements {
// 此处只解释已知 OpenAI wire;不在 Core 的通用转换路径推断任意目标协议
Operation::Generate(GenerateRequest::from_protocol_payload(
request.protocol_payload().clone(),
))
.capability_requirements()
}
@@ -580,8 +580,11 @@ pub(super) fn nonnegative_millis(value: Option<i64>) -> Option<u64> {
pub(super) fn compile_model_capabilities(model: &CodexCatalogModel) -> ProviderModelCapabilities {
// 模型进入目录即可发布 Generate 能力,`supported_in_api` 仅作提示
// 普通请求和诊断请求均以上游响应为准
let capabilities = ModelCapabilities::new(BTreeSet::from([OperationKind::Generate]), None)
.with_upstream_feature_validation();
let capabilities = ModelCapabilities::new(
BTreeSet::from([OperationKind::Generate, OperationKind::CountTokens]),
None,
)
.with_upstream_feature_validation();
ProviderModelCapabilities::new(model.request_model().clone(), capabilities)
.with_presentation(codex_model_presentation(model))
}
@@ -1,7 +1,10 @@
//! 插件只替换业务 wire;账号租约、凭据解释与费用来源仍属于 OpenAI
use super::*;
use crate::transport::usage::{OpenAiBillingUsage, openai_billing_breakdown_with_override};
use crate::credential::{ApiKeyProtocol, CodexRuntimeAuthentication};
use crate::transport::usage::{
OpenAiBillingUsage, configured_token_billing_breakdown, openai_billing_breakdown_with_override,
};
use gateway_core::{
account::{CredentialRevision, OutboundProxy, ProviderAccountId},
engine::upstream_adapter::{
@@ -109,17 +112,28 @@ impl UpstreamAccountConnection for SelectedConnection {
}
fn authorization(&self) -> Result<Vec<MiddlewareHeader>, ProviderError> {
let authorization = self
.lease
.authentication()
.authorization_header()
.map_err(|_| {
provider_error(ProviderErrorKind::Unauthorized, UpstreamSendState::NotSent)
})?;
let mut headers = vec![MiddlewareHeader::new(
"authorization",
bytes::Bytes::copy_from_slice(authorization.expose_secret().as_bytes()),
)];
let identity = if let CodexRuntimeAuthentication::ApiKey(authentication) =
self.lease.authentication()
&& authentication.configuration.protocol == ApiKeyProtocol::Messages
{
MiddlewareHeader::new(
"x-api-key",
bytes::Bytes::copy_from_slice(authentication.secret.expose_secret().as_bytes()),
)
} else {
let authorization =
self.lease
.authentication()
.authorization_header()
.map_err(|_| {
provider_error(ProviderErrorKind::Unauthorized, UpstreamSendState::NotSent)
})?;
MiddlewareHeader::new(
"authorization",
bytes::Bytes::copy_from_slice(authorization.expose_secret().as_bytes()),
)
};
let mut headers = vec![identity];
if let Some(account_id) = self.lease.account().upstream_account_id() {
headers.push(MiddlewareHeader::new(
"chatgpt-account-id",
@@ -141,14 +155,20 @@ impl UpstreamAccountConnection for SelectedConnection {
image_output_tokens: usage.image_output_tokens.unwrap_or(0),
..Default::default()
};
let pricing = self
.context
.pricing()
.get(PROVIDER_NAME)
.and_then(|models| models.get(self.model.as_str()));
if self.lease.authentication().api_protocol() == ApiKeyProtocol::Messages {
return configured_token_billing_breakdown(OpenAiBillingUsage::from(usage), pricing?)
.map(|cost| cost.calculated_cost());
}
openai_billing_breakdown_with_override(
self.model.as_str(),
OpenAiBillingUsage::from(usage),
self.requested_service_tier.as_deref(),
self.context
.pricing()
.get(PROVIDER_NAME)
.and_then(|models| models.get(self.model.as_str())),
pricing,
)
.map(|cost| cost.calculated_cost())
}
@@ -6,12 +6,13 @@ use std::num::NonZeroU64;
use bytes::Bytes;
use gateway_core::operation::RawJsonPayload;
use gateway_core::routing::{ModelServiceTier, UpstreamModelId};
use gateway_protocol::anthropic::MessagesModelCapabilities;
use reqwest::header::{ETAG, HeaderMap};
use serde::Deserialize;
use super::client::OpenAiUpstreamProtocol;
const MAX_CATALOG_MODELS: usize = 2_048;
pub(super) const MAX_CATALOG_MODELS: usize = 2_048;
const MAX_DISPLAY_NAME_BYTES: usize = 256;
const MAX_DESCRIPTION_BYTES: usize = 4 * 1024;
const MAX_SERVICE_TIER_ID_BYTES: usize = 64;
@@ -189,9 +190,15 @@ pub struct CodexCatalogModel {
capabilities: CodexCatalogCapabilities,
limits: CodexCatalogLimits,
metadata: CodexCatalogMetadata,
messages: Option<MessagesModelCapabilities>,
}
impl CodexCatalogModel {
/// Messages 上游明确提供的模型能力,不与其他账号的同名模型合并
pub(crate) fn messages_capabilities(&self) -> Option<&MessagesModelCapabilities> {
self.messages.as_ref()
}
/// 完整原生对象只用于客户端目录,不写入控制面画像或日志
#[must_use]
pub const fn document(&self) -> &RawJsonPayload {
@@ -437,6 +444,7 @@ fn normalize_model(
}
Ok(CodexCatalogModel {
messages: None,
document,
request_model,
display_name: wire.display_name,
@@ -593,9 +601,10 @@ fn validate_etag(value: &str) -> Result<String, CodexModelCatalogError> {
}
/// 标准 API 模型 ID 遵循核心 ID 合同,不套用 Codex slug 语法或推断原生画像
pub(crate) fn parse_api_model_catalog(
pub(super) fn parse_api_model_catalog(
body: &[u8],
etag: Option<&str>,
protocol: OpenAiUpstreamProtocol,
) -> Result<CodexModelCatalogSnapshot, CodexModelCatalogError> {
#[derive(Deserialize)]
struct ApiModels {
@@ -605,6 +614,8 @@ pub(crate) fn parse_api_model_catalog(
struct ApiModel {
id: String,
display_name: Option<String>,
#[serde(flatten)]
fields: serde_json::Map<String, serde_json::Value>,
}
let value: serde_json::Value =
serde_json::from_slice(body).map_err(|_| CodexModelCatalogError::InvalidWire)?;
@@ -623,6 +634,9 @@ pub(crate) fn parse_api_model_catalog(
let mut seen = BTreeSet::new();
let mut models = Vec::with_capacity(wire.data.len());
for item in wire.data {
let messages = (protocol == OpenAiUpstreamProtocol::MessagesApi).then(|| {
MessagesModelCapabilities::from_model(&serde_json::Value::Object(item.fields))
});
if item.id.trim() != item.id {
return Err(CodexModelCatalogError::InvalidModelSlug);
}
@@ -644,6 +658,7 @@ pub(crate) fn parse_api_model_catalog(
return Err(CodexModelCatalogError::DuplicateModelSlug);
}
models.push(CodexCatalogModel {
messages,
document,
request_model,
display_name,
@@ -683,6 +683,7 @@ pub struct CodexBackendJsonResponse {
pub(super) enum OpenAiUpstreamProtocol {
Codex,
ResponsesApi,
MessagesApi,
}
impl OpenAiUpstreamProtocol {
@@ -690,6 +691,7 @@ impl OpenAiUpstreamProtocol {
match self {
Self::Codex => super::endpoints::CODEX_RESPONSES_PATH,
Self::ResponsesApi => "/responses",
Self::MessagesApi => "/messages",
}
}
}
@@ -874,6 +876,12 @@ impl CodexBackendClient {
self
}
pub(crate) fn with_messages_api_base_url(self, base_url: &str) -> Self {
let mut client = self.with_responses_api_base_url(Some(base_url));
client.protocol = OpenAiUpstreamProtocol::MessagesApi;
client
}
pub fn for_account(
&self,
account: &gateway_core::account::ProviderAccount,
@@ -1,4 +1,4 @@
//! Codex 与 Responses API 模型目录的 HTTP 读取与客户端版本协商
//! 上游模型目录读取;Codex 版本协商与 Messages 分页各自遵循原生合同
use gateway_protocol::openai::events::retry_after_seconds_from_body;
@@ -20,9 +20,64 @@ impl CodexBackendClient {
context: CodexRequestContext<'_>,
client_version: Option<&str>,
) -> CodexClientResult<CodexModelCatalogSnapshot> {
let (body, etag) = self
.fetch_models_page(context, client_version, None)
.await?;
match self.protocol {
OpenAiUpstreamProtocol::Codex => Ok(parse_codex_model_catalog(&body, etag.as_deref())?),
OpenAiUpstreamProtocol::ResponsesApi => Ok(super::catalog::parse_api_model_catalog(
&body,
etag.as_deref(),
self.protocol,
)?),
OpenAiUpstreamProtocol::MessagesApi => {
let mut page = body;
let mut models = Vec::new();
let mut cursors = std::collections::BTreeSet::new();
loop {
let mut value: serde_json::Value = serde_json::from_slice(&page)
.map_err(|_| super::CodexModelCatalogError::InvalidWire)?;
let data = value
.get_mut("data")
.and_then(serde_json::Value::as_array_mut)
.ok_or(super::CodexModelCatalogError::InvalidWire)?;
models.append(data);
if models.len() > super::catalog::MAX_CATALOG_MODELS {
return Err(super::CodexModelCatalogError::TooManyModels.into());
}
if value.get("has_more").and_then(serde_json::Value::as_bool) != Some(true) {
break;
}
let cursor = value
.get("last_id")
.and_then(serde_json::Value::as_str)
.filter(|value| !value.is_empty())
.ok_or(super::CodexModelCatalogError::InvalidWire)?;
if !cursors.insert(cursor.to_owned()) {
return Err(super::CodexModelCatalogError::InvalidWire.into());
}
(page, _) = self.fetch_models_page(context, None, Some(cursor)).await?;
}
let body = serde_json::to_vec(&serde_json::json!({"data":models}))
.map_err(|_| super::CodexModelCatalogError::InvalidWire)?;
Ok(super::catalog::parse_api_model_catalog(
&body,
etag.as_deref(),
self.protocol,
)?)
}
}
}
async fn fetch_models_page(
&self,
context: CodexRequestContext<'_>,
client_version: Option<&str>,
after_id: Option<&str>,
) -> CodexClientResult<(bytes::Bytes, Option<String>)> {
let path = match self.protocol {
OpenAiUpstreamProtocol::Codex => "codex/models",
OpenAiUpstreamProtocol::ResponsesApi => "models",
OpenAiUpstreamProtocol::ResponsesApi | OpenAiUpstreamProtocol::MessagesApi => "models",
};
let profile = self.profile.snapshot();
let headers = self.model_request_headers(&profile, context)?;
@@ -34,7 +89,12 @@ impl CodexBackendClient {
(self.protocol == OpenAiUpstreamProtocol::Codex)
.then_some(profile.codex_version.as_str())
});
if let Some(client_version) = client_version {
if self.protocol == OpenAiUpstreamProtocol::MessagesApi {
request = request.query(&[("limit", "1000")]);
if let Some(after_id) = after_id {
request = request.query(&[("after_id", after_id)]);
}
} else if let Some(client_version) = client_version {
request = request.query(&[("client_version", client_version)]);
}
let response = request.send().await?;
@@ -65,11 +125,6 @@ impl CodexBackendClient {
send_phase: CodexUpstreamSendPhase::AfterPayload,
});
}
Ok(match self.protocol {
OpenAiUpstreamProtocol::Codex => parse_codex_model_catalog(&body, etag.as_deref())?,
OpenAiUpstreamProtocol::ResponsesApi => {
super::catalog::parse_api_model_catalog(&body, etag.as_deref())?
}
})
Ok((body, etag))
}
}

Some files were not shown because too many files have changed in this diff Show More