From dd65665128bc1066a14614804d7d86ecebf5c8d9 Mon Sep 17 00:00:00 2001 From: Zyy Date: Tue, 10 Nov 2026 18:34:45 +0800 Subject: [PATCH] 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 --- .gitignore | 3 + backend/Cargo.lock | 34 + backend/apps/gateway/tests/architecture.rs | 1 + .../src/admin/accounts/credentials.rs | 11 + .../gateway-api/src/admin/accounts/wire.rs | 2 +- .../src/admin/plugins/management.rs | 14 +- backend/crates/gateway-api/src/lib.rs | 2 + backend/crates/gateway-api/src/openai/auth.rs | 38 +- .../src/openai/chat_completions/http.rs | 17 +- .../crates/gateway-api/src/openai/endpoint.rs | 2 +- .../gateway-api/src/openai/generation/http.rs | 1065 +++++++++++++++++ .../gateway-api/src/openai/generation/mod.rs | 80 ++ .../src/openai/generation/request.rs | 160 +++ .../src/openai/generation/response.rs | 191 +++ .../src/openai/generation/validation.rs | 187 +++ .../gateway-api/src/openai/images/http.rs | 4 +- .../gateway-api/src/openai/live/http.rs | 6 +- .../gateway-api/src/openai/live/websocket.rs | 4 +- .../crates/gateway-api/src/openai/messages.rs | 237 ++++ .../gateway-api/src/openai/middleware/http.rs | 3 +- .../src/openai/middleware/request.rs | 5 +- backend/crates/gateway-api/src/openai/mod.rs | 2 + .../crates/gateway-api/src/openai/models.rs | 130 +- .../gateway-api/src/openai/responses/http.rs | 1054 +--------------- .../src/openai/responses/keepalive.rs | 29 +- .../gateway-api/src/openai/responses/mod.rs | 23 +- .../src/openai/responses/request.rs | 177 +-- .../src/openai/responses/response.rs | 4 +- .../src/openai/responses/validation.rs | 28 +- .../src/openai/responses/websocket/forward.rs | 4 +- .../src/openai/responses/websocket/mod.rs | 6 +- .../openai/responses/websocket/protocol.rs | 6 +- .../crates/gateway-api/src/openai/router.rs | 5 + .../gateway-api/src/openai/search/http.rs | 4 +- .../crates/gateway-api/src/openai/service.rs | 9 +- backend/crates/gateway-api/src/provider.rs | 6 +- .../gateway-api/tests/admin/accounts/mod.rs | 2 +- .../crates/gateway-api/tests/diagnostics.rs | 2 +- .../tests/openai/chat_completions/http.rs | 148 +-- .../tests/openai/chat_completions/request.rs | 4 +- .../tests/openai/chat_completions/response.rs | 4 +- .../gateway-api/tests/openai/messages.rs | 305 +++++ .../crates/gateway-api/tests/openai/mod.rs | 1 + .../crates/gateway-api/tests/openai/models.rs | 90 ++ .../gateway-api/tests/openai/responses/mod.rs | 14 +- .../tests/openai/responses/websocket/mod.rs | 4 +- .../crates/gateway-api/tests/openai/router.rs | 11 +- .../gateway-api/tests/support/generation.rs | 149 +++ .../tests/{support.rs => support/mod.rs} | 2 + backend/crates/gateway-core/Cargo.toml | 1 + .../src/engine/middleware/contract.rs | 23 +- backend/crates/gateway-core/src/operation.rs | 106 +- .../tests/engine/middleware/mod.rs | 46 + .../gateway-plugin/sdk/docs/capabilities.md | 6 +- .../src/anthropic/capabilities.rs | 54 + .../gateway-protocol/src/anthropic/content.rs | 172 +++ .../gateway-protocol/src/anthropic/error.rs | 17 + .../gateway-protocol/src/anthropic/mod.rs | 30 + .../gateway-protocol/src/anthropic/request.rs | 555 +++++++++ .../src/anthropic/response.rs | 228 ++++ .../src/anthropic/stream/accumulator.rs | 254 ++++ .../src/anthropic/stream/mod.rs | 43 + .../src/anthropic/stream/to_messages.rs | 368 ++++++ .../src/anthropic/stream/to_responses.rs | 329 +++++ .../src/anthropic/thinking.rs | 163 +++ .../gateway-protocol/src/anthropic/tools.rs | 292 +++++ .../gateway-protocol/src/anthropic/usage.rs | 77 ++ backend/crates/gateway-protocol/src/lib.rs | 6 + .../crates/gateway-protocol/src/request.rs | 80 ++ .../tests/anthropic/capabilities.rs | 31 + .../gateway-protocol/tests/anthropic/mod.rs | 7 + .../tests/anthropic/request.rs | 590 +++++++++ .../tests/anthropic/response.rs | 50 + .../tests/anthropic/stream/accumulator.rs | 57 + .../tests/anthropic/stream/mod.rs | 4 + .../tests/anthropic/stream/translation.rs | 292 +++++ .../gateway-protocol/tests/anthropic/usage.rs | 27 + backend/crates/gateway-protocol/tests/main.rs | 2 + .../crates/gateway-protocol/tests/request.rs | 22 + backend/crates/providers/openai/Cargo.toml | 2 + .../providers/openai/src/compat/messages.rs | 44 + .../crates/providers/openai/src/compat/mod.rs | 2 + .../providers/openai/src/compat/request.rs | 7 + .../providers/openai/src/credential/admin.rs | 14 +- .../openai/src/credential/api_key.rs | 18 +- .../openai/src/credential/catalog.rs | 113 +- .../providers/openai/src/credential/codec.rs | 7 + .../providers/openai/src/credential/mod.rs | 4 +- .../openai/src/credential/selector.rs | 50 +- .../providers/openai/src/provider/failure.rs | 1 + .../openai/src/provider/messages/count.rs | 338 ++++++ .../openai/src/provider/messages/mod.rs | 284 +++++ .../openai/src/provider/messages/stream.rs | 487 ++++++++ .../src/provider/messages/translator.rs | 119 ++ .../providers/openai/src/provider/mod.rs | 20 +- .../openai/src/provider/observation.rs | 7 +- .../openai/src/provider/upstream_adapter.rs | 52 +- .../providers/openai/src/transport/catalog.rs | 19 +- .../providers/openai/src/transport/client.rs | 8 + .../openai/src/transport/client_catalog.rs | 73 +- .../openai/src/transport/client_messages.rs | 120 ++ .../providers/openai/src/transport/headers.rs | 14 +- .../providers/openai/src/transport/mod.rs | 1 + .../providers/openai/src/transport/request.rs | 2 +- .../providers/openai/src/transport/usage.rs | 21 +- .../providers/openai/tests/admin/mod.rs | 3 +- .../openai/tests/credential/admin.rs | 60 + .../tests/provider/contract/messages.rs | 815 +++++++++++++ .../openai/tests/provider/contract/mod.rs | 31 +- .../tests/provider/contract/passthrough.rs | 12 + .../provider/contract/search_model_access.rs | 65 + .../provider/contract/upstream_adapter.rs | 74 +- .../providers/openai/tests/provider/live.rs | 1 - .../crates/providers/openai/tests/support.rs | 17 + deploy/README.md | 2 +- docs/api.md | 173 ++- docs/architecture.md | 63 +- docs/development.md | 10 + .../src/api/modules/accounts/management.ts | 3 +- frontend/src/i18n/locales/en/accounts.json | 5 +- .../src/i18n/locales/zh-Hans/accounts.json | 5 +- .../src/i18n/locales/zh-Hant/accounts.json | 5 +- .../components/AccountApiKeyFields.vue | 34 +- .../accounts/components/AccountEditModal.vue | 7 +- .../components/AccountSettingsFields.vue | 6 +- .../composables/useAccountApiKeyFormRules.ts | 5 + .../accounts/composables/useAccountEditor.ts | 2 + .../composables/useAccountOnboarding.ts | 1 + .../views/accounts/utils/upstreamApiKey.ts | 7 +- 129 files changed, 9716 insertions(+), 1738 deletions(-) create mode 100644 backend/crates/gateway-api/src/openai/generation/http.rs create mode 100644 backend/crates/gateway-api/src/openai/generation/mod.rs create mode 100644 backend/crates/gateway-api/src/openai/generation/request.rs create mode 100644 backend/crates/gateway-api/src/openai/generation/response.rs create mode 100644 backend/crates/gateway-api/src/openai/generation/validation.rs create mode 100644 backend/crates/gateway-api/src/openai/messages.rs create mode 100644 backend/crates/gateway-api/tests/openai/messages.rs create mode 100644 backend/crates/gateway-api/tests/support/generation.rs rename backend/crates/gateway-api/tests/{support.rs => support/mod.rs} (99%) create mode 100644 backend/crates/gateway-protocol/src/anthropic/capabilities.rs create mode 100644 backend/crates/gateway-protocol/src/anthropic/content.rs create mode 100644 backend/crates/gateway-protocol/src/anthropic/error.rs create mode 100644 backend/crates/gateway-protocol/src/anthropic/mod.rs create mode 100644 backend/crates/gateway-protocol/src/anthropic/request.rs create mode 100644 backend/crates/gateway-protocol/src/anthropic/response.rs create mode 100644 backend/crates/gateway-protocol/src/anthropic/stream/accumulator.rs create mode 100644 backend/crates/gateway-protocol/src/anthropic/stream/mod.rs create mode 100644 backend/crates/gateway-protocol/src/anthropic/stream/to_messages.rs create mode 100644 backend/crates/gateway-protocol/src/anthropic/stream/to_responses.rs create mode 100644 backend/crates/gateway-protocol/src/anthropic/thinking.rs create mode 100644 backend/crates/gateway-protocol/src/anthropic/tools.rs create mode 100644 backend/crates/gateway-protocol/src/anthropic/usage.rs create mode 100644 backend/crates/gateway-protocol/src/request.rs create mode 100644 backend/crates/gateway-protocol/tests/anthropic/capabilities.rs create mode 100644 backend/crates/gateway-protocol/tests/anthropic/mod.rs create mode 100644 backend/crates/gateway-protocol/tests/anthropic/request.rs create mode 100644 backend/crates/gateway-protocol/tests/anthropic/response.rs create mode 100644 backend/crates/gateway-protocol/tests/anthropic/stream/accumulator.rs create mode 100644 backend/crates/gateway-protocol/tests/anthropic/stream/mod.rs create mode 100644 backend/crates/gateway-protocol/tests/anthropic/stream/translation.rs create mode 100644 backend/crates/gateway-protocol/tests/anthropic/usage.rs create mode 100644 backend/crates/gateway-protocol/tests/request.rs create mode 100644 backend/crates/providers/openai/src/compat/messages.rs create mode 100644 backend/crates/providers/openai/src/provider/messages/count.rs create mode 100644 backend/crates/providers/openai/src/provider/messages/mod.rs create mode 100644 backend/crates/providers/openai/src/provider/messages/stream.rs create mode 100644 backend/crates/providers/openai/src/provider/messages/translator.rs create mode 100644 backend/crates/providers/openai/src/transport/client_messages.rs create mode 100644 backend/crates/providers/openai/tests/provider/contract/messages.rs diff --git a/.gitignore b/.gitignore index 504aefc29..e868148a0 100644 --- a/.gitignore +++ b/.gitignore @@ -17,6 +17,9 @@ /.runtime/ *.log +# Local planning documents +/docs/plans/ + # Local configuration and secrets /deploy/config.yaml .env diff --git a/backend/Cargo.lock b/backend/Cargo.lock index 46608d5eb..b1ee28051 100644 --- a/backend/Cargo.lock +++ b/backend/Cargo.lock @@ -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" diff --git a/backend/apps/gateway/tests/architecture.rs b/backend/apps/gateway/tests/architecture.rs index bf7aedf08..2cfde3a7b 100644 --- a/backend/apps/gateway/tests/architecture.rs +++ b/backend/apps/gateway/tests/architecture.rs @@ -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"), diff --git a/backend/crates/gateway-api/src/admin/accounts/credentials.rs b/backend/crates/gateway-api/src/admin/accounts/credentials.rs index bc3f6a6ae..94cbf9ffc 100644 --- a/backend/crates/gateway-api/src/admin/accounts/credentials.rs +++ b/backend/crates/gateway-api/src/admin/accounts/credentials.rs @@ -276,6 +276,7 @@ impl UpdateAccountRequest { #[derive(Clone, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] pub struct AccountConnectionUpdateRequest { + pub protocol: Option, pub base_url: Option, pub transport: String, pub api_key: Option, @@ -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)); } diff --git a/backend/crates/gateway-api/src/admin/accounts/wire.rs b/backend/crates/gateway-api/src/admin/accounts/wire.rs index 1c108ce38..7a3d4945f 100644 --- a/backend/crates/gateway-api/src/admin/accounts/wire.rs +++ b/backend/crates/gateway-api/src/admin/accounts/wire.rs @@ -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, diff --git a/backend/crates/gateway-api/src/admin/plugins/management.rs b/backend/crates/gateway-api/src/admin/plugins/management.rs index 878334fe9..c59fab581 100644 --- a/backend/crates/gateway-api/src/admin/plugins/management.rs +++ b/backend/crates/gateway-api/src/admin/plugins/management.rs @@ -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 = Arc::new(PluginModelsAuthorization { state, target }); - let response = execute_prepared_responses( + let response = execute_prepared_generation( service, prepared, - ResponsesHttpRequest { + GenerationHttpRequest { peer_address: parts .extensions .get::>() @@ -158,6 +159,7 @@ async fn model_responses( middleware_body, }, Some(authorization), + None, ) .await; Ok(plugin_response(response)) diff --git a/backend/crates/gateway-api/src/lib.rs b/backend/crates/gateway-api/src/lib.rs index 42ad87eba..e52e287a4 100644 --- a/backend/crates/gateway-api/src/lib.rs +++ b/backend/crates/gateway-api/src/lib.rs @@ -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), diff --git a/backend/crates/gateway-api/src/openai/auth.rs b/backend/crates/gateway-api/src/openai/auth.rs index fb095905f..77daa0ba1 100644 --- a/backend/crates/gateway-api/src/openai/auth.rs +++ b/backend/crates/gateway-api/src/openai/auth.rs @@ -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 { - 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 { - 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 { - 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()), diff --git a/backend/crates/gateway-api/src/openai/chat_completions/http.rs b/backend/crates/gateway-api/src/openai/chat_completions/http.rs index b90f529f5..3ebbb81ad 100644 --- a/backend/crates/gateway-api/src/openai/chat_completions/http.rs +++ b/backend/crates/gateway-api/src/openai/chat_completions/http.rs @@ -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 = diff --git a/backend/crates/gateway-api/src/openai/endpoint.rs b/backend/crates/gateway-api/src/openai/endpoint.rs index 2d4ae76db..46ec66043 100644 --- a/backend/crates/gateway-api/src/openai/endpoint.rs +++ b/backend/crates/gateway-api/src/openai/endpoint.rs @@ -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) { diff --git a/backend/crates/gateway-api/src/openai/generation/http.rs b/backend/crates/gateway-api/src/openai/generation/http.rs new file mode 100644 index 000000000..99338aac4 --- /dev/null +++ b/backend/crates/gateway-api/src/openai/generation/http.rs @@ -0,0 +1,1065 @@ +//! 多协议 HTTP 生成与计数的执行交付和连接生命周期 + +use crate::request_context::request_client_context; + +use std::collections::VecDeque; +use std::future::Future; +use std::net::SocketAddr; +use std::sync::{ + Arc, OnceLock, + atomic::{AtomicBool, Ordering}, +}; +use std::time::Duration; + +use axum::{ + body::Bytes, + extract::Extension, + http::{ + HeaderMap, HeaderName, HeaderValue, StatusCode, + header::{CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE}, + }, + response::Response, +}; +use futures::future::BoxFuture; +use gateway_core::engine::{ + CommitRequirement, EngineError, + execution::{ClientTransport, ExecutionSession, PreparedRootExecution, StartedExecution}, + middleware::{ + MiddlewareBody, MiddlewareError, MiddlewareFrame, MiddlewareFraming, MiddlewareHeader, + MiddlewareResponse, + }, +}; +use gateway_core::error::{GatewayError, GatewayErrorKind}; +use gateway_core::event::{ProviderEvent, ProviderResponseHeader}; +use gateway_core::lifecycle::{CancellationToken, ConnectionGuard}; +use gateway_protocol::openai::sse::response_failed_sse_event_with_id; +use serde_json::Value; +use tokio::time::Instant; + +use crate::middleware::headers::encode_headers; +use crate::openai::error::{ + engine_error_response, gateway_error_from_engine, protocol_error_response, +}; +use crate::openai::middleware::{ + ExpectedBody, PendingExecution, RequestInput, error_response, finalize_session, + into_http_response, invoke_request, pending_execution_response, request_parts, +}; +use crate::openai::service::OpenAiService; + +use super::{ + DecodedGenerationRequest, GenerationProtocol, + response::GenerationEncoder, + validation::{GenerationDeliveryValidator, GenerationValidationFacts}, +}; + +const AUTHORIZATION_RECHECK_INTERVAL: Duration = Duration::from_secs(1); + +/// 管理页面模型桥在等待首帧和交付响应期间复核不可变插件目标 +pub(crate) trait ResponseAuthorization: Send + Sync { + fn authorize(&self) -> BoxFuture<'_, Result<(), GatewayError>>; +} + +/// 各协议入口共用的 HTTP 交付上下文 +pub(crate) struct GenerationHttpRequest { + pub peer_address: Option, + pub ingress_id: Option>, + pub headers: HeaderMap, + pub decoded: DecodedGenerationRequest, + pub middleware_body: Bytes, +} + +/// 下游协议只投影出口字节 执行会话和计量仍归原 owner +pub(crate) struct HttpResponseAdapter { + pub endpoint: &'static str, + pub wrap: Box MiddlewareResponse + Send>, + pub stream_error: fn(&Value) -> Bytes, +} + +pub(crate) async fn execute_prepared_generation( + service: OpenAiService, + prepared: PreparedRootExecution, + request: GenerationHttpRequest, + authorization: Option>, + adapter: Option, +) -> Response { + let GenerationHttpRequest { + peer_address, + ingress_id, + headers, + decoded, + middleware_body, + } = request; + let (client_ip, user_agent) = request_client_context(&headers, peer_address); + let protocol = GenerationProtocol::from_request(&decoded); + let stream = decoded.metadata().stream(); + let transport = if stream { + ClientTransport::HttpSse + } else { + ClientTransport::HttpJson + }; + let model_hint = Some(decoded.metadata().requested_model().to_owned()); + // 终端会重新校验中间件改写后的正文,初步解码不必保留到响应交付 + drop(decoded); + let execution = service.execution(); + let request_id = prepared.request_id().clone(); + let cancellation = prepared.cancellation(); + let execution_entered = Arc::new(AtomicBool::new(false)); + let terminal_entered = Arc::clone(&execution_entered); + let started_request_id = Arc::new(OnceLock::new()); + let terminal_request_id = Arc::clone(&started_request_id); + let (admitted, keepalive) = tokio::sync::oneshot::channel(); + let mut middleware_headers = headers.clone(); + // 中间件正文已经由入口按上限解压;传输编码和旧长度不能与改写后的正文混用 + middleware_headers.remove(CONTENT_ENCODING); + middleware_headers.remove(CONTENT_LENGTH); + let endpoint = adapter + .as_ref() + .map_or(protocol.endpoint(), |adapter| adapter.endpoint); + let stream_error = adapter + .as_ref() + .map(|adapter| adapter.stream_error) + .or_else(|| { + (protocol != GenerationProtocol::Responses) + .then_some(crate::openai::messages::stream_error as fn(&Value) -> Bytes) + }); + let input = RequestInput { + endpoint: endpoint.to_owned(), + protocol: protocol.wire().to_owned(), + operation: Some(protocol.operation()), + transport, + model_hint, + headers: encode_headers(&middleware_headers), + body: middleware_body, + }; + let terminal_service = service.clone(); + let validation = GenerationValidationFacts::new(protocol); + let terminal_validation = validation.clone(); + let middleware = invoke_request( + execution, + prepared, + input, + Box::new(move |prepared, request| { + Box::pin(async move { + let (wire_protocol, request_headers, request_body) = + request_parts(request.clone())?; + if wire_protocol != protocol.wire() { + return Err(MiddlewareError::Rejected); + } + let decoded = protocol + .decode( + &request_body, + &request_headers, + prepared + .client() + .snapshot() + .responses_max_decompressed_body_bytes(), + ) + .map_err(|_| MiddlewareError::Rejected)? + .with_client_context(client_ip, user_agent) + .with_middleware_capabilities(&request)?; + if decoded.metadata().stream() != stream { + return Err(MiddlewareError::Rejected); + } + let connection_guard = if stream { + Some( + terminal_service + .try_register_connection() + .map_err(|_| MiddlewareError::Fault)?, + ) + } else { + None + }; + terminal_entered.store(true, Ordering::Relaxed); + let started = terminal_service + .start_prepared_generation(prepared, decoded, transport, endpoint) + .await + .map_err(MiddlewareError::Gateway)?; + let _ = terminal_request_id.set(started.request_id.clone()); + started.session.trace().headers( + "client.request", + serde_json::json!({ + "ingressRequestId": ingress_id.as_ref().and_then(|Extension(id)| id.header_value().to_str().ok()), + }), + request_headers + .iter() + .map(|(name, value)| (name.as_str(), value.as_bytes())), + ); + started + .session + .trace() + .capture("client.request.body", &request_body); + let _ = admitted.send(started.session.response_commit()); + execution_middleware_response( + started, + connection_guard, + terminal_validation, + protocol, + ) + .await + }) + }), + ); + let response = async move { + let middleware = if let Some(authorization) = authorization.as_ref() { + match await_with_authorization(middleware, authorization, &cancellation).await { + Ok(result) => result, + Err(error) => Err(MiddlewareError::Gateway(error)), + } + } else { + middleware.await + }; + let expected = if stream { + ExpectedBody::Sse + } else { + ExpectedBody::SingleJson + }; + match middleware { + Ok(response) => { + let response = if let Some(authorization) = authorization { + authorized_middleware_response(response, authorization, cancellation) + } else { + response + }; + let response = + validated_middleware_response(response, validation, stream, protocol); + let response = match adapter { + Some(adapter) => (adapter.wrap)(response), + None => response, + }; + into_http_response(response, expected, protocol.wire()).await + } + Err(error) => error_response(error), + } + }; + let response = if stream { + crate::openai::responses::keepalive::response_with_encoder( + response, + keepalive, + stream_error, + protocol == GenerationProtocol::Responses, + ) + .await + } else { + response.await + }; + let response = if protocol == GenerationProtocol::Responses { + response + } else { + crate::openai::messages::project_error_response(response).await + }; + // 预留 ID 没有对应执行记录,中间件提前返回时保留 HTTP 入口关联 ID + if execution_entered.load(Ordering::Relaxed) { + crate::openai::with_model_request_id( + response, + started_request_id.get().unwrap_or(&request_id), + ) + } else { + response + } +} + +async fn await_with_authorization( + future: impl Future, + authorization: &Arc, + cancellation: &CancellationToken, +) -> Result { + tokio::pin!(future); + loop { + tokio::select! { + output = &mut future => return Ok(output), + () = tokio::time::sleep(AUTHORIZATION_RECHECK_INTERVAL) => { + if let Err(error) = authorization.authorize().await { + cancellation.cancel(); + return Err(error); + } + } + } + } +} + +fn authorized_middleware_response( + response: MiddlewareResponse, + authorization: Arc, + cancellation: CancellationToken, +) -> MiddlewareResponse { + let (protocol, status, headers, body, envelope) = response.into_parts(); + let mut response = MiddlewareResponse::new( + protocol, + status, + headers, + Box::new(AuthorizedResponseBody { + inner: Some(body), + authorization, + cancellation, + last_authorized_at: Instant::now(), + }), + ); + if let Some(envelope) = envelope { + response = response.with_envelope(envelope); + } + response +} + +struct AuthorizedResponseBody { + inner: Option>, + authorization: Arc, + cancellation: CancellationToken, + last_authorized_at: Instant, +} + +impl AuthorizedResponseBody { + async fn revoke(&mut self, error: GatewayError) -> MiddlewareError { + self.cancellation.cancel(); + if let Some(inner) = self.inner.take() { + inner.close().await; + } + MiddlewareError::Gateway(error) + } +} + +impl MiddlewareBody for AuthorizedResponseBody { + fn next_frame(&mut self) -> BoxFuture<'_, Result, MiddlewareError>> { + Box::pin(async move { + if self.last_authorized_at.elapsed() >= AUTHORIZATION_RECHECK_INTERVAL { + if let Err(error) = self.authorization.authorize().await { + return Err(self.revoke(error).await); + } + self.last_authorized_at = Instant::now(); + } + let error = { + let Some(inner) = self.inner.as_mut() else { + return Ok(None); + }; + // 复核身份只暂停同一次读取,不能丢弃已经消费上游事件的 future + let frame = inner.next_frame(); + tokio::pin!(frame); + loop { + let elapsed = self.last_authorized_at.elapsed(); + if elapsed >= AUTHORIZATION_RECHECK_INTERVAL { + if let Err(error) = self.authorization.authorize().await { + break error; + } + self.last_authorized_at = Instant::now(); + continue; + } + let wait = AUTHORIZATION_RECHECK_INTERVAL - elapsed; + tokio::select! { + result = &mut frame => return result, + () = tokio::time::sleep(wait) => {} + } + } + }; + Err(self.revoke(error).await) + }) + } + + fn commit_downstream( + &mut self, + client_status_code: Option, + ) -> BoxFuture<'_, Result<(), MiddlewareError>> { + let Some(inner) = self.inner.as_mut() else { + return Box::pin(async { Err(MiddlewareError::InvalidState) }); + }; + inner.commit_downstream(client_status_code) + } + + fn record_client_status( + &mut self, + client_status_code: u16, + ) -> BoxFuture<'_, Result<(), MiddlewareError>> { + let Some(inner) = self.inner.as_mut() else { + return Box::pin(async { Ok(()) }); + }; + inner.record_client_status(client_status_code) + } + + fn is_finalized(&self) -> bool { + self.inner.as_ref().is_none_or(|inner| inner.is_finalized()) + } + + fn close(mut self: Box) -> BoxFuture<'static, ()> { + let inner = self.inner.take(); + Box::pin(async move { + if let Some(inner) = inner { + inner.close().await; + } + }) + } +} + +async fn execution_middleware_response( + started: StartedExecution, + connection_guard: Option>, + validation: GenerationValidationFacts, + protocol: GenerationProtocol, +) -> Result { + let StartedExecution { + stream, session, .. + } = started; + if stream { + streaming_execution_middleware_response(session, connection_guard, validation, protocol) + .await + } else { + drop(connection_guard); + buffered_execution_middleware_response(session, validation, protocol).await + } +} + +async fn buffered_execution_middleware_response( + session: Box, + validation: GenerationValidationFacts, + protocol: GenerationProtocol, +) -> Result { + let mut execution = PendingExecution::new(session); + let collected = execution + .session_mut() + .ok_or(MiddlewareError::InvalidState)? + .collect_uncommitted() + .await; + let events = match collected { + Ok(events) => events, + Err(error) => { + let headers = execution + .session_mut() + .ok_or(MiddlewareError::InvalidState)? + .response_headers() + .to_vec(); + return guarded_engine_error_response(execution, &error, &headers, protocol).await; + } + }; + let transformed = events.iter().any(ProviderEvent::middleware_transformed); + let encoded = match protocol.collect(&events) { + Ok(encoded) => Bytes::from(encoded), + Err(error) => { + let response = + protocol_error_response(StatusCode::INTERNAL_SERVER_ERROR, error.protocol_body()); + return guarded_http_response(execution, response, protocol).await; + } + }; + validation.observe_buffered(&events, &encoded); + let session = execution + .session_mut() + .ok_or(MiddlewareError::InvalidState)?; + session.trace().record( + "downstream.encoded", + serde_json::json!({"transport": "http_json", "bytes": encoded.len()}), + ); + session.trace().dump("downstream.body", &encoded); + let headers = response_headers(session.response_headers(), false); + Ok(pending_execution_response( + protocol.wire().to_owned(), + StatusCode::OK.as_u16(), + headers, + MiddlewareFrame::new(encoded, MiddlewareFraming::JsonDocument, true) + .with_transformed(transformed), + execution, + )) +} + +async fn streaming_execution_middleware_response( + session: Box, + connection_guard: Option>, + validation: GenerationValidationFacts, + protocol: GenerationProtocol, +) -> Result { + let mut body = StreamingExecutionBody::new(session, connection_guard, validation, protocol); + if let Err(error) = body.prime().await { + let headers = body.response_headers().to_vec(); + let execution = body.take_pending_execution()?; + return match error { + MiddlewareError::Engine(error) => { + guarded_engine_error_response(execution, &error, &headers, protocol).await + } + error => guarded_http_response(execution, error_response(error), protocol).await, + }; + } + let headers = response_headers(body.response_headers(), true); + Ok(MiddlewareResponse::new( + protocol.wire().to_owned(), + StatusCode::OK.as_u16(), + headers, + Box::new(body), + )) +} + +/// 直接驱动测试 session 的非流式交付;生产入口通过同一 MiddlewareResponse 路径 +pub async fn collect_execution_response(session: Box) -> Response { + match buffered_execution_middleware_response( + session, + GenerationValidationFacts::new(GenerationProtocol::Responses), + GenerationProtocol::Responses, + ) + .await + { + Ok(response) => into_http_response(response, ExpectedBody::SingleJson, "openai").await, + Err(error) => error_response(error), + } +} + +/// 直接驱动测试 session 的 SSE 交付;生产入口通过同一 MiddlewareResponse 路径 +pub async fn stream_execution_response( + session: Box, + connection_guard: Option>, +) -> Response { + let (admitted, keepalive) = tokio::sync::oneshot::channel(); + let _ = admitted.send(session.response_commit()); + crate::openai::responses::keepalive::response( + async move { + match streaming_execution_middleware_response( + session, + connection_guard, + GenerationValidationFacts::new(GenerationProtocol::Responses), + GenerationProtocol::Responses, + ) + .await + { + Ok(response) => into_http_response(response, ExpectedBody::Sse, "openai").await, + Err(error) => error_response(error), + } + }, + keepalive, + ) + .await +} + +fn validated_middleware_response( + response: MiddlewareResponse, + facts: GenerationValidationFacts, + streaming: bool, + protocol: GenerationProtocol, +) -> MiddlewareResponse { + if !(200..300).contains(&response.status_code()) { + // 非成功响应沿用通用 SinglePayload 边界,不能套用成功 Responses 终态状态机 + return response; + } + let (wire_protocol, status, headers, body, envelope) = response.into_parts(); + let mut response = MiddlewareResponse::new( + wire_protocol, + status, + headers, + Box::new(ValidatedGenerationBody { + inner: Some(body), + facts, + streaming, + validator: GenerationDeliveryValidator::new(protocol), + protocol, + pending: VecDeque::new(), + committed: false, + }), + ); + if let Some(envelope) = envelope { + response = response.with_envelope(envelope); + } + response +} + +struct ValidatedGenerationBody { + inner: Option>, + facts: GenerationValidationFacts, + streaming: bool, + validator: GenerationDeliveryValidator, + protocol: GenerationProtocol, + pending: VecDeque, + committed: bool, +} + +impl ValidatedGenerationBody { + async fn fail_stream(&mut self) -> Option { + if let Some(inner) = self.inner.take() { + inner.close().await; + } + let response_id = self + .validator + .response_id() + .map(str::to_owned) + .or_else(|| self.facts.response_id()); + self.pending.push_back(MiddlewareFrame::new( + if self.protocol == GenerationProtocol::Responses { + Bytes::from(response_failed_sse_event_with_id(response_id.as_deref(), "server_error", "middleware_failed", "Response middleware returned an invalid stream.")) + } else { + crate::openai::messages::stream_error(&serde_json::json!({"error":{"message":"Response middleware returned an invalid stream."}})) + }, + MiddlewareFraming::SseEvent, + false, + )); + self.pending.push_back(done_frame(self.protocol)); + self.pending.pop_front() + } +} + +impl MiddlewareBody for ValidatedGenerationBody { + fn next_frame(&mut self) -> BoxFuture<'_, Result, MiddlewareError>> { + Box::pin(async move { + if let Some(frame) = self.pending.pop_front() { + return Ok(Some(frame)); + } + let Some(inner) = self.inner.as_mut() else { + return Ok(None); + }; + let frame = match inner.next_frame().await { + Ok(frame) => frame, + Err(error) if self.streaming && self.committed => { + let _ = error; + return Ok(self.fail_stream().await); + } + Err(error) => return Err(error), + }; + let Some(frame) = frame else { + if self.streaming && self.validator.finish_delivery().is_err() { + if self.committed { + return Ok(self.fail_stream().await); + } + return Err(MiddlewareError::InvalidState); + } + return Ok(None); + }; + let valid = if self.streaming { + self.validator + .validate_frame(frame.bytes(), frame.transformed(), &self.facts) + } else if frame.transformed() { + self.facts.validate_buffered(frame.bytes()) + } else { + Ok(()) + }; + if valid.is_err() { + if self.streaming && self.committed { + return Ok(self.fail_stream().await); + } + return Err(MiddlewareError::InvalidState); + } + Ok(Some(frame)) + }) + } + + fn commit_downstream( + &mut self, + client_status_code: Option, + ) -> BoxFuture<'_, Result<(), MiddlewareError>> { + Box::pin(async move { + let Some(inner) = self.inner.as_mut() else { + return Err(MiddlewareError::InvalidState); + }; + inner.commit_downstream(client_status_code).await?; + self.committed = true; + Ok(()) + }) + } + + fn record_client_status( + &mut self, + client_status_code: u16, + ) -> BoxFuture<'_, Result<(), MiddlewareError>> { + Box::pin(async move { + match self.inner.as_mut() { + Some(inner) => inner.record_client_status(client_status_code).await, + None => Ok(()), + } + }) + } + + fn is_finalized(&self) -> bool { + self.inner.as_ref().is_none_or(|inner| inner.is_finalized()) + } + + fn close(mut self: Box) -> BoxFuture<'static, ()> { + let inner = self.inner.take(); + Box::pin(async move { + if let Some(inner) = inner { + inner.close().await; + } + }) + } +} + +async fn guarded_engine_error_response( + execution: PendingExecution, + error: &EngineError, + response_headers: &[ProviderResponseHeader], + protocol: GenerationProtocol, +) -> Result { + guarded_http_response( + execution, + engine_error_response_with_headers(error, response_headers), + protocol, + ) + .await +} + +async fn guarded_http_response( + execution: PendingExecution, + response: Response, + protocol: GenerationProtocol, +) -> Result { + let response = if protocol == GenerationProtocol::Responses { + response + } else { + crate::openai::messages::project_error_response(response).await + }; + let (parts, body) = response.into_parts(); + let bytes = axum::body::to_bytes(body, usize::MAX) + .await + .map_err(|_| MiddlewareError::Fault)?; + Ok(pending_execution_response( + protocol.wire().to_owned(), + parts.status.as_u16(), + encode_headers(&parts.headers), + MiddlewareFrame::new(bytes, MiddlewareFraming::RawBytes, true), + execution, + )) +} + +fn engine_error_response_with_headers( + error: &EngineError, + response_headers: &[ProviderResponseHeader], +) -> Response { + let response = engine_error_response(error); + let failure_request_ids = ["x-request-id", "x-oai-request-id"] + .into_iter() + .flat_map(|name| { + response + .headers() + .get_all(name) + .iter() + .cloned() + .map(move |value| (name, value)) + }) + .collect::>(); + // 失败后仍须交付已采集的 turn state;只隔离 opening 身份,不丢弃会话状态 + let mut response = apply_provider_response_headers(response, response_headers); + response.headers_mut().remove("x-request-id"); + response.headers_mut().remove("x-oai-request-id"); + for (name, value) in failure_request_ids { + response.headers_mut().append(name, value); + } + response +} + +fn apply_provider_response_headers( + mut response: Response, + response_headers: &[ProviderResponseHeader], +) -> Response { + let connection_options = + crate::openai::responses::response_connection_options(response_headers); + for header in response_headers { + if !crate::openai::responses::response_header_is_forwardable( + header.name(), + &connection_options, + ) { + continue; + } + let Ok(name) = HeaderName::from_bytes(header.name().as_bytes()) else { + continue; + }; + let Ok(value) = HeaderValue::from_bytes(header.value()) else { + continue; + }; + response.headers_mut().append(name, value); + } + response +} + +fn response_headers( + provider_headers: &[ProviderResponseHeader], + streaming: bool, +) -> Vec { + let connection_options = + crate::openai::responses::response_connection_options(provider_headers); + let mut headers = Vec::new(); + headers.push(MiddlewareHeader::new( + CONTENT_TYPE.as_str(), + Bytes::from_static(if streaming { + b"text/event-stream" + } else { + b"application/json" + }), + )); + for header in provider_headers { + if !crate::openai::responses::response_header_is_forwardable( + header.name(), + &connection_options, + ) || header.name().eq_ignore_ascii_case(CONTENT_TYPE.as_str()) + || HeaderName::from_bytes(header.name().as_bytes()).is_err() + || HeaderValue::from_bytes(header.value()).is_err() + { + continue; + } + headers.push(MiddlewareHeader::new( + header.name(), + Bytes::copy_from_slice(header.value()), + )); + } + headers +} + +struct StreamingExecutionBody { + session: Option>, + encoder: GenerationEncoder, + protocol: GenerationProtocol, + validation: GenerationValidationFacts, + pending: VecDeque, + awaiting_terminal_eof: bool, + output_finished: bool, + batch_pending: bool, + transformed_pending: bool, + committed: bool, + _connection_guard: Option>, +} + +impl StreamingExecutionBody { + fn new( + session: Box, + connection_guard: Option>, + validation: GenerationValidationFacts, + protocol: GenerationProtocol, + ) -> Self { + Self { + session: Some(session), + encoder: GenerationEncoder::new(protocol), + protocol, + validation, + pending: VecDeque::new(), + awaiting_terminal_eof: false, + output_finished: false, + batch_pending: false, + transformed_pending: false, + committed: false, + _connection_guard: connection_guard, + } + } + + async fn prime(&mut self) -> Result<(), MiddlewareError> { + self.fill_pending().await?; + if self.pending.is_empty() { + return Err(MiddlewareError::InvalidState); + } + Ok(()) + } + + fn response_headers(&self) -> &[ProviderResponseHeader] { + self.session + .as_ref() + .map_or(&[], |session| session.response_headers()) + } + + async fn fill_pending(&mut self) -> Result<(), MiddlewareError> { + while self.pending.is_empty() && !self.output_finished { + if self.awaiting_terminal_eof { + if !self.committed { + // 终态 wire 不能在首字节前被中间件整批移除 + return Err(MiddlewareError::InvalidState); + } + self.verify_terminal_eof().await?; + self.pending.push_back(done_frame(self.protocol)); + self.output_finished = true; + continue; + } + if self.batch_pending { + if !self.committed { + self.session + .as_mut() + .ok_or(MiddlewareError::InvalidState)? + .discard_pending_delivery() + .map_err(MiddlewareError::Engine)?; + } + self.batch_pending = false; + } + let result = self + .session + .as_mut() + .ok_or(MiddlewareError::InvalidState)? + .next_event() + .await; + let coordinated = match result { + Ok(Some(event)) => event, + Ok(None) if self.committed && self.is_finalized() => { + self.pending.push_back(done_frame(self.protocol)); + self.output_finished = true; + continue; + } + Ok(None) => return Err(invalid_execution_stream()), + Err(error) if self.committed => { + self.push_stream_error(gateway_error_from_engine(&error)); + continue; + } + Err(error) => return Err(MiddlewareError::Engine(error)), + }; + let expected = if self.committed { + CommitRequirement::AlreadyCommitted + } else { + CommitRequirement::CommitBeforeDelivery + }; + if coordinated.commit_requirement() != expected { + return Err(invalid_execution_stream()); + } + let mut encoded = VecDeque::new(); + for event in coordinated.into_provider_events() { + self.validation.observe_event(&event); + let transformed = self.transformed_pending || event.middleware_transformed(); + let frames = self.encoder.push_sse(&event); + if frames.is_empty() { + self.transformed_pending = transformed; + continue; + } + encoded.extend(frames.into_iter().map(|bytes| { + MiddlewareFrame::new(bytes, MiddlewareFraming::SseEvent, false) + .with_transformed(transformed) + })); + self.transformed_pending = false; + } + self.awaiting_terminal_eof = + self.encoder.is_completed() || self.encoder.has_wire_failure(); + self.batch_pending = !self.committed; + if encoded.is_empty() { + if !self.committed || self.awaiting_terminal_eof { + return Err(invalid_execution_stream()); + } + continue; + } + // 已提交的流先确认 Core 终结,避免后续 EOF 验证推翻已交付的成功终态 + if self.awaiting_terminal_eof && self.committed { + self.verify_terminal_eof().await?; + encoded.push_back(done_frame(self.protocol)); + self.output_finished = true; + } + self.pending = encoded; + } + Ok(()) + } + + async fn verify_terminal_eof(&mut self) -> Result<(), MiddlewareError> { + let result = self + .session + .as_mut() + .ok_or(MiddlewareError::InvalidState)? + .next_event() + .await; + match result { + Ok(None) if self.is_finalized() => Ok(()), + Err(_) if self.encoder.has_wire_failure() && self.is_finalized() => Ok(()), + Ok(_) => Err(invalid_execution_stream()), + Err(error) => Err(MiddlewareError::Engine(error)), + } + } + + fn push_stream_error(&mut self, error: GatewayError) { + self.pending.push_back(MiddlewareFrame::new( + self.encoder.error_frame(&error), + MiddlewareFraming::SseEvent, + false, + )); + self.pending.push_back(done_frame(self.protocol)); + self.output_finished = true; + } + + fn take_session_for_close(&mut self) -> Option> { + self.session.take() + } + + fn take_pending_execution(&mut self) -> Result { + self.take_session_for_close() + .map(PendingExecution::new) + .ok_or(MiddlewareError::InvalidState) + } +} + +impl MiddlewareBody for StreamingExecutionBody { + fn next_frame(&mut self) -> BoxFuture<'_, Result, MiddlewareError>> { + Box::pin(async move { + if let Some(frame) = self.pending.pop_front() { + return Ok(Some(frame)); + } + if self.output_finished { + return Ok(None); + } + if let Err(error) = self.fill_pending().await { + if !self.committed { + return Err(error); + } + let error = match error { + MiddlewareError::Gateway(error) => error, + MiddlewareError::Engine(error) => gateway_error_from_engine(&error), + _ => GatewayError::new( + GatewayErrorKind::Internal, + "Gateway response stream could not be delivered.", + ), + }; + self.push_stream_error(error); + } + Ok(self.pending.pop_front()) + }) + } + + fn commit_downstream( + &mut self, + client_status_code: Option, + ) -> BoxFuture<'_, Result<(), MiddlewareError>> { + Box::pin(async move { + if self.committed { + return Ok(()); + } + self.session + .as_mut() + .ok_or(MiddlewareError::InvalidState)? + .commit_downstream(client_status_code) + .await + .map_err(MiddlewareError::Engine)?; + self.committed = true; + self.batch_pending = false; + Ok(()) + }) + } + + fn record_client_status( + &mut self, + client_status_code: u16, + ) -> BoxFuture<'_, Result<(), MiddlewareError>> { + Box::pin(async move { + let Some(session) = self.session.as_mut() else { + return Ok(()); + }; + session + .record_client_status(client_status_code) + .await + .map_err(MiddlewareError::Engine) + }) + } + + fn is_finalized(&self) -> bool { + self.session + .as_ref() + .is_none_or(|session| session.is_finalized()) + } + + fn close(mut self: Box) -> BoxFuture<'static, ()> { + let session = self.take_session_for_close(); + Box::pin(async move { + if let Some(session) = session { + finalize_session(session).await; + } + }) + } +} + +impl Drop for StreamingExecutionBody { + fn drop(&mut self) { + let Some(session) = self.take_session_for_close() else { + return; + }; + session.cancel(); + let finalize = session.detach_finalize(); + if let Ok(runtime) = tokio::runtime::Handle::try_current() { + drop(runtime.spawn(finalize)); + } + } +} + +fn done_frame(protocol: GenerationProtocol) -> MiddlewareFrame { + MiddlewareFrame::new(protocol.terminal_bytes(), MiddlewareFraming::SseEvent, true) +} + +fn invalid_execution_stream() -> MiddlewareError { + MiddlewareError::Gateway(GatewayError::new( + GatewayErrorKind::Internal, + "Gateway response stream violated its execution lifecycle.", + )) +} diff --git a/backend/crates/gateway-api/src/openai/generation/mod.rs b/backend/crates/gateway-api/src/openai/generation/mod.rs new file mode 100644 index 000000000..2363be157 --- /dev/null +++ b/backend/crates/gateway-api/src/openai/generation/mod.rs @@ -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 { + 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) + } + } + } +} diff --git a/backend/crates/gateway-api/src/openai/generation/request.rs b/backend/crates/gateway-api/src/openai/generation/request.rs new file mode 100644 index 000000000..e860da227 --- /dev/null +++ b/backend/crates/gateway-api/src/openai/generation/request.rs @@ -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()"), + } + } +} + +/// 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, + pub(in crate::openai) user_agent: Option, +} + +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 { + 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.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, + user_agent: Option, + ) -> 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() + } +} diff --git a/backend/crates/gateway-api/src/openai/generation/response.rs b/backend/crates/gateway-api/src/openai/generation/response.rs new file mode 100644 index 000000000..349ae0a83 --- /dev/null +++ b/backend/crates/gateway-api/src/openai/generation/response.rs @@ -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, + 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 { + 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, 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) + } +} diff --git a/backend/crates/gateway-api/src/openai/generation/validation.rs b/backend/crates/gateway-api/src/openai/generation/validation.rs new file mode 100644 index 000000000..bca1e297d --- /dev/null +++ b/backend/crates/gateway-api/src/openai/generation/validation.rs @@ -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>>), + 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::(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 { + 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::(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, 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(()), + } + } +} diff --git a/backend/crates/gateway-api/src/openai/images/http.rs b/backend/crates/gateway-api/src/openai/images/http.rs index d2bc3d58c..379bb6fe3 100644 --- a/backend/crates/gateway-api/src/openai/images/http.rs +++ b/backend/crates/gateway-api/src/openai/images/http.rs @@ -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), }; diff --git a/backend/crates/gateway-api/src/openai/live/http.rs b/backend/crates/gateway-api/src/openai/live/http.rs index 4f2da1c05..56744118c 100644 --- a/backend/crates/gateway-api/src/openai/live/http.rs +++ b/backend/crates/gateway-api/src/openai/live/http.rs @@ -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), }; diff --git a/backend/crates/gateway-api/src/openai/live/websocket.rs b/backend/crates/gateway-api/src/openai/live/websocket.rs index 648ac7876..6d8489229 100644 --- a/backend/crates/gateway-api/src/openai/live/websocket.rs +++ b/backend/crates/gateway-api/src/openai/live/websocket.rs @@ -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), }; diff --git a/backend/crates/gateway-api/src/openai/messages.rs b/backend/crates/gateway-api/src/openai/messages.rs new file mode 100644 index 000000000..c72697fd4 --- /dev/null +++ b/backend/crates/gateway-api/src/openai/messages.rs @@ -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, + connect_info: Option>>, + ingress_id: Option>, + 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, + connect_info: Option>>, + ingress_id: Option>, + headers: HeaderMap, + body: Bytes, +) -> Response { + execute( + state, + connect_info, + ingress_id, + headers, + body, + GenerationProtocol::MessageTokenCount, + ) + .await +} + +async fn execute( + state: ApiState, + connect_info: Option>>, + ingress_id: Option>, + 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 { + 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::(&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(), + )) +} diff --git a/backend/crates/gateway-api/src/openai/middleware/http.rs b/backend/crates/gateway-api/src/openai/middleware/http.rs index b02ab2a81..6064cfe4f 100644 --- a/backend/crates/gateway-api/src/openai/middleware/http.rs +++ b/backend/crates/gateway-api/src/openai/middleware/http.rs @@ -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); diff --git a/backend/crates/gateway-api/src/openai/middleware/request.rs b/backend/crates/gateway-api/src/openai/middleware/request.rs index c6a661be7..ff14b7e13 100644 --- a/backend/crates/gateway-api/src/openai/middleware/request.rs +++ b/backend/crates/gateway-api/src/openai/middleware/request.rs @@ -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), } } diff --git a/backend/crates/gateway-api/src/openai/mod.rs b/backend/crates/gateway-api/src/openai/mod.rs index 3ef984862..da031951f 100644 --- a/backend/crates/gateway-api/src/openai/mod.rs +++ b/backend/crates/gateway-api/src/openai/mod.rs @@ -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; diff --git a/backend/crates/gateway-api/src/openai/models.rs b/backend/crates/gateway-api/src/openai/models.rs index 596e25b2e..1b85cecfb 100644 --- a/backend/crates/gateway-api/src/openai/models.rs +++ b/backend/crates/gateway-api/src/openai/models.rs @@ -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, + after_id: Option, + before_id: Option, + limit: Option, } /// `GET /v1/models` @@ -38,28 +41,37 @@ pub(crate) async fn models( Query(query): Query, 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, ) -> 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, query: &ModelsQuery) -> Response { + let limit = match query.limit.as_deref().unwrap_or("20").parse::() { + 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| -> Result, ()> { + 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::>(); + 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, diff --git a/backend/crates/gateway-api/src/openai/responses/http.rs b/backend/crates/gateway-api/src/openai/responses/http.rs index 93913b513..49af3ede2 100644 --- a/backend/crates/gateway-api/src/openai/responses/http.rs +++ b/backend/crates/gateway-api/src/openai/responses/http.rs @@ -1,70 +1,21 @@ -//! OpenAI Responses HTTP 与 SSE adapter +//! Responses HTTP 入口的认证和解码 -use crate::request_context::request_client_context; - -use std::collections::VecDeque; -use std::future::Future; -use std::net::SocketAddr; -use std::sync::{ - Arc, OnceLock, - atomic::{AtomicBool, Ordering}, +use super::request::decode_request_with_body; +use crate::{ + ApiState, + openai::{ + auth::{ClientKeyHeaders, authenticate_client, client_access_error_response}, + error::gateway_error_response, + generation::{GenerationHttpRequest, execute_prepared_generation}, + }, }; -use std::time::Duration; - use axum::{ body::Bytes, extract::{Extension, State, connect_info::ConnectInfo}, - http::{ - HeaderMap, HeaderName, HeaderValue, StatusCode, - header::{CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE}, - }, + http::{HeaderMap, StatusCode}, response::Response, }; -use futures::future::BoxFuture; -use gateway_core::engine::{ - CommitRequirement, EngineError, - execution::{ClientTransport, ExecutionSession, PreparedRootExecution, StartedExecution}, - middleware::{ - MiddlewareBody, MiddlewareError, MiddlewareFrame, MiddlewareFraming, MiddlewareHeader, - MiddlewareResponse, - }, -}; -use gateway_core::error::{GatewayError, GatewayErrorKind}; -use gateway_core::event::{ProviderEvent, ProviderResponseHeader}; -use gateway_core::lifecycle::{CancellationToken, ConnectionGuard}; -use gateway_core::operation::OperationKind; -use gateway_protocol::openai::sse::{DONE_SSE_FRAME, response_failed_sse_event_with_id}; -use serde_json::Value; -use tokio::time::Instant; - -use crate::ApiState; -use crate::middleware::headers::encode_headers; -use crate::openai::middleware::{ - ExpectedBody, PendingExecution, RequestInput, error_response, finalize_session, - into_http_response, invoke_request, pending_execution_response, request_parts, -}; -use crate::openai::service::OpenAiService; -use crate::openai::{ - auth::{authenticate_client, client_access_error_response}, - error::{ - engine_error_response, gateway_error_contract, gateway_error_from_engine, - gateway_error_response, protocol_error_response, - }, -}; - -use super::{ - OpenAiResponsesEncoder, ResponseEncodeError, - request::{DecodedResponsesRequest, decode_request_with_body, decode_request_with_headers}, - validation::{ResponseValidationFacts, ResponsesDeliveryValidator, validate_buffered_response}, -}; - -const OPENAI_PROTOCOL: &str = "openai"; -const AUTHORIZATION_RECHECK_INTERVAL: Duration = Duration::from_secs(1); - -/// 管理页面模型桥在等待首帧和交付响应期间复核不可变插件目标 -pub(crate) trait ResponseAuthorization: Send + Sync { - fn authorize(&self) -> BoxFuture<'_, Result<(), GatewayError>>; -} +use std::net::SocketAddr; /// `POST /v1/responses` pub(crate) async fn responses( @@ -75,7 +26,7 @@ pub(crate) async fn responses( 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), }; @@ -95,10 +46,10 @@ pub(crate) async fn responses( Ok(prepared) => prepared, Err(error) => return gateway_error_response(&error), }; - execute_prepared_responses( + execute_prepared_generation( service, prepared, - ResponsesHttpRequest { + GenerationHttpRequest { peer_address: connect_info.map(|Extension(ConnectInfo(address))| address), ingress_id, headers, @@ -106,982 +57,7 @@ pub(crate) async fn responses( middleware_body, }, None, + None, ) .await } - -/// 两个 Responses 入口共享解码后的 HTTP 交付上下文,不携带认证策略 -pub(crate) struct ResponsesHttpRequest { - pub peer_address: Option, - pub ingress_id: Option>, - pub headers: HeaderMap, - pub decoded: DecodedResponsesRequest, - pub middleware_body: Bytes, -} - -pub(crate) async fn execute_prepared_responses( - service: OpenAiService, - prepared: PreparedRootExecution, - request: ResponsesHttpRequest, - authorization: Option>, -) -> Response { - execute_prepared_response(service, prepared, request, authorization, None).await -} - -/// 下游协议只投影出口字节 执行会话和计量仍归原 owner -pub(in crate::openai) struct HttpResponseAdapter { - pub endpoint: &'static str, - pub wrap: Box MiddlewareResponse + Send>, - pub stream_error: fn(&Value) -> Bytes, -} - -pub(in crate::openai) async fn execute_prepared_response( - service: OpenAiService, - prepared: PreparedRootExecution, - request: ResponsesHttpRequest, - authorization: Option>, - adapter: Option, -) -> Response { - let ResponsesHttpRequest { - peer_address, - ingress_id, - headers, - decoded, - middleware_body, - } = request; - let (client_ip, user_agent) = request_client_context(&headers, peer_address); - let stream = decoded.metadata().stream(); - let transport = if stream { - ClientTransport::HttpSse - } else { - ClientTransport::HttpJson - }; - let model_hint = Some(decoded.metadata().requested_model().to_owned()); - // 终端会重新校验中间件改写后的正文,初步解码不必保留到响应交付 - drop(decoded); - let execution = service.execution(); - let request_id = prepared.request_id().clone(); - let cancellation = prepared.cancellation(); - let execution_entered = Arc::new(AtomicBool::new(false)); - let terminal_entered = Arc::clone(&execution_entered); - let started_request_id = Arc::new(OnceLock::new()); - let terminal_request_id = Arc::clone(&started_request_id); - let (admitted, keepalive) = tokio::sync::oneshot::channel(); - let mut middleware_headers = headers.clone(); - // 中间件正文已经由入口按上限解压;传输编码和旧长度不能与改写后的正文混用 - middleware_headers.remove(CONTENT_ENCODING); - middleware_headers.remove(CONTENT_LENGTH); - let endpoint = adapter - .as_ref() - .map_or(crate::openai::router::RESPONSES_PATH, |adapter| { - adapter.endpoint - }); - let stream_error = adapter.as_ref().map(|adapter| adapter.stream_error); - let input = RequestInput { - endpoint: endpoint.to_owned(), - protocol: OPENAI_PROTOCOL.to_owned(), - operation: Some(OperationKind::Generate), - transport, - model_hint, - headers: encode_headers(&middleware_headers), - body: middleware_body, - }; - let terminal_service = service.clone(); - let validation = ResponseValidationFacts::default(); - let terminal_validation = validation.clone(); - let middleware = invoke_request( - execution, - prepared, - input, - Box::new(move |prepared, request| { - Box::pin(async move { - let (protocol, request_headers, request_body) = request_parts(request.clone())?; - if protocol != OPENAI_PROTOCOL { - return Err(MiddlewareError::Rejected); - } - let decoded = decode_request_with_headers( - &request_body, - &request_headers, - prepared - .client() - .snapshot() - .responses_max_decompressed_body_bytes(), - ) - .map_err(|_| MiddlewareError::Rejected)? - .with_client_context(client_ip, user_agent) - .with_middleware_capabilities(&request)?; - if decoded.metadata().stream() != stream { - return Err(MiddlewareError::Rejected); - } - let connection_guard = if stream { - Some( - terminal_service - .try_register_connection() - .map_err(|_| MiddlewareError::Fault)?, - ) - } else { - None - }; - terminal_entered.store(true, Ordering::Relaxed); - let started = terminal_service - .start_prepared_response(prepared, decoded, transport, endpoint) - .await - .map_err(MiddlewareError::Gateway)?; - let _ = terminal_request_id.set(started.request_id.clone()); - started.session.trace().headers( - "client.request", - serde_json::json!({ - "ingressRequestId": ingress_id.as_ref().and_then(|Extension(id)| id.header_value().to_str().ok()), - }), - request_headers - .iter() - .map(|(name, value)| (name.as_str(), value.as_bytes())), - ); - started - .session - .trace() - .capture("client.request.body", &request_body); - let _ = admitted.send(started.session.response_commit()); - execution_middleware_response(started, connection_guard, terminal_validation).await - }) - }), - ); - let response = async move { - let middleware = if let Some(authorization) = authorization.as_ref() { - match await_with_authorization(middleware, authorization, &cancellation).await { - Ok(result) => result, - Err(error) => Err(MiddlewareError::Gateway(error)), - } - } else { - middleware.await - }; - let expected = if stream { - ExpectedBody::Sse - } else { - ExpectedBody::SingleJson - }; - match middleware { - Ok(response) => { - let response = if let Some(authorization) = authorization { - authorized_middleware_response(response, authorization, cancellation) - } else { - response - }; - let response = validated_middleware_response(response, validation, stream); - let response = match adapter { - Some(adapter) => (adapter.wrap)(response), - None => response, - }; - into_http_response(response, expected).await - } - Err(error) => error_response(error), - } - }; - let response = if stream { - super::keepalive::response_with_encoder(response, keepalive, stream_error).await - } else { - response.await - }; - // 预留 ID 没有对应执行记录,中间件提前返回时保留 HTTP 入口关联 ID - if execution_entered.load(Ordering::Relaxed) { - super::super::with_model_request_id( - response, - started_request_id.get().unwrap_or(&request_id), - ) - } else { - response - } -} - -async fn await_with_authorization( - future: impl Future, - authorization: &Arc, - cancellation: &CancellationToken, -) -> Result { - tokio::pin!(future); - loop { - tokio::select! { - output = &mut future => return Ok(output), - () = tokio::time::sleep(AUTHORIZATION_RECHECK_INTERVAL) => { - if let Err(error) = authorization.authorize().await { - cancellation.cancel(); - return Err(error); - } - } - } - } -} - -fn authorized_middleware_response( - response: MiddlewareResponse, - authorization: Arc, - cancellation: CancellationToken, -) -> MiddlewareResponse { - let (protocol, status, headers, body, envelope) = response.into_parts(); - let mut response = MiddlewareResponse::new( - protocol, - status, - headers, - Box::new(AuthorizedResponseBody { - inner: Some(body), - authorization, - cancellation, - last_authorized_at: Instant::now(), - }), - ); - if let Some(envelope) = envelope { - response = response.with_envelope(envelope); - } - response -} - -struct AuthorizedResponseBody { - inner: Option>, - authorization: Arc, - cancellation: CancellationToken, - last_authorized_at: Instant, -} - -impl AuthorizedResponseBody { - async fn revoke(&mut self, error: GatewayError) -> MiddlewareError { - self.cancellation.cancel(); - if let Some(inner) = self.inner.take() { - inner.close().await; - } - MiddlewareError::Gateway(error) - } -} - -impl MiddlewareBody for AuthorizedResponseBody { - fn next_frame(&mut self) -> BoxFuture<'_, Result, MiddlewareError>> { - Box::pin(async move { - if self.last_authorized_at.elapsed() >= AUTHORIZATION_RECHECK_INTERVAL { - if let Err(error) = self.authorization.authorize().await { - return Err(self.revoke(error).await); - } - self.last_authorized_at = Instant::now(); - } - let error = { - let Some(inner) = self.inner.as_mut() else { - return Ok(None); - }; - // 复核身份只暂停同一次读取,不能丢弃已经消费上游事件的 future - let frame = inner.next_frame(); - tokio::pin!(frame); - loop { - let elapsed = self.last_authorized_at.elapsed(); - if elapsed >= AUTHORIZATION_RECHECK_INTERVAL { - if let Err(error) = self.authorization.authorize().await { - break error; - } - self.last_authorized_at = Instant::now(); - continue; - } - let wait = AUTHORIZATION_RECHECK_INTERVAL - elapsed; - tokio::select! { - result = &mut frame => return result, - () = tokio::time::sleep(wait) => {} - } - } - }; - Err(self.revoke(error).await) - }) - } - - fn commit_downstream( - &mut self, - client_status_code: Option, - ) -> BoxFuture<'_, Result<(), MiddlewareError>> { - let Some(inner) = self.inner.as_mut() else { - return Box::pin(async { Err(MiddlewareError::InvalidState) }); - }; - inner.commit_downstream(client_status_code) - } - - fn record_client_status( - &mut self, - client_status_code: u16, - ) -> BoxFuture<'_, Result<(), MiddlewareError>> { - let Some(inner) = self.inner.as_mut() else { - return Box::pin(async { Ok(()) }); - }; - inner.record_client_status(client_status_code) - } - - fn is_finalized(&self) -> bool { - self.inner.as_ref().is_none_or(|inner| inner.is_finalized()) - } - - fn close(mut self: Box) -> BoxFuture<'static, ()> { - let inner = self.inner.take(); - Box::pin(async move { - if let Some(inner) = inner { - inner.close().await; - } - }) - } -} - -async fn execution_middleware_response( - started: StartedExecution, - connection_guard: Option>, - validation: ResponseValidationFacts, -) -> Result { - let StartedExecution { - stream, session, .. - } = started; - if stream { - streaming_execution_middleware_response(session, connection_guard, validation).await - } else { - drop(connection_guard); - buffered_execution_middleware_response(session, validation).await - } -} - -async fn buffered_execution_middleware_response( - session: Box, - validation: ResponseValidationFacts, -) -> Result { - let mut execution = PendingExecution::new(session); - let collected = execution - .session_mut() - .ok_or(MiddlewareError::InvalidState)? - .collect_uncommitted() - .await; - let events = match collected { - Ok(events) => events, - Err(error) => { - let headers = execution - .session_mut() - .ok_or(MiddlewareError::InvalidState)? - .response_headers() - .to_vec(); - return guarded_engine_error_response(execution, &error, &headers).await; - } - }; - let transformed = events.iter().any(ProviderEvent::middleware_transformed); - let encoded = match encode_collected_events(&events) { - Ok(encoded) => Bytes::from(encoded), - Err(error) => { - let response = - protocol_error_response(StatusCode::INTERNAL_SERVER_ERROR, error.protocol_body()); - return guarded_http_response(execution, response).await; - } - }; - validation.observe_buffered(&events, &encoded); - let session = execution - .session_mut() - .ok_or(MiddlewareError::InvalidState)?; - session.trace().record( - "downstream.encoded", - serde_json::json!({"transport": "http_json", "bytes": encoded.len()}), - ); - session.trace().dump("downstream.body", &encoded); - let headers = response_headers(session.response_headers(), false); - Ok(pending_execution_response( - OPENAI_PROTOCOL.to_owned(), - StatusCode::OK.as_u16(), - headers, - MiddlewareFrame::new(encoded, MiddlewareFraming::JsonDocument, true) - .with_transformed(transformed), - execution, - )) -} - -async fn streaming_execution_middleware_response( - session: Box, - connection_guard: Option>, - validation: ResponseValidationFacts, -) -> Result { - let mut body = StreamingExecutionBody::new(session, connection_guard, validation); - if let Err(error) = body.prime().await { - let headers = body.response_headers().to_vec(); - let execution = body.take_pending_execution()?; - return match error { - MiddlewareError::Engine(error) => { - guarded_engine_error_response(execution, &error, &headers).await - } - error => guarded_http_response(execution, error_response(error)).await, - }; - } - let headers = response_headers(body.response_headers(), true); - Ok(MiddlewareResponse::new( - OPENAI_PROTOCOL.to_owned(), - StatusCode::OK.as_u16(), - headers, - Box::new(body), - )) -} - -/// 直接驱动测试 session 的非流式交付;生产入口通过同一 MiddlewareResponse 路径 -pub async fn collect_execution_response(session: Box) -> Response { - match buffered_execution_middleware_response(session, ResponseValidationFacts::default()).await - { - Ok(response) => into_http_response(response, ExpectedBody::SingleJson).await, - Err(error) => error_response(error), - } -} - -/// 直接驱动测试 session 的 SSE 交付;生产入口通过同一 MiddlewareResponse 路径 -pub async fn stream_execution_response( - session: Box, - connection_guard: Option>, -) -> Response { - let (admitted, keepalive) = tokio::sync::oneshot::channel(); - let _ = admitted.send(session.response_commit()); - super::keepalive::response( - async move { - match streaming_execution_middleware_response( - session, - connection_guard, - ResponseValidationFacts::default(), - ) - .await - { - Ok(response) => into_http_response(response, ExpectedBody::Sse).await, - Err(error) => error_response(error), - } - }, - keepalive, - ) - .await -} - -fn validated_middleware_response( - response: MiddlewareResponse, - facts: ResponseValidationFacts, - streaming: bool, -) -> MiddlewareResponse { - if !(200..300).contains(&response.status_code()) { - // 非成功响应沿用通用 SinglePayload 边界,不能套用成功 Responses 终态状态机 - return response; - } - let (protocol, status, headers, body, envelope) = response.into_parts(); - let mut response = MiddlewareResponse::new( - protocol, - status, - headers, - Box::new(ValidatedResponsesBody { - inner: Some(body), - facts, - streaming, - validator: ResponsesDeliveryValidator::default(), - pending: VecDeque::new(), - committed: false, - }), - ); - if let Some(envelope) = envelope { - response = response.with_envelope(envelope); - } - response -} - -struct ValidatedResponsesBody { - inner: Option>, - facts: ResponseValidationFacts, - streaming: bool, - validator: ResponsesDeliveryValidator, - pending: VecDeque, - committed: bool, -} - -impl ValidatedResponsesBody { - async fn fail_stream(&mut self) -> Option { - if let Some(inner) = self.inner.take() { - inner.close().await; - } - let response_id = self - .validator - .response_id() - .map(str::to_owned) - .or_else(|| self.facts.response_id()); - self.pending.push_back(MiddlewareFrame::new( - Bytes::from(response_failed_sse_event_with_id( - response_id.as_deref(), - "server_error", - "middleware_failed", - "Response middleware returned an invalid stream.", - )), - MiddlewareFraming::SseEvent, - false, - )); - self.pending.push_back(done_frame()); - self.pending.pop_front() - } -} - -impl MiddlewareBody for ValidatedResponsesBody { - fn next_frame(&mut self) -> BoxFuture<'_, Result, MiddlewareError>> { - Box::pin(async move { - if let Some(frame) = self.pending.pop_front() { - return Ok(Some(frame)); - } - let Some(inner) = self.inner.as_mut() else { - return Ok(None); - }; - let frame = match inner.next_frame().await { - Ok(frame) => frame, - Err(error) if self.streaming && self.committed => { - let _ = error; - return Ok(self.fail_stream().await); - } - Err(error) => return Err(error), - }; - let Some(frame) = frame else { - if self.streaming && self.validator.finish_delivery().is_err() { - if self.committed { - return Ok(self.fail_stream().await); - } - return Err(MiddlewareError::InvalidState); - } - return Ok(None); - }; - let valid = if self.streaming { - self.validator - .validate_frame(frame.bytes(), frame.transformed(), &self.facts) - } else if frame.transformed() { - validate_buffered_response(&self.facts, frame.bytes()) - } else { - Ok(()) - }; - if valid.is_err() { - if self.streaming && self.committed { - return Ok(self.fail_stream().await); - } - return Err(MiddlewareError::InvalidState); - } - Ok(Some(frame)) - }) - } - - fn commit_downstream( - &mut self, - client_status_code: Option, - ) -> BoxFuture<'_, Result<(), MiddlewareError>> { - Box::pin(async move { - let Some(inner) = self.inner.as_mut() else { - return Err(MiddlewareError::InvalidState); - }; - inner.commit_downstream(client_status_code).await?; - self.committed = true; - Ok(()) - }) - } - - fn record_client_status( - &mut self, - client_status_code: u16, - ) -> BoxFuture<'_, Result<(), MiddlewareError>> { - Box::pin(async move { - match self.inner.as_mut() { - Some(inner) => inner.record_client_status(client_status_code).await, - None => Ok(()), - } - }) - } - - fn is_finalized(&self) -> bool { - self.inner.as_ref().is_none_or(|inner| inner.is_finalized()) - } - - fn close(mut self: Box) -> BoxFuture<'static, ()> { - let inner = self.inner.take(); - Box::pin(async move { - if let Some(inner) = inner { - inner.close().await; - } - }) - } -} - -fn encode_collected_events(events: &[ProviderEvent]) -> Result, ResponseEncodeError> { - let response = super::response::collect_response(events)?; - serde_json::to_vec(&response).map_err(|_| ResponseEncodeError::Serialization) -} - -async fn guarded_engine_error_response( - execution: PendingExecution, - error: &EngineError, - response_headers: &[ProviderResponseHeader], -) -> Result { - guarded_http_response( - execution, - engine_error_response_with_headers(error, response_headers), - ) - .await -} - -async fn guarded_http_response( - execution: PendingExecution, - response: Response, -) -> Result { - let (parts, body) = response.into_parts(); - let bytes = axum::body::to_bytes(body, usize::MAX) - .await - .map_err(|_| MiddlewareError::Fault)?; - Ok(pending_execution_response( - OPENAI_PROTOCOL.to_owned(), - parts.status.as_u16(), - encode_headers(&parts.headers), - MiddlewareFrame::new(bytes, MiddlewareFraming::RawBytes, true), - execution, - )) -} - -fn engine_error_response_with_headers( - error: &EngineError, - response_headers: &[ProviderResponseHeader], -) -> Response { - let response = engine_error_response(error); - let failure_request_ids = ["x-request-id", "x-oai-request-id"] - .into_iter() - .flat_map(|name| { - response - .headers() - .get_all(name) - .iter() - .cloned() - .map(move |value| (name, value)) - }) - .collect::>(); - // 失败后仍须交付已采集的 turn state;只隔离 opening 身份,不丢弃会话状态 - let mut response = apply_provider_response_headers(response, response_headers); - response.headers_mut().remove("x-request-id"); - response.headers_mut().remove("x-oai-request-id"); - for (name, value) in failure_request_ids { - response.headers_mut().append(name, value); - } - response -} - -fn apply_provider_response_headers( - mut response: Response, - response_headers: &[ProviderResponseHeader], -) -> Response { - let connection_options = super::response_connection_options(response_headers); - for header in response_headers { - if !super::response_header_is_forwardable(header.name(), &connection_options) { - continue; - } - let Ok(name) = HeaderName::from_bytes(header.name().as_bytes()) else { - continue; - }; - let Ok(value) = HeaderValue::from_bytes(header.value()) else { - continue; - }; - response.headers_mut().append(name, value); - } - response -} - -fn response_headers( - provider_headers: &[ProviderResponseHeader], - streaming: bool, -) -> Vec { - let connection_options = super::response_connection_options(provider_headers); - let mut headers = Vec::new(); - headers.push(MiddlewareHeader::new( - CONTENT_TYPE.as_str(), - Bytes::from_static(if streaming { - b"text/event-stream" - } else { - b"application/json" - }), - )); - for header in provider_headers { - if !super::response_header_is_forwardable(header.name(), &connection_options) - || header.name().eq_ignore_ascii_case(CONTENT_TYPE.as_str()) - || HeaderName::from_bytes(header.name().as_bytes()).is_err() - || HeaderValue::from_bytes(header.value()).is_err() - { - continue; - } - headers.push(MiddlewareHeader::new( - header.name(), - Bytes::copy_from_slice(header.value()), - )); - } - headers -} - -struct StreamingExecutionBody { - session: Option>, - encoder: OpenAiResponsesEncoder, - validation: ResponseValidationFacts, - pending: VecDeque, - awaiting_terminal_eof: bool, - output_finished: bool, - batch_pending: bool, - transformed_pending: bool, - committed: bool, - _connection_guard: Option>, -} - -impl StreamingExecutionBody { - fn new( - session: Box, - connection_guard: Option>, - validation: ResponseValidationFacts, - ) -> Self { - Self { - session: Some(session), - encoder: OpenAiResponsesEncoder::new(), - validation, - pending: VecDeque::new(), - awaiting_terminal_eof: false, - output_finished: false, - batch_pending: false, - transformed_pending: false, - committed: false, - _connection_guard: connection_guard, - } - } - - async fn prime(&mut self) -> Result<(), MiddlewareError> { - self.fill_pending().await?; - if self.pending.is_empty() { - return Err(MiddlewareError::InvalidState); - } - Ok(()) - } - - fn response_headers(&self) -> &[ProviderResponseHeader] { - self.session - .as_ref() - .map_or(&[], |session| session.response_headers()) - } - - async fn fill_pending(&mut self) -> Result<(), MiddlewareError> { - while self.pending.is_empty() && !self.output_finished { - if self.awaiting_terminal_eof { - if !self.committed { - // 终态 wire 不能在首字节前被中间件整批移除 - return Err(MiddlewareError::InvalidState); - } - self.verify_terminal_eof().await?; - self.pending.push_back(done_frame()); - self.output_finished = true; - continue; - } - if self.batch_pending { - if !self.committed { - self.session - .as_mut() - .ok_or(MiddlewareError::InvalidState)? - .discard_pending_delivery() - .map_err(MiddlewareError::Engine)?; - } - self.batch_pending = false; - } - let result = self - .session - .as_mut() - .ok_or(MiddlewareError::InvalidState)? - .next_event() - .await; - let coordinated = match result { - Ok(Some(event)) => event, - Ok(None) if self.committed && self.is_finalized() => { - self.pending.push_back(done_frame()); - self.output_finished = true; - continue; - } - Ok(None) => return Err(invalid_execution_stream()), - Err(error) if self.committed => { - self.push_stream_error(gateway_error_from_engine(&error)); - continue; - } - Err(error) => return Err(MiddlewareError::Engine(error)), - }; - let expected = if self.committed { - CommitRequirement::AlreadyCommitted - } else { - CommitRequirement::CommitBeforeDelivery - }; - if coordinated.commit_requirement() != expected { - return Err(invalid_execution_stream()); - } - let mut encoded = VecDeque::new(); - for event in coordinated.into_provider_events() { - self.validation.observe_event(&event); - let transformed = self.transformed_pending || event.middleware_transformed(); - let frames = self.encoder.push_sse(&event); - if frames.is_empty() { - self.transformed_pending = transformed; - continue; - } - encoded.extend(frames.into_iter().map(|bytes| { - MiddlewareFrame::new(bytes, MiddlewareFraming::SseEvent, false) - .with_transformed(transformed) - })); - self.transformed_pending = false; - } - self.awaiting_terminal_eof = - self.encoder.is_completed() || self.encoder.has_wire_failure(); - self.batch_pending = !self.committed; - if encoded.is_empty() { - if !self.committed || self.awaiting_terminal_eof { - return Err(invalid_execution_stream()); - } - continue; - } - // 已提交的流先确认 Core 终结,避免后续 EOF 验证推翻已交付的成功终态 - if self.awaiting_terminal_eof && self.committed { - self.verify_terminal_eof().await?; - encoded.push_back(done_frame()); - self.output_finished = true; - } - self.pending = encoded; - } - Ok(()) - } - - async fn verify_terminal_eof(&mut self) -> Result<(), MiddlewareError> { - let result = self - .session - .as_mut() - .ok_or(MiddlewareError::InvalidState)? - .next_event() - .await; - match result { - Ok(None) if self.is_finalized() => Ok(()), - Err(_) if self.encoder.has_wire_failure() && self.is_finalized() => Ok(()), - Ok(_) => Err(invalid_execution_stream()), - Err(error) => Err(MiddlewareError::Engine(error)), - } - } - - fn push_stream_error(&mut self, error: GatewayError) { - let (_, default_type, default_code) = gateway_error_contract(error.kind()); - self.pending.push_back(MiddlewareFrame::new( - Bytes::from(response_failed_sse_event_with_id( - self.encoder.response_id(), - error.client_error_type().unwrap_or(default_type), - crate::client_error::client_error_code( - error.client_error_code().unwrap_or(default_code), - ), - error.client_message(), - )), - MiddlewareFraming::SseEvent, - false, - )); - self.pending.push_back(done_frame()); - self.output_finished = true; - } - - fn take_session_for_close(&mut self) -> Option> { - self.session.take() - } - - fn take_pending_execution(&mut self) -> Result { - self.take_session_for_close() - .map(PendingExecution::new) - .ok_or(MiddlewareError::InvalidState) - } -} - -impl MiddlewareBody for StreamingExecutionBody { - fn next_frame(&mut self) -> BoxFuture<'_, Result, MiddlewareError>> { - Box::pin(async move { - if let Some(frame) = self.pending.pop_front() { - return Ok(Some(frame)); - } - if self.output_finished { - return Ok(None); - } - if let Err(error) = self.fill_pending().await { - if !self.committed { - return Err(error); - } - let error = match error { - MiddlewareError::Gateway(error) => error, - MiddlewareError::Engine(error) => gateway_error_from_engine(&error), - _ => GatewayError::new( - GatewayErrorKind::Internal, - "Gateway response stream could not be delivered.", - ), - }; - self.push_stream_error(error); - } - Ok(self.pending.pop_front()) - }) - } - - fn commit_downstream( - &mut self, - client_status_code: Option, - ) -> BoxFuture<'_, Result<(), MiddlewareError>> { - Box::pin(async move { - if self.committed { - return Ok(()); - } - self.session - .as_mut() - .ok_or(MiddlewareError::InvalidState)? - .commit_downstream(client_status_code) - .await - .map_err(MiddlewareError::Engine)?; - self.committed = true; - self.batch_pending = false; - Ok(()) - }) - } - - fn record_client_status( - &mut self, - client_status_code: u16, - ) -> BoxFuture<'_, Result<(), MiddlewareError>> { - Box::pin(async move { - let Some(session) = self.session.as_mut() else { - return Ok(()); - }; - session - .record_client_status(client_status_code) - .await - .map_err(MiddlewareError::Engine) - }) - } - - fn is_finalized(&self) -> bool { - self.session - .as_ref() - .is_none_or(|session| session.is_finalized()) - } - - fn close(mut self: Box) -> BoxFuture<'static, ()> { - let session = self.take_session_for_close(); - Box::pin(async move { - if let Some(session) = session { - finalize_session(session).await; - } - }) - } -} - -impl Drop for StreamingExecutionBody { - fn drop(&mut self) { - let Some(session) = self.take_session_for_close() else { - return; - }; - session.cancel(); - let finalize = session.detach_finalize(); - if let Ok(runtime) = tokio::runtime::Handle::try_current() { - drop(runtime.spawn(finalize)); - } - } -} - -fn done_frame() -> MiddlewareFrame { - MiddlewareFrame::new( - Bytes::from_static(DONE_SSE_FRAME.as_bytes()), - MiddlewareFraming::SseEvent, - true, - ) -} - -fn invalid_execution_stream() -> MiddlewareError { - MiddlewareError::Gateway(GatewayError::new( - GatewayErrorKind::Internal, - "Gateway response stream violated its execution lifecycle.", - )) -} diff --git a/backend/crates/gateway-api/src/openai/responses/keepalive.rs b/backend/crates/gateway-api/src/openai/responses/keepalive.rs index 6e58ae178..3058df35f 100644 --- a/backend/crates/gateway-api/src/openai/responses/keepalive.rs +++ b/backend/crates/gateway-api/src/openai/responses/keepalive.rs @@ -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 + Send + 'static, admitted: oneshot::Receiver, ) -> 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 + Send + 'static, admitted: oneshot::Receiver, error_encoder: Option 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 Bytes>), + Waiting( + BoxFuture<'static, Response>, + Option Bytes>, + bool, + ), Streaming(BodyDataStream), } @@ -74,7 +79,7 @@ impl PendingResponse { async fn next(mut self) -> Result, 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 Bytes>) -> Body { +async fn stream_failure( + response: Response, + error_encoder: Option 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 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) } diff --git a/backend/crates/gateway-api/src/openai/responses/mod.rs b/backend/crates/gateway-api/src/openai/responses/mod.rs index ad17a770d..e7366ea4b 100644 --- a/backend/crates/gateway-api/src/openai/responses/mod.rs +++ b/backend/crates/gateway-api/src/openai/responses/mod.rs @@ -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; diff --git a/backend/crates/gateway-api/src/openai/responses/request.rs b/backend/crates/gateway-api/src/openai/responses/request.rs index 1a8d82114..11dc37df6 100644 --- a/backend/crates/gateway-api/src/openai/responses/request.rs +++ b/backend/crates/gateway-api/src/openai/responses/request.rs @@ -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, 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()"), - } - } -} - -/// Handler、Router 和 history owner 使用的请求元数据 -#[derive(Clone, PartialEq, Eq)] -pub struct ResponsesRequestMetadata { - requested_model: String, - stream: bool, - store: bool, - continuation: ContinuationIntent, - client_ip: Option, - user_agent: Option, -} - -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 { - 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.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, - user_agent: Option, - ) -> 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 { +) -> Result { 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( pub(super) fn decode_request_inner( body: &[u8], request_headers: &OpenAiRequestHeaders, -) -> Result { +) -> Result { let value = serde_json::from_slice::(body).map_err(|_| RequestDecodeError::MalformedJson)?; let Value::Object(object) = value else { @@ -463,7 +308,7 @@ pub(super) fn decode_request_object( mut object: Map, request_headers: &OpenAiRequestHeaders, source: RequestDecodeSource, -) -> Result { +) -> Result { // 仅消费已识别的本地 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, diff --git a/backend/crates/gateway-api/src/openai/responses/response.rs b/backend/crates/gateway-api/src/openai/responses/response.rs index 293a8f752..d38102b4c 100644 --- a/backend/crates/gateway-api/src/openai/responses/response.rs +++ b/backend/crates/gateway-api/src/openai/responses/response.rs @@ -187,7 +187,9 @@ impl OpenAiResponsesEncoder { } /// 仅在非流式出口聚合同一响应的完成项,不让流式转发常驻保存输出内容 -pub(super) fn collect_response(events: &[ProviderEvent]) -> Result { +pub(in crate::openai) fn collect_response( + events: &[ProviderEvent], +) -> Result { let mut encoder = OpenAiResponsesEncoder::new(); let mut response_id = None; let mut items = BTreeMap::new(); diff --git a/backend/crates/gateway-api/src/openai/responses/validation.rs b/backend/crates/gateway-api/src/openai/responses/validation.rs index 6b4a9e4cf..fced15b24 100644 --- a/backend/crates/gateway-api/src/openai/responses/validation.rs +++ b/backend/crates/gateway-api/src/openai/responses/validation.rs @@ -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>); +pub(in crate::openai) struct ResponseValidationFacts(Arc>); 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 { + pub(in crate::openai) fn response_id(&self) -> Option { 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 { diff --git a/backend/crates/gateway-api/src/openai/responses/websocket/forward.rs b/backend/crates/gateway-api/src/openai/responses/websocket/forward.rs index 8b0af347f..1d3bc141f 100644 --- a/backend/crates/gateway-api/src/openai/responses/websocket/forward.rs +++ b/backend/crates/gateway-api/src/openai/responses/websocket/forward.rs @@ -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(), diff --git a/backend/crates/gateway-api/src/openai/responses/websocket/mod.rs b/backend/crates/gateway-api/src/openai/responses/websocket/mod.rs index 1b50202bc..4e881fb00 100644 --- a/backend/crates/gateway-api/src/openai/responses/websocket/mod.rs +++ b/backend/crates/gateway-api/src/openai/responses/websocket/mod.rs @@ -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, diff --git a/backend/crates/gateway-api/src/openai/responses/websocket/protocol.rs b/backend/crates/gateway-api/src/openai/responses/websocket/protocol.rs index 7553dcc64..563863e0d 100644 --- a/backend/crates/gateway-api/src/openai/responses/websocket/protocol.rs +++ b/backend/crates/gateway-api/src/openai/responses/websocket/protocol.rs @@ -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 { +) -> Result { 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 { +) -> Result { let Value::Object(mut body) = serde_json::from_str::(payload) .map_err(|_| ResponseCreateFrameError::InvalidJson)? else { diff --git a/backend/crates/gateway-api/src/openai/router.rs b/backend/crates/gateway-api/src/openai/router.rs index 8d234f25b..2e7ce6f81 100644 --- a/backend/crates/gateway-api/src/openai/router.rs +++ b/backend/crates/gateway-api/src/openai/router.rs @@ -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 { .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)) diff --git a/backend/crates/gateway-api/src/openai/search/http.rs b/backend/crates/gateway-api/src/openai/search/http.rs index 51ea8b6af..aaa779fc5 100644 --- a/backend/crates/gateway-api/src/openai/search/http.rs +++ b/backend/crates/gateway-api/src/openai/search/http.rs @@ -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), }; diff --git a/backend/crates/gateway-api/src/openai/service.rs b/backend/crates/gateway-api/src/openai/service.rs index c3418d81b..aed3cb302 100644 --- a/backend/crates/gateway-api/src/openai/service.rs +++ b/backend/crates/gateway-api/src/openai/service.rs @@ -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 { 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(), diff --git a/backend/crates/gateway-api/src/provider.rs b/backend/crates/gateway-api/src/provider.rs index 8aa7ecc7c..2032125ea 100644 --- a/backend/crates/gateway-api/src/provider.rs +++ b/backend/crates/gateway-api/src/provider.rs @@ -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), }; diff --git a/backend/crates/gateway-api/tests/admin/accounts/mod.rs b/backend/crates/gateway-api/tests/admin/accounts/mod.rs index 7f61c33d1..2b0cb7f01 100644 --- a/backend/crates/gateway-api/tests/admin/accounts/mod.rs +++ b/backend/crates/gateway-api/tests/admin/accounts/mod.rs @@ -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": { diff --git a/backend/crates/gateway-api/tests/diagnostics.rs b/backend/crates/gateway-api/tests/diagnostics.rs index eff7f7794..b91125999 100644 --- a/backend/crates/gateway-api/tests/diagnostics.rs +++ b/backend/crates/gateway-api/tests/diagnostics.rs @@ -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", ), diff --git a/backend/crates/gateway-api/tests/openai/chat_completions/http.rs b/backend/crates/gateway-api/tests/openai/chat_completions/http.rs index e3c57470d..1c04c271a 100644 --- a/backend/crates/gateway-api/tests/openai/chat_completions/http.rs +++ b/backend/crates/gateway-api/tests/openai/chat_completions/http.rs @@ -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>, - pub trace: Arc, - pub finish: Finish, - pub delay: Option, - pub fail_commit: bool, - pub response_headers: Vec, - committed: bool, - buffered: bool, -} - -impl Session { - pub fn new(events: Vec) -> 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) -> 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, 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, 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) -> 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) -> 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, - pub trace: Arc, + pub trace: Arc, } impl Fixture { diff --git a/backend/crates/gateway-api/tests/openai/chat_completions/request.rs b/backend/crates/gateway-api/tests/openai/chat_completions/request.rs index 5a3aa735c..0da82b97c 100644 --- a/backend/crates/gateway-api/tests/openai/chat_completions/request.rs +++ b/backend/crates/gateway-api/tests/openai/chat_completions/request.rs @@ -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; diff --git a/backend/crates/gateway-api/tests/openai/chat_completions/response.rs b/backend/crates/gateway-api/tests/openai/chat_completions/response.rs index 057e2e7a8..1204cb5d0 100644 --- a/backend/crates/gateway-api/tests/openai/chat_completions/response.rs +++ b/backend/crates/gateway-api/tests/openai/chat_completions/response.rs @@ -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; diff --git a/backend/crates/gateway-api/tests/openai/messages.rs b/backend/crates/gateway-api/tests/openai/messages.rs new file mode 100644 index 000000000..12389be6c --- /dev/null +++ b/backend/crates/gateway-api/tests/openai/messages.rs @@ -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>, + captured: Mutex>, +} + +impl ExecutionService for Execution { + fn authenticate(&self, key: &str) -> Result { + if key == "sk_messages_test" { + Ok(authenticated_client(key)) + } else { + Err(ClientAuthenticationError::InvalidKey) + } + } + fn public_models(&self, _: &AuthenticatedClient) -> Vec { + vec![] + } + fn contains_public_model(&self, _: &AuthenticatedClient, _: &PublicModelId) -> bool { + true + } + fn start( + &self, + request: StartExecution, + ) -> BoxFuture<'_, Result> { + 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> { + 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 { + 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 { + 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) { + 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") + ); +} diff --git a/backend/crates/gateway-api/tests/openai/mod.rs b/backend/crates/gateway-api/tests/openai/mod.rs index fd3e61cd6..8e7191a57 100644 --- a/backend/crates/gateway-api/tests/openai/mod.rs +++ b/backend/crates/gateway-api/tests/openai/mod.rs @@ -7,6 +7,7 @@ mod error; mod image_policy; mod images; mod live; +mod messages; mod middleware; mod models; mod peer_link; diff --git a/backend/crates/gateway-api/tests/openai/models.rs b/backend/crates/gateway-api/tests/openai/models.rs index cdf1731c6..1d50ce53a 100644 --- a/backend/crates/gateway-api/tests/openai/models.rs +++ b/backend/crates/gateway-api/tests/openai/models.rs @@ -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, diff --git a/backend/crates/gateway-api/tests/openai/responses/mod.rs b/backend/crates/gateway-api/tests/openai/responses/mod.rs index 3d3d122fc..4583910fe 100644 --- a/backend/crates/gateway-api/tests/openai/responses/mod.rs +++ b/backend/crates/gateway-api/tests/openai/responses/mod.rs @@ -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 { +fn decode_request(body: &[u8]) -> Result { decode_request_with_headers(body, &HeaderMap::new(), 64 * 1024 * 1024) } fn decode_response_create( payload: &str, -) -> Result { +) -> Result { 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 { +fn openai_wire_body(decoded: &DecodedGenerationRequest) -> &serde_json::Map { generate_operation(decoded).protocol_payload().body() } -fn openai_protocol_context(decoded: &DecodedResponsesRequest) -> &serde_json::Map { +fn openai_protocol_context(decoded: &DecodedGenerationRequest) -> &serde_json::Map { generate_operation(decoded).protocol_payload().context() } diff --git a/backend/crates/gateway-api/tests/openai/responses/websocket/mod.rs b/backend/crates/gateway-api/tests/openai/responses/websocket/mod.rs index dc2ceb6d4..21f85826b 100644 --- a/backend/crates/gateway-api/tests/openai/responses/websocket/mod.rs +++ b/backend/crates/gateway-api/tests/openai/responses/websocket/mod.rs @@ -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", diff --git a/backend/crates/gateway-api/tests/openai/router.rs b/backend/crates/gateway-api/tests/openai/router.rs index 9dd42da45..86130a61a 100644 --- a/backend/crates/gateway-api/tests/openai/router.rs +++ b/backend/crates/gateway-api/tests/openai/router.rs @@ -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")); } diff --git a/backend/crates/gateway-api/tests/support/generation.rs b/backend/crates/gateway-api/tests/support/generation.rs new file mode 100644 index 000000000..949d94c31 --- /dev/null +++ b/backend/crates/gateway-api/tests/support/generation.rs @@ -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>, + pub trace: Arc, + pub finish: Finish, + pub delay: Option, + pub fail_commit: bool, + pub response_headers: Vec, + committed: bool, + buffered: bool, +} + +impl Session { + pub fn new(events: Vec) -> 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) -> 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, 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, 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) -> 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) -> BoxFuture<'static, ()> { + Box::pin(async move { + self.trace.detached.fetch_add(1, Ordering::SeqCst); + self.trace.finalized.store(true, Ordering::SeqCst); + }) + } +} diff --git a/backend/crates/gateway-api/tests/support.rs b/backend/crates/gateway-api/tests/support/mod.rs similarity index 99% rename from backend/crates/gateway-api/tests/support.rs rename to backend/crates/gateway-api/tests/support/mod.rs index 6a299b283..33f41b1db 100644 --- a/backend/crates/gateway-api/tests/support.rs +++ b/backend/crates/gateway-api/tests/support/mod.rs @@ -174,3 +174,5 @@ impl gateway_core::diagnostics::OperationalDiagnostics for RecordingDiagnostics Ok(()) } } + +pub(crate) mod generation; diff --git a/backend/crates/gateway-core/Cargo.toml b/backend/crates/gateway-core/Cargo.toml index b13c49197..8d74156e2 100644 --- a/backend/crates/gateway-core/Cargo.toml +++ b/backend/crates/gateway-core/Cargo.toml @@ -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" diff --git a/backend/crates/gateway-core/src/engine/middleware/contract.rs b/backend/crates/gateway-core/src/engine/middleware/contract.rs index 91f71c363..da35d216d 100644 --- a/backend/crates/gateway-core/src/engine/middleware/contract.rs +++ b/backend/crates/gateway-core/src/engine/middleware/contract.rs @@ -174,17 +174,17 @@ impl MiddlewareRequest { declaration: Option, ) -> Result { 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 { +fn generate_requirements( + protocol: &str, + body: &[u8], +) -> Result { 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(), diff --git a/backend/crates/gateway-core/src/operation.rs b/backend/crates/gateway-core/src/operation.rs index dbe9e895b..17be33f14 100644 --- a/backend/crates/gateway-core/src/operation.rs +++ b/backend/crates/gateway-core/src/operation.rs @@ -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, provider_session_state: Option, @@ -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 { - 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 { @@ -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) -> 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::>(&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 { diff --git a/backend/crates/gateway-core/tests/engine/middleware/mod.rs b/backend/crates/gateway-core/tests/engine/middleware/mod.rs index 492b6c370..243ba4a86 100644 --- a/backend/crates/gateway-core/tests/engine/middleware/mod.rs +++ b/backend/crates/gateway-core/tests/engine/middleware/mod.rs @@ -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}; diff --git a/backend/crates/gateway-plugin/sdk/docs/capabilities.md b/backend/crates/gateway-plugin/sdk/docs/capabilities.md index c93e949a2..3b58c99f5 100644 --- a/backend/crates/gateway-plugin/sdk/docs/capabilities.md +++ b/backend/crates/gateway-plugin/sdk/docs/capabilities.md @@ -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 阶段使用声明均会拒绝。 diff --git a/backend/crates/gateway-protocol/src/anthropic/capabilities.rs b/backend/crates/gateway-protocol/src/anthropic/capabilities.rs new file mode 100644 index 000000000..1119812e2 --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/capabilities.rs @@ -0,0 +1,54 @@ +//! 所选 Messages 模型的明确能力与限制,不根据模型名称推断 + +use serde_json::Value; + +/// 转换器消费的模型目录事实;None 表示上游未声明 +#[derive(Debug, Default, Clone, PartialEq, Eq)] +pub struct MessagesModelCapabilities { + pub thinking: Option, + pub adaptive_thinking: Option, + pub manual_thinking: Option, + pub disabled_thinking: Option, + pub efforts: Option>, + pub max_tokens: Option, +} + +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), + } + } +} diff --git a/backend/crates/gateway-protocol/src/anthropic/content.rs b/backend/crates/gateway-protocol/src/anthropic/content.rs new file mode 100644 index 000000000..d739f67f4 --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/content.rs @@ -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::>() + .join("\n"), + _ => String::new(), + } +} + +pub(super) fn blocks(value: Option<&Value>) -> Vec { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 +} diff --git a/backend/crates/gateway-protocol/src/anthropic/error.rs b/backend/crates/gateway-protocol/src/anthropic/error.rs new file mode 100644 index 000000000..556e9d049 --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/error.rs @@ -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, +} diff --git a/backend/crates/gateway-protocol/src/anthropic/mod.rs b/backend/crates/gateway-protocol/src/anthropic/mod.rs new file mode 100644 index 000000000..fcd611635 --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/mod.rs @@ -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"; diff --git a/backend/crates/gateway-protocol/src/anthropic/request.rs b/backend/crates/gateway-protocol/src/anthropic/request.rs new file mode 100644 index 000000000..3bffea602 --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/request.rs @@ -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) { + 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) { + 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) -> 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) -> 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, +) -> Result, 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, +) -> Result, TranslationError> { + validate_count_request(request)?; + messages_to_responses_body(request) +} + +fn messages_to_responses_body( + request: &Map, +) -> Result, 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::>(); + 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, + capabilities: &MessagesModelCapabilities, +) -> Result, 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::(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, target: &mut Map, 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, role: &str, parts: &mut Vec) { + if !parts.is_empty() { + input.push(json!({"type":"message","role":role,"content":std::mem::take(parts)})); + } +} + +fn append_message(messages: &mut Vec, role: &str, parts: Vec) { + 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) -> Vec { + let mut normalized = Vec::with_capacity(messages.len()); + let mut pending = Vec::::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, 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::>(); + 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::>(); + 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::>()}) +} diff --git a/backend/crates/gateway-protocol/src/anthropic/response.rs b/backend/crates/gateway-protocol/src/anthropic/response.rs new file mode 100644 index 000000000..9a646dd4f --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/response.rs @@ -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, +) -> Result { + 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, +) -> Result { + complete_response( + message, + original_request.get("model"), + &ToolSet::identities(original_request), + ) +} + +pub(super) fn complete_response( + message: &Value, + model: Option<&Value>, + tools: &ToolSet, +) -> Result { + 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::>(); + Ok(response_from_message(message, model, output)) +} + +pub(super) fn response_from_message( + message: &Value, + model: Option<&Value>, + output: Vec, +) -> 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 { + 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, +) -> Result { + complete_message(response, original_request.get("model")) +} + +pub(super) fn complete_message( + response: &Value, + model: Option<&Value>, +) -> Result { + 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::>(); + 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 { + 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::(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(), + } +} diff --git a/backend/crates/gateway-protocol/src/anthropic/stream/accumulator.rs b/backend/crates/gateway-protocol/src/anthropic/stream/accumulator.rs new file mode 100644 index 000000000..71d3c7674 --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/stream/accumulator.rs @@ -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, +} + +impl MessageSnapshot { + fn into_json(mut self) -> Result { + 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, + blocks: BTreeMap, + terminal: bool, +} + +impl MessagesAccumulator { + /// message_stop 返回完整响应,error 返回原生错误终态,未知事件不改变状态 + pub fn push(&mut self, event: &Value) -> Result, TranslationError> { + self.accumulate(event)? + .map(MessageSnapshot::into_json) + .transpose() + } + + // 原生 JSON 要求工具输入可解析,跨协议转换还需要保留合法截断的原始参数 + pub(super) fn accumulate( + &mut self, + event: &Value, + ) -> Result, 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 { + 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()); + } + } +} diff --git a/backend/crates/gateway-protocol/src/anthropic/stream/mod.rs b/backend/crates/gateway-protocol/src/anthropic/stream/mod.rs new file mode 100644 index 000000000..d67d7f4dd --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/stream/mod.rs @@ -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, 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) +} diff --git a/backend/crates/gateway-protocol/src/anthropic/stream/to_messages.rs b/backend/crates/gateway-protocol/src/anthropic/stream/to_messages.rs new file mode 100644 index 000000000..9499894e6 --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/stream/to_messages.rs @@ -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, +} + +/// 每次 Responses 执行独立持有输出块与结束状态 +#[derive(Debug)] +pub struct ResponsesToMessagesStream { + model: Option, + blocks: BTreeMap<(u64, usize), Block>, + started: bool, + terminal: bool, +} + +impl ResponsesToMessagesStream { + /// 原始 Messages 请求用于保留客户端模型身份 + #[must_use] + pub fn new(original_request: &Map) -> Self { + Self { + model: original_request.get("model").cloned(), + blocks: BTreeMap::new(), + started: false, + terminal: false, + } + } + + /// 完整 JSON 响应只需要客户端模型名 + pub fn complete_json(&self, response: &Value) -> Result { + super::super::response::complete_message(response, self.model.as_ref()) + } + + /// 输入已解码 Responses 事件,返回 Messages 事件 + pub fn push(&mut self, event: &Value) -> Result, 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) { + 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) { + 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, + ) -> 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, + ) -> 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::>() + } 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(()) + } +} diff --git a/backend/crates/gateway-protocol/src/anthropic/stream/to_responses.rs b/backend/crates/gateway-protocol/src/anthropic/stream/to_responses.rs new file mode 100644 index 000000000..8faa88cdc --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/stream/to_responses.rs @@ -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, + tools: ToolSet, + accumulator: MessagesAccumulator, + response_id: String, + output_indices: BTreeMap, + sequence: u64, +} + +impl MessagesToResponsesStream { + /// 原始 Responses 请求用于工具身份与模型恢复 + #[must_use] + pub fn new(original_request: &Map) -> 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 { + complete_response(message, self.model.as_ref(), &self.tools).map(terminal_response_event) + } + + /// 输入已解码事件,返回携带 type 的 Responses 事件 + pub fn push(&mut self, event: &Value) -> Result, 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 { + 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 + } +} diff --git a/backend/crates/gateway-protocol/src/anthropic/thinking.rs b/backend/crates/gateway-protocol/src/anthropic/thinking.rs new file mode 100644 index 000000000..f9f5b8f09 --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/thinking.rs @@ -0,0 +1,163 @@ +//! 按目标模型能力映射推理等级与预算;未知兼容上游沿用 CPA 手动预算 + +use serde_json::{Map, Value, json}; + +use super::MessagesModelCapabilities; + +pub(super) fn to_responses(request: &Map) -> 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, + target: &mut Map, + 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) -> 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) + }) +} diff --git a/backend/crates/gateway-protocol/src/anthropic/tools.rs b/backend/crates/gateway-protocol/src/anthropic/tools.rs new file mode 100644 index 000000000..2e397c12f --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/tools.rs @@ -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 { + pub name: String, + pub namespace: Option, + pub custom: bool, + pub definition: D, +} + +#[derive(Debug, Clone, Default)] +pub(super) struct ToolSet { + pub tools: BTreeMap>, +} + +impl ToolSet { + fn collect<'a>(request: &'a Map, 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) -> Self { + Self::collect(request, |_| ()) + } +} + +impl<'a> ToolSet<&'a Value> { + pub fn from_responses(request: &'a Map) -> Self { + Self::collect(request, |tool| tool) + } + + fn definitions(&self, allowed: Option<&[Value]>) -> Vec { + 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, + target: &mut Map, + ) -> 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 { + 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::() + .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::(&format!("{}\"", &value[..end])) { + input.push_str(&value[end..]); + return input; + } + } + arguments.to_owned() +} diff --git a/backend/crates/gateway-protocol/src/anthropic/usage.rs b/backend/crates/gateway-protocol/src/anthropic/usage.rs new file mode 100644 index 000000000..fe5f24e9d --- /dev/null +++ b/backend/crates/gateway-protocol/src/anthropic/usage.rs @@ -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, + /// 输出量 + pub output_tokens: Option, + /// 缓存读取量 + pub cache_read_input_tokens: Option, + /// 缓存写入量 + pub cache_creation_input_tokens: Option, +} + +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 { + 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}) +} diff --git a/backend/crates/gateway-protocol/src/lib.rs b/backend/crates/gateway-protocol/src/lib.rs index c729e17fe..c4f7b02c8 100644 --- a/backend/crates/gateway-protocol/src/lib.rs +++ b/backend/crates/gateway-protocol/src/lib.rs @@ -5,5 +5,11 @@ /// OpenAI wire contract pub mod openai; +/// Anthropic Messages 与 Responses 的线协议转换 +pub mod anthropic; + +/// 协议请求中的共享能力事实 +pub mod request; + /// CPR 互联只读观测协议 pub mod peer; diff --git a/backend/crates/gateway-protocol/src/request.rs b/backend/crates/gateway-protocol/src/request.rs new file mode 100644 index 000000000..0e8e46caa --- /dev/null +++ b/backend/crates/gateway-protocol/src/request.rs @@ -0,0 +1,80 @@ +//! 从协议正文提取调度需要的纯请求事实 + +use serde_json::{Map, Value}; + +/// 请求正文表达的能力要求 +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] +pub struct RequestFacts { + /// 显式输出预算 + pub max_output_tokens: Option, + /// 工具声明 + 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) -> 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, + } +} diff --git a/backend/crates/gateway-protocol/tests/anthropic/capabilities.rs b/backend/crates/gateway-protocol/tests/anthropic/capabilities.rs new file mode 100644 index 000000000..3018fa480 --- /dev/null +++ b/backend/crates/gateway-protocol/tests/anthropic/capabilities.rs @@ -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 + ); +} diff --git a/backend/crates/gateway-protocol/tests/anthropic/mod.rs b/backend/crates/gateway-protocol/tests/anthropic/mod.rs new file mode 100644 index 000000000..ba4b81655 --- /dev/null +++ b/backend/crates/gateway-protocol/tests/anthropic/mod.rs @@ -0,0 +1,7 @@ +//! Messages 转换与聚合行为测试入口 + +mod capabilities; +mod request; +mod response; +mod stream; +mod usage; diff --git a/backend/crates/gateway-protocol/tests/anthropic/request.rs b/backend/crates/gateway-protocol/tests/anthropic/request.rs new file mode 100644 index 000000000..c5d5e3725 --- /dev/null +++ b/backend/crates/gateway-protocol/tests/anthropic/request.rs @@ -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 { + 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| 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")); +} diff --git a/backend/crates/gateway-protocol/tests/anthropic/response.rs b/backend/crates/gateway-protocol/tests/anthropic/response.rs new file mode 100644 index 000000000..f75646be4 --- /dev/null +++ b/backend/crates/gateway-protocol/tests/anthropic/response.rs @@ -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."); +} diff --git a/backend/crates/gateway-protocol/tests/anthropic/stream/accumulator.rs b/backend/crates/gateway-protocol/tests/anthropic/stream/accumulator.rs new file mode 100644 index 000000000..0e3d8099d --- /dev/null +++ b/backend/crates/gateway-protocol/tests/anthropic/stream/accumulator.rs @@ -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()); +} diff --git a/backend/crates/gateway-protocol/tests/anthropic/stream/mod.rs b/backend/crates/gateway-protocol/tests/anthropic/stream/mod.rs new file mode 100644 index 000000000..2f09cc6f9 --- /dev/null +++ b/backend/crates/gateway-protocol/tests/anthropic/stream/mod.rs @@ -0,0 +1,4 @@ +//! SSE 增量转换和聚合的测试入口 + +mod accumulator; +mod translation; diff --git a/backend/crates/gateway-protocol/tests/anthropic/stream/translation.rs b/backend/crates/gateway-protocol/tests/anthropic/stream/translation.rs new file mode 100644 index 000000000..263cab841 --- /dev/null +++ b/backend/crates/gateway-protocol/tests/anthropic/stream/translation.rs @@ -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"); + } +} diff --git a/backend/crates/gateway-protocol/tests/anthropic/usage.rs b/backend/crates/gateway-protocol/tests/anthropic/usage.rs new file mode 100644 index 000000000..4f3dae152 --- /dev/null +++ b/backend/crates/gateway-protocol/tests/anthropic/usage.rs @@ -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)); +} diff --git a/backend/crates/gateway-protocol/tests/main.rs b/backend/crates/gateway-protocol/tests/main.rs index 0469625b4..7ce8120df 100644 --- a/backend/crates/gateway-protocol/tests/main.rs +++ b/backend/crates/gateway-protocol/tests/main.rs @@ -1,3 +1,5 @@ //! 共享协议解析与编码的测试入口 +mod anthropic; mod openai; +mod request; diff --git a/backend/crates/gateway-protocol/tests/request.rs b/backend/crates/gateway-protocol/tests/request.rs new file mode 100644 index 000000000..cecb70905 --- /dev/null +++ b/backend/crates/gateway-protocol/tests/request.rs @@ -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); +} diff --git a/backend/crates/providers/openai/Cargo.toml b/backend/crates/providers/openai/Cargo.toml index 5afdf6569..64dcb61ad 100644 --- a/backend/crates/providers/openai/Cargo.toml +++ b/backend/crates/providers/openai/Cargo.toml @@ -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"] } diff --git a/backend/crates/providers/openai/src/compat/messages.rs b/backend/crates/providers/openai/src/compat/messages.rs new file mode 100644 index 000000000..d8e2745e1 --- /dev/null +++ b/backend/crates/providers/openai/src/compat/messages.rs @@ -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, 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::>() + } 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))); +} diff --git a/backend/crates/providers/openai/src/compat/mod.rs b/backend/crates/providers/openai/src/compat/mod.rs index 8e843dcae..ba32061d1 100644 --- a/backend/crates/providers/openai/src/compat/mod.rs +++ b/backend/crates/providers/openai/src/compat/mod.rs @@ -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; diff --git a/backend/crates/providers/openai/src/compat/request.rs b/backend/crates/providers/openai/src/compat/request.rs index 48f87f45f..0a71105a7 100644 --- a/backend/crates/providers/openai/src/compat/request.rs +++ b/backend/crates/providers/openai/src/compat/request.rs @@ -35,6 +35,13 @@ pub(super) fn normalize_non_codex_request_body(body: &mut Map) { } fn normalize_codex_oauth_options(body: &mut Map) { + // 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", diff --git a/backend/crates/providers/openai/src/credential/admin.rs b/backend/crates/providers/openai/src/credential/admin.rs index 1dce7ed04..901e2d0cd 100644 --- a/backend/crates/providers/openai/src/credential/admin.rs +++ b/backend/crates/providers/openai/src/credential/admin.rs @@ -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, transport: ResponsesTransport, api_key: Option, } @@ -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 ApiKeyConfiguration { ApiKeyConfiguration { base_url: self.base_url.clone(), + protocol: self.protocol, transport: self.transport, } } diff --git a/backend/crates/providers/openai/src/credential/catalog.rs b/backend/crates/providers/openai/src/credential/catalog.rs index 12843a994..f102f4ffe 100644 --- a/backend/crates/providers/openai/src/credential/catalog.rs +++ b/backend/crates/providers/openai/src/credential/catalog.rs @@ -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, CodexCredentialCatalogError>; +type AccountModelsResult = Result, 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, cache: Arc>, client_catalogs: Arc>>, + background_capabilities: Arc, etags: Arc>, etag_notification: Arc, } @@ -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, + 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(), diff --git a/backend/crates/providers/openai/src/credential/codec.rs b/backend/crates/providers/openai/src/credential/codec.rs index 044d8dbfa..5be1ce99b 100644 --- a/backend/crates/providers/openai/src/credential/codec.rs +++ b/backend/crates/providers/openai/src/credential/codec.rs @@ -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 { diff --git a/backend/crates/providers/openai/src/credential/mod.rs b/backend/crates/providers/openai/src/credential/mod.rs index c72d3dd01..ec1fcbf8f 100644 --- a/backend/crates/providers/openai/src/credential/mod.rs +++ b/backend/crates/providers/openai/src/credential/mod.rs @@ -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, diff --git a/backend/crates/providers/openai/src/credential/selector.rs b/backend/crates/providers/openai/src/credential/selector.rs index 1bad92ccb..43eb91e65 100644 --- a/backend/crates/providers/openai/src/credential/selector.rs +++ b/backend/crates/providers/openai/src/credential/selector.rs @@ -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>, account_feedback: Arc, scheduling_projection: SchedulingProjectionCache, + endpoint_protocols: + Mutex>, } #[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; } } diff --git a/backend/crates/providers/openai/src/provider/failure.rs b/backend/crates/providers/openai/src/provider/failure.rs index 9ab903741..0f279ed06 100644 --- a/backend/crates/providers/openai/src/provider/failure.rs +++ b/backend/crates/providers/openai/src/provider/failure.rs @@ -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 { diff --git a/backend/crates/providers/openai/src/provider/messages/count.rs b/backend/crates/providers/openai/src/provider/messages/count.rs new file mode 100644 index 000000000..ea17e8190 --- /dev/null +++ b/backend/crates/providers/openai/src/provider/messages/count.rs @@ -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, + request: &TokenCountRequest, + candidate: &ProviderCandidate, + context: AttemptContext, + ) -> Result { + 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 = + 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, + model: UpstreamModelId, + context: AttemptContext, + lease: CodexCredentialLease, + account_selection_wait_ms: u64, + response_protocol: &'static str, + ) -> Result { + 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 = 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> = OnceLock::new(); + static CL100K: OnceLock> = 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::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, 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, value: &Value, names: &[&str]) { + for name in names { + push(segments, &value[name]); + } +} + +fn messages_segments(body: &Map) -> Vec { + 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) { + 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) -> Vec { + 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 +} diff --git a/backend/crates/providers/openai/src/provider/messages/mod.rs b/backend/crates/providers/openai/src/provider/messages/mod.rs new file mode 100644 index 000000000..1048ac4a7 --- /dev/null +++ b/backend/crates/providers/openai/src/provider/messages/mod.rs @@ -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, + operation: Operation, + mut headers: Vec, + model: UpstreamModelId, + context: AttemptContext, + mut selected: SelectedGenerate, + ) -> Result { + 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, + body: Map, + source_context: Map, + headers: Vec, + model: UpstreamModelId, + context: AttemptContext, + selected: SelectedGenerate, + ) -> Result { + 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, + source_context: Map, + headers: Vec, + model: UpstreamModelId, + context: AttemptContext, + lease: CodexCredentialLease, + account_selection_wait_ms: u64, + count_protocol: Option<&'static str>, + ) -> Result { + 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, + headers: &mut Vec, +) { + 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())); +} diff --git a/backend/crates/providers/openai/src/provider/messages/stream.rs b/backend/crates/providers/openai/src/provider/messages/stream.rs new file mode 100644 index 000000000..1bf29d3fc --- /dev/null +++ b/backend/crates/providers/openai/src/provider/messages/stream.rs @@ -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, + pub selector: Arc, + pub quota: Arc, + 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, + usage: MessageUsage, + reason: Option, + tools: BTreeMap, + completed: bool, + unpriced_usage: bool, +} + +impl MessageState { + fn frame( + &mut self, + frame: SseFrame, + request: &ColdMessages, + ) -> Result { + 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::(&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 { + 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 { + 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"); + } + } +} diff --git a/backend/crates/providers/openai/src/provider/messages/translator.rs b/backend/crates/providers/openai/src/provider/messages/translator.rs new file mode 100644 index 000000000..021792508 --- /dev/null +++ b/backend/crates/providers/openai/src/provider/messages/translator.rs @@ -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) -> 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, 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) -> 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, 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, +) -> Result, 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() +} diff --git a/backend/crates/providers/openai/src/provider/mod.rs b/backend/crates/providers/openai/src/provider/mod.rs index 9c54eab9c..7d0e74328 100644 --- a/backend/crates/providers/openai/src/provider/mod.rs +++ b/backend/crates/providers/openai/src/provider/mod.rs @@ -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() -} diff --git a/backend/crates/providers/openai/src/provider/observation.rs b/backend/crates/providers/openai/src/provider/observation.rs index 3b83d3254..3176cc742 100644 --- a/backend/crates/providers/openai/src/provider/observation.rs +++ b/backend/crates/providers/openai/src/provider/observation.rs @@ -580,8 +580,11 @@ pub(super) fn nonnegative_millis(value: Option) -> Option { 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)) } diff --git a/backend/crates/providers/openai/src/provider/upstream_adapter.rs b/backend/crates/providers/openai/src/provider/upstream_adapter.rs index 661fb414d..7c8e22601 100644 --- a/backend/crates/providers/openai/src/provider/upstream_adapter.rs +++ b/backend/crates/providers/openai/src/provider/upstream_adapter.rs @@ -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, 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()) } diff --git a/backend/crates/providers/openai/src/transport/catalog.rs b/backend/crates/providers/openai/src/transport/catalog.rs index ff46ea0a4..11d60cff0 100644 --- a/backend/crates/providers/openai/src/transport/catalog.rs +++ b/backend/crates/providers/openai/src/transport/catalog.rs @@ -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, } 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 { } /// 标准 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 { #[derive(Deserialize)] struct ApiModels { @@ -605,6 +614,8 @@ pub(crate) fn parse_api_model_catalog( struct ApiModel { id: String, display_name: Option, + #[serde(flatten)] + fields: serde_json::Map, } 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, diff --git a/backend/crates/providers/openai/src/transport/client.rs b/backend/crates/providers/openai/src/transport/client.rs index ae9ad2e19..f3bf48182 100644 --- a/backend/crates/providers/openai/src/transport/client.rs +++ b/backend/crates/providers/openai/src/transport/client.rs @@ -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, diff --git a/backend/crates/providers/openai/src/transport/client_catalog.rs b/backend/crates/providers/openai/src/transport/client_catalog.rs index 707f1b821..2a1f1dba4 100644 --- a/backend/crates/providers/openai/src/transport/client_catalog.rs +++ b/backend/crates/providers/openai/src/transport/client_catalog.rs @@ -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 { + 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)> { 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)) } } diff --git a/backend/crates/providers/openai/src/transport/client_messages.rs b/backend/crates/providers/openai/src/transport/client_messages.rs new file mode 100644 index 000000000..677773d69 --- /dev/null +++ b/backend/crates/providers/openai/src/transport/client_messages.rs @@ -0,0 +1,120 @@ +//! Messages HTTP 请求复用账号代理、出站中间件和诊断,不携带 Codex 会话身份 + +use std::time::Instant; + +use bytes::Bytes; +use futures::StreamExt; +use reqwest::header::{ACCEPT, CONTENT_TYPE, HeaderMap, HeaderValue}; + +use super::{ + CodexBackendClient, CodexBackendSseStream, CodexClientError, CodexClientResult, + CodexRequestContext, CodexTransportMetrics, CodexUpstreamDiagnostics, + client::{elapsed_duration_millis, http_json_upstream_error, http_version_name}, + response_meta::{self, CodexResponseMetadata}, +}; + +pub(crate) struct MessagesHttpResponse { + pub body: CodexBackendSseStream, + pub streaming: bool, + pub diagnostics: CodexUpstreamDiagnostics, + pub response_metadata: CodexResponseMetadata, + pub transport_metrics: CodexTransportMetrics, +} + +impl CodexBackendClient { + pub(crate) async fn post_messages( + &self, + endpoint: &'static str, + body: Bytes, + passthrough_headers: &HeaderMap, + context: CodexRequestContext<'_>, + ) -> CodexClientResult { + let mut headers = self.model_request_headers(&self.profile.snapshot(), context)?; + super::headers::append_passthrough_headers(&mut headers, passthrough_headers); + headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json")); + headers.insert( + ACCEPT, + HeaderValue::from_static("application/json, text/event-stream"), + ); + self.append_middleware_headers(&mut headers)?; + let body = if self.privacy.is_some() { + let mut value = + serde_json::from_slice(&body).map_err(CodexClientError::RequestBodyEncode)?; + self.apply_privacy(&mut value, &mut headers)?; + Bytes::from(serde_json::to_vec(&value).map_err(CodexClientError::RequestBodyEncode)?) + } else { + body + }; + let trace = context + .trace + .cloned() + .unwrap_or_default() + .exchange("messages_http"); + let request = self + .prepare_http_request(super::endpoint_url(&self.base_url, endpoint), headers, body) + .await?; + trace.headers( + "upstream.request.headers", + serde_json::json!({"method":"POST"}), + request + .headers() + .iter() + .map(|(name, value)| (name.as_str(), value.as_bytes())), + ); + trace.capture( + "upstream.request.body", + request + .body() + .and_then(reqwest::Body::as_bytes) + .unwrap_or_default(), + ); + let started = Instant::now(); + let response = self + .http_opening_client()? + .execute(request) + .await + .map_err(CodexClientError::Http)?; + let transport_metrics = CodexTransportMetrics { + upstream_headers_ms: Some(elapsed_duration_millis(started.elapsed())), + http_version: Some(http_version_name(response.version()).to_owned()), + ..CodexTransportMetrics::default() + }; + trace.headers( + "upstream.response.headers", + serde_json::json!({"status":response.status().as_u16()}), + response + .headers() + .iter() + .map(|(name, value)| (name.as_str(), value.as_bytes())), + ); + if !response.status().is_success() { + return Err(http_json_upstream_error(response, &trace, transport_metrics).await); + } + let streaming = response + .headers() + .get(CONTENT_TYPE) + .and_then(|header| header.to_str().ok()) + .is_some_and(|value| { + value + .split(';') + .next() + .is_some_and(|value| value.trim().eq_ignore_ascii_case("text/event-stream")) + }); + let diagnostics = + response_meta::diagnostics(Some(response.status().as_u16()), response.headers()) + .with_response_origin(Some(response.url().clone())); + let response_metadata = response_meta::response_metadata(response.headers()); + let body = Box::pin( + response + .bytes_stream() + .map(|chunk| chunk.map_err(CodexClientError::Http)), + ); + Ok(MessagesHttpResponse { + body, + streaming, + diagnostics, + response_metadata, + transport_metrics, + }) + } +} diff --git a/backend/crates/providers/openai/src/transport/headers.rs b/backend/crates/providers/openai/src/transport/headers.rs index e70c03e3b..ffe976cc6 100644 --- a/backend/crates/providers/openai/src/transport/headers.rs +++ b/backend/crates/providers/openai/src/transport/headers.rs @@ -119,10 +119,22 @@ impl CodexBackendClient { profile: &CodexWireProfile, context: CodexRequestContext<'_>, ) -> CodexClientResult { + if self.protocol == OpenAiUpstreamProtocol::MessagesApi { + let mut headers = HeaderMap::new(); + let api_key = context + .authorization + .strip_prefix("Bearer ") + .unwrap_or(context.authorization); + headers.insert("x-api-key", HeaderValue::from_str(api_key)?); + headers.insert("anthropic-version", HeaderValue::from_static("2023-06-01")); + return Ok(headers); + } // 客户端画像与认证方式无关;API Key 不携带 OAuth 账号身份和 Cookie let (account_id, cookie_header) = match self.protocol { OpenAiUpstreamProtocol::Codex => (context.account_id, context.cookie_header), - OpenAiUpstreamProtocol::ResponsesApi => (None, None), + OpenAiUpstreamProtocol::ResponsesApi | OpenAiUpstreamProtocol::MessagesApi => { + (None, None) + } }; let mut headers = build_codex_model_headers(profile, context.authorization, account_id)?; insert_optional_header(&mut headers, "cookie", cookie_header)?; diff --git a/backend/crates/providers/openai/src/transport/mod.rs b/backend/crates/providers/openai/src/transport/mod.rs index e3b9d0971..f73617f66 100644 --- a/backend/crates/providers/openai/src/transport/mod.rs +++ b/backend/crates/providers/openai/src/transport/mod.rs @@ -7,6 +7,7 @@ pub mod client; mod client_catalog; mod client_json; mod client_live; +mod client_messages; mod client_stream; pub(crate) mod connection; mod correlation; diff --git a/backend/crates/providers/openai/src/transport/request.rs b/backend/crates/providers/openai/src/transport/request.rs index 9580055e5..db945a4a2 100644 --- a/backend/crates/providers/openai/src/transport/request.rs +++ b/backend/crates/providers/openai/src/transport/request.rs @@ -20,7 +20,7 @@ use crate::transport::protocol::responses::{ CodexResponsesRequest, X_CODEX_TURN_STATE_CLIENT_METADATA_KEY, }; -const PASSTHROUGH_HEADERS_CONTEXT_KEY: &str = "opaque_request_headers"; +pub(crate) const PASSTHROUGH_HEADERS_CONTEXT_KEY: &str = "opaque_request_headers"; const TURN_ID_CLIENT_METADATA_KEY: &str = "turn_id"; const THREAD_SPAWN_SUBAGENT_KIND: &str = "thread_spawn"; const THREAD_SPAWN_CONVERSATION_PREFIX: &str = "thread-spawn:"; diff --git a/backend/crates/providers/openai/src/transport/usage.rs b/backend/crates/providers/openai/src/transport/usage.rs index f79824a60..72584b502 100644 --- a/backend/crates/providers/openai/src/transport/usage.rs +++ b/backend/crates/providers/openai/src/transport/usage.rs @@ -535,8 +535,8 @@ pub fn openai_billing_breakdown( usage: OpenAiBillingUsage, service_tier: Option<&str>, ) -> Option { - openai_billing_breakdown_with_context( - model, + token_billing_breakdown_with_context( + model_pricing(model), usage, service_tier, usage.input_tokens > LONG_CONTEXT_THRESHOLD, @@ -552,8 +552,8 @@ pub fn openai_billing_breakdown_with_override( service_tier: Option<&str>, pricing: Option<&gateway_core::metering::ModelPriceOverride>, ) -> Option { - openai_billing_breakdown_with_context( - model, + token_billing_breakdown_with_context( + model_pricing(model), usage, service_tier, usage.input_tokens > LONG_CONTEXT_THRESHOLD, @@ -561,8 +561,16 @@ pub fn openai_billing_breakdown_with_override( ) } -fn openai_billing_breakdown_with_context( - model: &str, +/// 其他 API 协议仅使用明确配置的标准 Token 单价,不继承 OpenAI 型号与档位规则 +pub(crate) fn configured_token_billing_breakdown( + usage: OpenAiBillingUsage, + pricing: &gateway_core::metering::ModelPriceOverride, +) -> Option { + token_billing_breakdown_with_context(None, usage, None, false, Some(pricing)) +} + +fn token_billing_breakdown_with_context( + pricing: Option, usage: OpenAiBillingUsage, service_tier: Option<&str>, long_context: bool, @@ -579,7 +587,6 @@ fn openai_billing_breakdown_with_context( } let tool_ticks = web_search_amount_ticks(usage)? .checked_add(u128::from(usage.file_search_calls).checked_mul(FILE_SEARCH_CALL_TICKS)?)?; - let pricing = model_pricing(model); let normalized_tier = normalize_service_tier(service_tier); let tier = pricing_tier(normalized_tier.as_deref())?; let (standard_rates, _) = diff --git a/backend/crates/providers/openai/tests/admin/mod.rs b/backend/crates/providers/openai/tests/admin/mod.rs index 64b03caee..b718217ed 100644 --- a/backend/crates/providers/openai/tests/admin/mod.rs +++ b/backend/crates/providers/openai/tests/admin/mod.rs @@ -3046,7 +3046,8 @@ async fn api_key_admin_exposes_only_configuration_and_preserves_key_when_rotatin .unwrap() .unwrap(); let configuration = configuration.expose_to_provider().expose_to_provider(); - assert_eq!(configuration.len(), 2); + assert_eq!(configuration.len(), 3); + assert_eq!(configuration.get("protocol"), Some(&json!("responses"))); assert_eq!( configuration.get("base_url"), Some(&json!("https://first.example/v1")) diff --git a/backend/crates/providers/openai/tests/credential/admin.rs b/backend/crates/providers/openai/tests/credential/admin.rs index e17455c23..7e95b6b89 100644 --- a/backend/crates/providers/openai/tests/credential/admin.rs +++ b/backend/crates/providers/openai/tests/credential/admin.rs @@ -1107,6 +1107,66 @@ async fn api_key_import_export_preserves_target_without_oauth_exchange() { } } +#[tokio::test] +async fn messages_api_key_import_export_preserves_protocol_and_rejects_websocket() { + use gateway_core::account::LoadedCredential; + use provider_openai::credential::{ + ApiKeyProtocol, CodexCredentialAdmin, CodexCredentialData, ExportManagedCodexCredential, + }; + let service = CodexCredentialAdminService::new( + Arc::new(UnusedRefresher), + Arc::new(TestLeaseCoordinator::default()), + runtime_policy(), + Arc::new(crate::RecordingDiagnostics::default()), + ); + let document = serde_json::json!({"provider":"openai", "authentication_kind":"api_key", "base_url":"https://api.anthropic.com/v1", "protocol":"messages", "api_key":"sk-test-only", "transport":"http"}); + let imported = service + .prepare_import_document_with_proxy(document.clone(), None) + .await + .unwrap() + .into_accounts() + .pop() + .unwrap(); + let now = Utc::now(); + let exported = CodexCredentialAdmin + .format_cpr_export(vec![ExportManagedCodexCredential { + current: LoadedCredential { + account: imported.account, + credential: imported.credential, + }, + added_at: now, + updated_at: now, + }]) + .unwrap() + .into_json() + .unwrap(); + let restored = service + .prepare_import_document_with_proxy(exported, None) + .await + .unwrap() + .into_accounts() + .pop() + .unwrap(); + let CodexCredentialData::ApiKey(data) = + CodexCredentialCodec::decode_complete(&restored.credential).unwrap() + else { + panic!("API credential"); + }; + assert_eq!(data.protocol, ApiKeyProtocol::Messages); + assert_eq!( + serde_json::to_value(data.configuration()).unwrap()["protocol"], + "messages" + ); + let mut invalid = document; + invalid["transport"] = serde_json::json!("prefer_websocket"); + assert!( + service + .prepare_import_document_with_proxy(invalid, None) + .await + .is_err() + ); +} + #[tokio::test] async fn api_key_import_rejects_unsafe_urls_and_empty_keys() { let service = CodexCredentialAdminService::new( diff --git a/backend/crates/providers/openai/tests/provider/contract/messages.rs b/backend/crates/providers/openai/tests/provider/contract/messages.rs new file mode 100644 index 000000000..922c069e6 --- /dev/null +++ b/backend/crates/providers/openai/tests/provider/contract/messages.rs @@ -0,0 +1,815 @@ +//! Messages 原生 wire、跨协议头隔离和本地计数合同 + +use super::*; +use gateway_core::event::ProviderResponseTimings; +use gateway_core::operation::TokenCountRequest; +use provider_openai::credential::{ApiKeyProtocol, ResponsesTransport}; + +const MESSAGES_SSE: &str = concat!( + ": keepalive\r\n\r\n", + "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_native\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"gpt-5.4\",\"content\":[],\"usage\":{\"input_tokens\":10,\"cache_read_input_tokens\":2,\"cache_creation_input_tokens\":3,\"output_tokens\":0}}}\n\n", + "event: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}}\n\n", + "event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"hello\"},\"future\":true}\n\n", + "event: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\n", + "event: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\"},\"usage\":{\"input_tokens\":11,\"output_tokens\":2}}\n\n", + "event: message_stop\ndata: { \"type\":\"message_stop\",\"future\":{\"keep\":true} }\n\n", +); + +async fn seed(store: &Arc, server: &MockServer, protocol: ApiKeyProtocol) { + store + .seed_api_key_for_protocol( + "acct_provider_contract", + server.uri(), + ResponsesTransport::Http, + protocol, + ) + .await; +} + +fn messages_operation(stream: bool) -> Operation { + let body = json!({ + "model":"gpt-5.4", "max_tokens":128, "stream":stream, + "messages":[ + {"role":"assistant","content":[{"type":"thinking","thinking":"prior thought","signature":"real-native-signature"},{"type":"text","text":"before"}]}, + {"role":"user","content":"hello"}, + {"role":"system","content":[],"output_config":{"effort":"medium"}} + ], + "future_option":{"preserve":true} + }); + Operation::Generate(GenerateRequest::from_protocol_payload( + ProtocolPayload::json_object("anthropic", body.as_object().unwrap().clone()) + .unwrap() + .with_context(Map::from_iter([( + "opaque_request_headers".to_owned(), + json!([ + ["anthropic-version", STANDARD.encode("2026-10-21")], + ["anthropic-beta", STANDARD.encode("native-feature")], + ["anthropic-workspace-id", STANDARD.encode("workspace-test")], + ["x-business-extension", STANDARD.encode("keep")] + ]), + )])), + )) +} + +#[tokio::test] +async fn final_usage_before_truncation_keeps_only_explicitly_priceable_cost() { + for (priced, long_cache, fast) in [ + (false, false, false), + (true, false, false), + (true, true, false), + (true, false, true), + ] { + let server = MockServer::start().await; + let store = Arc::new(MemoryAccountStore::default()); + seed(&store, &server, ApiKeyProtocol::Messages).await; + let mut body = MESSAGES_SSE + .split("event: message_stop") + .next() + .unwrap() + .to_owned(); + if long_cache { + body = body.replace( + "\"cache_creation_input_tokens\":3", + "\"cache_creation_input_tokens\":3,\"cache_creation\":{\"ephemeral_1h_input_tokens\":3}", + ); + } + if fast { + body = body.replace( + "\"output_tokens\":2", + "\"output_tokens\":2,\"speed\":\"fast\"", + ); + } + Mock::given(method("POST")) + .and(path("/messages")) + .respond_with(ResponseTemplate::new(200).set_body_raw(body, "text/event-stream")) + .expect(1) + .mount(&server) + .await; + let pricing = if priced { + serde_json::from_value(json!({"openai":{"gpt-5.4":{ + "multiplierBps":10000,"bands":{"standard":{ + "input":"2","output":"4","cacheRead":"0.5","cacheWrite":"3" + }} + }}})) + .unwrap() + } else { + Default::default() + }; + let mut stream = provider(&store) + .execute( + planned_request("openai", messages_operation(true)), + context_with_pricing( + "req_messages_truncated", + CancellationToken::new(), + FastMode::Default, + pricing, + ), + ) + .await + .unwrap(); + let mut usage = Usage::new(); + let mut cost = None; + let mut failed = false; + while let Some(result) = stream.next().await { + match result { + Ok(event) => { + for fact in event.canonical_facts() { + match fact { + GatewayEvent::Usage(value) => usage.merge(value), + GatewayEvent::CalculatedCost(value) => { + cost = Some(value.clone().into_estimate()) + } + _ => {} + } + } + } + Err(error) => { + assert_eq!(error.kind(), ProviderErrorKind::Protocol); + failed = true; + } + } + } + assert!(failed); + assert_eq!(usage.input_tokens, Some(16)); + assert_eq!(usage.output_tokens, Some(2)); + if priced && !long_cache && !fast { + assert_eq!( + cost.unwrap().total().unwrap().amount().canonical(), + "0.00004" + ); + } else { + assert!(cost.is_none()); + } + server.verify().await; + } +} + +#[tokio::test] +async fn native_messages_preserve_json_sse_headers_and_real_signatures() { + for streaming in [false, true] { + let server = MockServer::start().await; + let store = Arc::new(MemoryAccountStore::default()); + seed(&store, &server, ApiKeyProtocol::Messages).await; + let json_response = "{ \"id\":\"msg_native\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"gpt-5.4\",\"content\":[{\"type\":\"text\",\"text\":\"hello\"}],\"stop_reason\":\"end_turn\",\"usage\":{\"input_tokens\":11,\"cache_read_input_tokens\":2,\"cache_creation_input_tokens\":3,\"output_tokens\":2},\"future\":true }\n"; + let raw = if streaming { + MESSAGES_SSE + } else { + json_response + }; + Mock::given(method("POST")) + .and(path("/messages")) + .and(header("x-api-key", "sk-api-test-only")) + .and(header("anthropic-version", "2026-10-21")) + .and(header("anthropic-beta", "native-feature")) + .respond_with(ResponseTemplate::new(200).set_body_raw( + raw, + if streaming { + "text/event-stream" + } else { + "application/json" + }, + )) + .expect(1) + .mount(&server) + .await; + let operation = messages_operation(streaming); + let original = operation.middleware_body().unwrap(); + let mut stream = provider(&store) + .execute( + planned_request("openai", operation), + context("req_messages_native", CancellationToken::new()), + ) + .await + .unwrap(); + let mut received = Vec::new(); + let mut usage = Usage::new(); + let mut timings = ProviderResponseTimings::default(); + while let Some(event) = stream.next().await { + let event = event.unwrap(); + if let Some(snapshot) = event.response_observation() { + timings = snapshot.timings(); + } + if let Some(wire) = event.wire_event() { + assert_eq!(wire.protocol(), "anthropic"); + if let Some(raw) = wire.raw_sse_frame().or(wire.raw_json_body()) { + received.extend_from_slice(raw); + } + } + for fact in event.canonical_facts() { + if let GatewayEvent::Usage(newer) = fact { + usage.merge(newer); + } + } + } + assert!(timings.first_event_ms.is_some()); + assert!(timings.first_token_ms.is_some()); + assert!(timings.first_text_ms.is_some()); + assert!(timings.first_reasoning_ms.is_none()); + assert_eq!(received, raw.as_bytes()); + assert_eq!(usage.input_tokens, Some(16)); + assert_eq!(usage.cached_input_tokens, Some(2)); + assert_eq!(usage.cache_write_input_tokens, Some(3)); + assert_eq!(usage.output_tokens, Some(2)); + let requests = server.received_requests().await.unwrap(); + assert_eq!( + serde_json::from_slice::(&requests[0].body).unwrap(), + serde_json::from_slice::(&original).unwrap() + ); + assert!(!requests[0].headers.contains_key("chatgpt-account-id")); + server.verify().await; + } +} + +#[tokio::test] +async fn messages_and_responses_translate_with_target_header_boundaries() { + for target in [ApiKeyProtocol::Messages, ApiKeyProtocol::Responses] { + let server = MockServer::start().await; + let store = Arc::new(MemoryAccountStore::default()); + seed(&store, &server, target).await; + let (endpoint, response) = if target == ApiKeyProtocol::Messages { + ("/messages", MESSAGES_SSE.to_owned()) + } else { + ( + "/responses", + format!( + "event: response.created\ndata: {{\"type\":\"response.created\",\"response\":{{\"id\":\"resp_scope_capture\",\"model\":\"gpt-5.4\",\"status\":\"in_progress\",\"output\":[]}}}}\n\n{CAPTURE_COMPLETED_SSE}" + ), + ) + }; + Mock::given(method("POST")) + .and(path(endpoint)) + .respond_with(ResponseTemplate::new(200).set_body_raw(response, "text/event-stream")) + .expect(1) + .mount(&server) + .await; + let operation = if target == ApiKeyProtocol::Messages { + generate_with_downstream_headers() + } else { + messages_operation(true) + }; + let expected_protocol = operation.protocol().to_owned(); + let mut stream = provider(&store) + .execute( + planned_request("openai", operation), + context("req_messages_translation", CancellationToken::new()), + ) + .await + .unwrap(); + let mut terminal_seen = false; + while let Some(event) = stream.next().await { + let event = event.unwrap(); + let terminal = event + .canonical_facts() + .iter() + .any(|fact| matches!(fact, GatewayEvent::Completed(_))); + for event in stream.translate_native_response(event, terminal).unwrap() { + if let Some(wire) = event.wire_event() { + assert_eq!(wire.protocol(), expected_protocol); + } + terminal_seen |= event + .canonical_facts() + .iter() + .any(|fact| matches!(fact, GatewayEvent::Completed(_))); + } + } + assert!(terminal_seen); + let requests = server.received_requests().await.unwrap(); + let headers = &requests + .iter() + .find(|request| request.method == "POST") + .unwrap() + .headers; + assert_eq!(headers.get("x-business-extension").unwrap(), "keep"); + if target == ApiKeyProtocol::Messages { + for name in [ + "session-id", + "thread-id", + "x-codex-future", + "x-openai-internal-future", + ] { + assert!(!headers.contains_key(name)); + } + } else { + for name in [ + "anthropic-version", + "anthropic-beta", + "anthropic-workspace-id", + ] { + assert!(!headers.contains_key(name)); + } + } + server.verify().await; + } +} + +#[tokio::test] +async fn custom_messages_and_responses_count_locally_without_billable_usage() { + for (target, source) in [ + (ApiKeyProtocol::Messages, "anthropic"), + (ApiKeyProtocol::Responses, "anthropic"), + (ApiKeyProtocol::Messages, "token-count"), + (ApiKeyProtocol::Responses, "token-count"), + ] { + let server = MockServer::start().await; + let store = Arc::new(MemoryAccountStore::default()); + seed(&store, &server, target).await; + let body = Bytes::from_static(br#"{"messages":[{"role":"user","content":"hello world"}]}"#); + let operation = Operation::CountTokens(TokenCountRequest::from_raw_json( + RawJsonPayload::new(source, body).unwrap(), + )); + let mut stream = provider(&store) + .execute( + planned_request("openai", operation), + context("req_messages_count", CancellationToken::new()), + ) + .await + .unwrap(); + let mut count = None; + while let Some(event) = stream.next().await { + let event = event.unwrap(); + assert!(!event.canonical_facts().iter().any(|fact| matches!( + fact, + GatewayEvent::Usage(_) | GatewayEvent::CalculatedCost(_) + ))); + if let Some(wire) = event.wire_event() { + assert_eq!(wire.protocol(), source); + let body: Value = serde_json::from_slice(wire.raw_json_body().unwrap()).unwrap(); + count = body.get("input_tokens").and_then(Value::as_u64); + } + } + assert!(count.is_some_and(|count| count > 0)); + assert!(server.received_requests().await.unwrap().is_empty()); + } +} + +#[tokio::test] +async fn cancelled_local_count_returns_no_usage_or_result() { + let server = MockServer::start().await; + let store = Arc::new(MemoryAccountStore::default()); + seed(&store, &server, ApiKeyProtocol::Responses).await; + let cancel = CancellationToken::new(); + let operation = Operation::CountTokens(TokenCountRequest::from_raw_json( + RawJsonPayload::new( + "anthropic", + Bytes::from_static(br#"{"messages":[{"role":"user","content":"hello"}]}"#), + ) + .unwrap(), + )); + let mut stream = provider(&store) + .execute( + planned_request("openai", operation), + context("req_cancel_local_count", cancel.clone()), + ) + .await + .unwrap(); + cancel.cancel(); + assert!( + matches!(stream.next().await, Some(Err(error)) if error.kind() == ProviderErrorKind::Cancelled) + ); + assert!(stream.next().await.is_none()); + assert!(server.received_requests().await.unwrap().is_empty()); +} + +#[tokio::test] +async fn official_messages_count_preserves_native_result_and_never_estimates_after_failure() { + use gateway_core::engine::middleware::outbound::Target; + + for source in ["anthropic", "token-count"] { + for status in [200, 429] { + let server = MockServer::start().await; + let store = Arc::new(MemoryAccountStore::default()); + store + .seed_api_key_for_protocol( + "acct_provider_contract", + "https://api.anthropic.com/v1".to_owned(), + ResponsesTransport::Http, + ApiKeyProtocol::Messages, + ) + .await; + let expected_body = if status == 200 { + "{ \"input_tokens\": 42 }\n" + } else { + "{\"type\":\"error\",\"error\":{\"type\":\"rate_limit_error\",\"message\":\"native count limited\"}}" + }; + Mock::given(method("POST")) + .and(path("/v1/messages/count_tokens")) + .and(header("x-api-key", "sk-api-test-only")) + .and(header("anthropic-version", "2023-06-01")) + .respond_with( + ResponseTemplate::new(status).set_body_raw(expected_body, "application/json"), + ) + .expect(1) + .mount(&server) + .await; + let uri = format!("{}/v1/messages/count_tokens", server.uri()); + let attempt = outbound_context("req_native_messages_count", move |request| { + // 验证官方目标已按原生计数准备,再通过现有出站挂载改向本地合同服务器 + let Target::Http { + method, + uri: original_uri, + } = &request.target + else { + panic!("原生计数必须使用 HTTP"); + }; + assert_eq!(method, reqwest::Method::POST); + assert_eq!( + original_uri, + "https://api.anthropic.com/v1/messages/count_tokens" + ); + assert!(!request.header_map().unwrap().contains_key("authorization")); + let body: Value = serde_json::from_slice(&request.body).unwrap(); + assert_eq!(body["model"], "gpt-5.4"); + assert!(body.get("max_tokens").is_none()); + request.target = Target::Http { + method: reqwest::Method::POST, + uri: uri.parse().unwrap(), + }; + Ok(()) + }); + let operation = Operation::CountTokens(TokenCountRequest::from_raw_json( + RawJsonPayload::new( + source, + Bytes::from_static(br#"{"messages":[{"role":"user","content":"hello"}]}"#), + ) + .unwrap(), + )); + let mut stream = provider(&store) + .execute(planned_request("openai", operation), attempt) + .await + .unwrap(); + let mut raw = Vec::new(); + let mut failed = false; + while let Some(event) = stream.next().await { + match event { + Ok(event) => { + assert!(!event.canonical_facts().iter().any(|fact| matches!( + fact, + GatewayEvent::Usage(_) | GatewayEvent::CalculatedCost(_) + ))); + if let Some(wire) = event.wire_event() { + assert_eq!(wire.protocol(), source); + if let Some(bytes) = wire.raw_json_body() { + raw.extend_from_slice(bytes); + } + } + } + Err(_) => failed = true, + } + } + assert_eq!(failed, status != 200); + if status == 200 { + assert_eq!(raw, expected_body.as_bytes()); + } else { + assert!(raw.is_empty()); + } + server.verify().await; + } + } +} + +#[tokio::test] +async fn translated_thinking_uses_selected_account_catalog_and_preserves_fast_betas() { + let store = Arc::new(MemoryAccountStore::default()); + let adaptive = MockServer::start().await; + let manual = MockServer::start().await; + for (account, server, capabilities) in [ + ( + "acct_provider_contract", + &adaptive, + json!({"thinking":{"supported":true,"types":{"adaptive":{"supported":true},"enabled":{"supported":false},"disabled":{"supported":false}}},"effort":{"high":{"supported":true}}}), + ), + ("acct_manual", &manual, json!({})), + ] { + store + .seed_api_key_for_protocol( + account, + server.uri(), + ResponsesTransport::Http, + ApiKeyProtocol::Messages, + ) + .await; + Mock::given(method("GET")).and(path("/models")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({"data":[{"id":"gpt-5.4","max_tokens":2048,"capabilities":capabilities}],"has_more":false}))) + .expect(1).mount(server).await; + Mock::given(method("POST")) + .and(path("/messages")) + .respond_with( + ResponseTemplate::new(200).set_body_raw(MESSAGES_SSE, "text/event-stream"), + ) + .expect(2) + .mount(server) + .await; + } + let provider = provider(&store); + for _ in 0..2 { + for account in ["acct_provider_contract", "acct_manual"] { + let body = json!({"model":"unrelated-client-alias","input":"hello","max_output_tokens":4096,"reasoning":{"effort":"xhigh"},"tools":[{"type":"function","name":"echo"}],"parallel_tool_calls":false,"service_tier":"priority"}); + let operation = Operation::Generate(GenerateRequest::from_protocol_payload( + ProtocolPayload::json_object("openai", body.as_object().unwrap().clone()) + .unwrap() + .with_context(Map::from_iter([( + "opaque_request_headers".into(), + json!([ + ["anthropic-beta", STANDARD.encode("feature-a")], + ["anthropic-beta", STANDARD.encode("feature-b")] + ]), + )])), + )); + let mut stream = Arc::clone(&provider) + .execute( + planned_request("openai", operation), + diagnostic_context("req_messages_capabilities", account), + ) + .await + .unwrap(); + while let Some(event) = stream.next().await { + event.unwrap(); + } + } + } + for (server, thinking) in [ + (&adaptive, json!({"type":"adaptive"})), + (&manual, json!({"type":"enabled","budget_tokens":2047})), + ] { + for request in server + .received_requests() + .await + .unwrap() + .iter() + .filter(|request| request.method == "POST") + { + let body: Value = serde_json::from_slice(&request.body).unwrap(); + assert_eq!(body["model"], "gpt-5.4"); + assert_eq!(body["thinking"], thinking); + assert_eq!(body["max_tokens"], 2048); + assert_eq!(body["speed"], "fast"); + assert!(body.get("service_tier").is_none()); + assert_eq!( + body["tool_choice"], + json!({"type":"auto","disable_parallel_tool_use":true}) + ); + assert_eq!( + request.headers.get("anthropic-beta").unwrap(), + "feature-a,feature-b,fast-mode-2026-02-01" + ); + } + server.verify().await; + } +} + +#[tokio::test] +async fn cancelled_capability_lookup_never_sends_generation() { + let server = MockServer::start().await; + let store = Arc::new(MemoryAccountStore::default()); + seed(&store, &server, ApiKeyProtocol::Messages).await; + Mock::given(method("GET")) + .and(path("/models")) + .respond_with( + ResponseTemplate::new(200) + .set_delay(Duration::from_secs(10)) + .set_body_json(json!({"data":[]})), + ) + .mount(&server) + .await; + let cancellation = CancellationToken::new(); + let cancelled = cancellation.clone(); + let task = tokio::spawn(async move { + provider(&store) + .execute( + planned_request("openai", generate_operation()), + context("req_cancel_catalog", cancelled), + ) + .await + }); + tokio::time::timeout(Duration::from_secs(2), async { + while server.received_requests().await.unwrap().is_empty() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + cancellation.cancel(); + let result = tokio::time::timeout(Duration::from_secs(1), task) + .await + .unwrap() + .unwrap(); + assert!(matches!(result,Err(error) if error.kind()==ProviderErrorKind::Cancelled)); + assert!( + server + .received_requests() + .await + .unwrap() + .iter() + .all(|request| request.method == "GET") + ); +} + +#[tokio::test] +async fn messages_json_and_sse_deliver_consistent_responses_terminal_states() { + for (reason, expected_status, expected_event) in [ + ("end_turn", "completed", "response.completed"), + ("max_tokens", "incomplete", "response.incomplete"), + ("refusal", "incomplete", "response.incomplete"), + ] { + let mut terminals = Vec::new(); + for upstream_streaming in [false, true] { + let server = MockServer::start().await; + let store = Arc::new(MemoryAccountStore::default()); + seed(&store, &server, ApiKeyProtocol::Messages).await; + let body = json!({"id":"msg_native","type":"message","role":"assistant","model":"gpt-5.4","content":[{"type":"text","text":"hello"}],"stop_reason":reason,"usage":{"input_tokens":11,"cache_read_input_tokens":2,"cache_creation_input_tokens":3,"output_tokens":2}}); + let response = if upstream_streaming { + ResponseTemplate::new(200).set_body_raw( + MESSAGES_SSE.replace("end_turn", reason), + "text/event-stream", + ) + } else { + ResponseTemplate::new(200).set_body_json(body) + }; + Mock::given(method("POST")) + .and(path("/messages")) + .respond_with(response) + .expect(1) + .mount(&server) + .await; + let mut stream = provider(&store) + .execute( + planned_request("openai", generate_with_downstream_headers()), + context("req_messages_terminal", CancellationToken::new()), + ) + .await + .unwrap(); + let mut terminal_count = 0; + while let Some(event) = stream.next().await { + let event = event.unwrap(); + let terminal = event + .canonical_facts() + .iter() + .any(|fact| matches!(fact, GatewayEvent::Completed(_))); + let translated = stream.translate_native_response(event, terminal).unwrap(); + for event in translated { + if event + .canonical_facts() + .iter() + .any(|fact| matches!(fact, GatewayEvent::Started(_))) + { + assert!( + event.wire_event().is_some(), + "原生出口的开始事实必须带可交付正文,不能提交空的 SSE 批次" + ); + } + if event + .canonical_facts() + .iter() + .any(|fact| matches!(fact, GatewayEvent::Completed(_))) + { + terminal_count += 1; + let wire = event.wire_event().expect("终态附在最后一个转换事件"); + assert_eq!(wire.data()["type"], expected_event); + assert_eq!(wire.data()["response"]["status"], expected_status); + terminals.push(wire.data()["response"].clone()); + } + } + } + assert_eq!(terminal_count, 1); + server.verify().await; + } + assert_eq!( + terminals[0], terminals[1], + "同一上游结果的 JSON 与 SSE 语义一致" + ); + } +} + +#[tokio::test] +async fn many_messages_json_blocks_stay_in_one_responses_terminal_event() { + let server = MockServer::start().await; + let store = Arc::new(MemoryAccountStore::default()); + seed(&store, &server, ApiKeyProtocol::Messages).await; + let content = (0..100) + .map(|index| json!({"type":"text","text":format!("block {index}")})) + .collect::>(); + Mock::given(method("POST")) + .and(path("/messages")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({"id":"msg_many","type":"message","role":"assistant","model":"gpt-5.4","content":content,"stop_reason":"max_tokens","usage":{"input_tokens":10,"output_tokens":100}}))) + .expect(1) + .mount(&server) + .await; + let mut stream = provider(&store) + .execute( + planned_request("openai", generate_with_downstream_headers()), + context("req_messages_many_blocks", CancellationToken::new()), + ) + .await + .unwrap(); + let mut received = Vec::new(); + while let Some(event) = stream.next().await { + let event = event.unwrap(); + let terminal = event + .canonical_facts() + .iter() + .any(|fact| matches!(fact, GatewayEvent::Completed(_))); + for event in stream.translate_native_response(event, terminal).unwrap() { + if let Some(wire) = event.wire_event() { + received.push(wire.data().clone()); + } + } + } + assert_eq!(received.len(), 1); + assert_eq!(received[0]["type"], "response.incomplete"); + assert_eq!( + received[0]["response"]["output"].as_array().unwrap().len(), + 100 + ); + assert_eq!( + received[0]["response"]["output"][99]["content"][0]["text"], + "block 99" + ); + server.verify().await; +} + +#[tokio::test] +async fn oversized_messages_json_is_rejected_before_wire_delivery() { + let server = MockServer::start().await; + let store = Arc::new(MemoryAccountStore::default()); + seed(&store, &server, ApiKeyProtocol::Messages).await; + let mut body = br#"{"type":"message","id":"msg_big","model":"gpt-5.4","content":[],"stop_reason":"end_turn","usage":{}}"#.to_vec(); + body.resize(16 * 1024 * 1024 + 1, b' '); + Mock::given(method("POST")) + .and(path("/messages")) + .respond_with(ResponseTemplate::new(200).set_body_raw(body, "application/json")) + .mount(&server) + .await; + let mut stream = provider(&store) + .execute( + planned_request("openai", messages_operation(false)), + context("req_big_json", CancellationToken::new()), + ) + .await + .unwrap(); + while let Some(event) = stream.next().await { + match event { + Err(err) => { + assert_eq!(err.kind(), ProviderErrorKind::Protocol); + return; + } + Ok(event) => assert!(event.wire_event().is_none()), + } + } + panic!("超限的 JSON 必须失败"); +} + +#[tokio::test] +async fn slow_catalog_does_not_block_generation_and_populates_next_turn() { + let server = MockServer::start().await; + let store = Arc::new(MemoryAccountStore::default()); + seed(&store, &server, ApiKeyProtocol::Messages).await; + Mock::given(method("GET")) + .and(path("/models")) + .respond_with( + ResponseTemplate::new(200) + .set_delay(Duration::from_secs(2)) + .set_body_json( + json!({"data":[{"id":"gpt-5.4","max_tokens":2048}],"has_more":false}), + ), + ) + .expect(1) + .mount(&server) + .await; + Mock::given(method("POST")) + .and(path("/messages")) + .respond_with(ResponseTemplate::new(200).set_body_raw(MESSAGES_SSE, "text/event-stream")) + .expect(2) + .mount(&server) + .await; + let provider = provider(&store); + for i in 0..2 { + let mut stream = provider + .clone() + .execute( + planned_request("openai", generate_operation()), + context("req_slow_catalog", CancellationToken::new()), + ) + .await + .unwrap(); + while let Some(event) = stream.next().await { + event.unwrap(); + } + if i == 0 { + tokio::time::sleep(Duration::from_secs(2)).await; + } + } + let limits = server + .received_requests() + .await + .unwrap() + .into_iter() + .filter(|r| r.method == "POST") + .map(|r| { + serde_json::from_slice::(&r.body).unwrap()["max_tokens"] + .as_u64() + .unwrap() + }) + .collect::>(); + assert_eq!(limits, [32000, 2048]); + server.verify().await; +} diff --git a/backend/crates/providers/openai/tests/provider/contract/mod.rs b/backend/crates/providers/openai/tests/provider/contract/mod.rs index 7a7968dcc..3eba4c4b8 100644 --- a/backend/crates/providers/openai/tests/provider/contract/mod.rs +++ b/backend/crates/providers/openai/tests/provider/contract/mod.rs @@ -8,6 +8,7 @@ mod cookies; mod correlation; mod error_details; mod image_model_access; +mod messages; mod model_account_eligibility; mod outbound; pub(super) use outbound::outbound_context; @@ -8163,7 +8164,7 @@ async fn responses_should_observe_and_bill_the_outbound_service_tier_on_both_tra false, Some(json!("default")), Some("priority"), - Some("default"), + None, Some(3_437_500), ), ( @@ -8179,7 +8180,7 @@ async fn responses_should_observe_and_bill_the_outbound_service_tier_on_both_tra false, Some(json!("priority")), Some("priority"), - Some("default"), + None, Some(3_437_500), ), ( @@ -8187,7 +8188,7 @@ async fn responses_should_observe_and_bill_the_outbound_service_tier_on_both_tra false, Some(json!("fast")), None, - Some("default"), + None, Some(3_437_500), ), ( @@ -8195,7 +8196,7 @@ async fn responses_should_observe_and_bill_the_outbound_service_tier_on_both_tra false, Some(json!("default")), None, - Some("default"), + None, Some(3_437_500), ), (FastMode::Disabled, false, None, None, None, Some(3_437_500)), @@ -8268,8 +8269,8 @@ async fn responses_should_observe_and_bill_the_outbound_service_tier_on_both_tra true, Some(json!("auto")), None, - Some("auto"), None, + Some(3_437_500), ), (FastMode::Enabled, false, None, None, None, Some(3_437_500)), ( @@ -8277,7 +8278,7 @@ async fn responses_should_observe_and_bill_the_outbound_service_tier_on_both_tra false, Some(json!("default")), None, - Some("default"), + None, Some(3_437_500), ), ] { @@ -12451,24 +12452,18 @@ async fn fast_policy_changes_preserve_the_websocket_continuation_and_meter_each_ let mut websocket = crate::transport::accept_codex_test_websocket_with(socket, |request, response| { // 提示头只在首次握手发送;后续档位由各自 response.create 正文指定 - assert_eq!( - request.headers()["x-codex-routing-hint"], - "model=gpt-5.4;tier=default" - ); + assert_eq!(request.headers()["x-codex-routing-hint"], "model=gpt-5.4"); response.headers_mut().insert( "sec-websocket-extensions", "permessage-deflate".parse().unwrap(), ); }) .await; - for (index, tier) in ["default", "priority", "default", "default"] - .into_iter() - .enumerate() - { + for (index, tier) in [None, Some("priority"), None, None].into_iter().enumerate() { let message = websocket.next().await.unwrap().unwrap(); let frame: Value = serde_json::from_str(message.to_text().unwrap()).unwrap(); assert_eq!(frame["type"], "response.create"); - assert_eq!(frame["service_tier"], tier); + assert_eq!(frame.get("service_tier").and_then(Value::as_str), tier); assert_eq!( frame.get("previous_response_id").cloned(), index @@ -12625,11 +12620,7 @@ async fn fast_policy_changes_preserve_the_websocket_continuation_and_meter_each_ ); assert_eq!( observed_tier.as_deref(), - Some(if fast_mode == FastMode::Enabled { - "priority" - } else { - "default" - }) + (fast_mode == FastMode::Enabled).then_some("priority") ); assert_eq!( costs, diff --git a/backend/crates/providers/openai/tests/provider/contract/passthrough.rs b/backend/crates/providers/openai/tests/provider/contract/passthrough.rs index 61e59f68c..03f0ac97b 100644 --- a/backend/crates/providers/openai/tests/provider/contract/passthrough.rs +++ b/backend/crates/providers/openai/tests/provider/contract/passthrough.rs @@ -300,3 +300,15 @@ async fn websocket_messages_preserve_text_and_metadata_despite_unrecognized_json assert!(completed); assert_eq!(&delivered[1..delivered.len() - 1], messages); } + +#[tokio::test] +async fn default_service_tiers_are_omitted_only_for_codex_oauth() { + for tier in ["auto", "default", "priority", "flex"] { + for api_key in [false, true] { + let body = json!({"model":"gpt-5.4","input":"hello","service_tier":tier}); + let sent = capture_downstream_request(body, api_key, false, false).await; + let expected = (api_key || !matches!(tier, "auto" | "default")).then_some(tier); + assert_eq!(sent.get("service_tier").and_then(Value::as_str), expected); + } + } +} diff --git a/backend/crates/providers/openai/tests/provider/contract/search_model_access.rs b/backend/crates/providers/openai/tests/provider/contract/search_model_access.rs index 380c14d84..ca2198c79 100644 --- a/backend/crates/providers/openai/tests/provider/contract/search_model_access.rs +++ b/backend/crates/providers/openai/tests/provider/contract/search_model_access.rs @@ -369,3 +369,68 @@ async fn search_model_selection_does_not_restrict_plugin_body_rewrites() { "plugin-model" ); } + +#[tokio::test] +async fn search_reuses_protocol_projection_until_credential_revision_changes() { + use gateway_core::account::{CredentialCasUpdate, ProviderAccountUpdate}; + use provider_openai::credential::{ + ApiKeyProtocol, CodexCredentialCodec, CodexCredentialData, ResponsesTransport, + }; + let store = Arc::new(MemoryAccountStore::default()); + let server = MockServer::start().await; + store + .seed_api_key_for_protocol( + FIRST, + server.uri(), + ResponsesTransport::Http, + ApiKeyProtocol::Messages, + ) + .await; + let provider = provider(&store); + let ctx = || { + attempt( + AccountAttemptContext::new(BTreeSet::new(), None, None) + .with_account_scope(scope(AccountModelAccess::all(), AccountModelAccess::all())), + AccountAffinity::Strict, + 1, + None, + ) + }; + let loads = store.credential_loads(); + for _ in 0..2 { + let err = provider + .clone() + .execute(search(BODY), ctx()) + .await + .err() + .unwrap(); + assert_eq!(err.kind(), ProviderErrorKind::NoEligibleAccount); + } + assert_eq!(store.credential_loads() - loads, 1); + let id = ProviderAccountId::new(FIRST).unwrap(); + let loaded = store.load_current_credential(&id).await.unwrap(); + let mut data = CodexCredentialCodec::decode_complete(&loaded.credential).unwrap(); + let CodexCredentialData::ApiKey(config) = &mut data else { + panic!("预期 API Key 账号"); + }; + config.protocol = ApiKeyProtocol::Responses; + let update = CredentialCasUpdate::new( + id.clone(), + loaded.account.revision(), + ProviderAccountUpdate { + account_id: id.clone(), + name: FIRST.to_owned(), + email: None, + plan_type: None, + }, + CodexCredentialCodec::encode_complete(data).unwrap(), + false, + None, + None, + ) + .unwrap() + .preserving_profile(); + store.compare_and_swap_credential(update).await.unwrap(); + let stream = provider.execute(search(BODY), ctx()).await.unwrap(); + assert_eq!(stream.metadata().provider_account_id(), &id); +} diff --git a/backend/crates/providers/openai/tests/provider/contract/upstream_adapter.rs b/backend/crates/providers/openai/tests/provider/contract/upstream_adapter.rs index 2ca3eddbb..47c1a2e4d 100644 --- a/backend/crates/providers/openai/tests/provider/contract/upstream_adapter.rs +++ b/backend/crates/providers/openai/tests/provider/contract/upstream_adapter.rs @@ -1011,7 +1011,7 @@ impl UpstreamAdapter for ConnectionProbe { } fn supports_authentication(&self, kind: &str) -> bool { - kind == "oauth" + matches!(kind, "oauth" | "api_key") } fn execute( @@ -1039,6 +1039,7 @@ impl UpstreamAdapter for ConnectionProbe { async fn selected_adapter_connection( provider: Arc, request_id: &str, + pricing: gateway_core::metering::PricingOverrides, ) -> SelectedConnection { let (selected, receiver) = oneshot::channel(); let plan = gateway_core::engine::upstream_adapter::FrozenUpstreamAdapterPlan::new( @@ -1055,7 +1056,8 @@ async fn selected_adapter_connection( ModelRequestId::new(request_id).unwrap(), ClientApiKeyId::new("key_openai_contract").unwrap(), ) - .with_upstream_adapters(Some(plan)), + .with_upstream_adapters(Some(plan)) + .with_pricing(Arc::new(pricing)), NonZeroU32::MIN, SystemTime::now() + Duration::from_secs(5), account_policy(), @@ -1075,6 +1077,62 @@ async fn selected_adapter_connection( receiver.await.unwrap() } +#[tokio::test] +async fn messages_adapter_uses_api_key_identity_and_only_configured_prices() { + for priced in [false, true] { + let store = Arc::new(MemoryAccountStore::default()); + let server = MockServer::start().await; + store + .seed_api_key_for_protocol( + "acct_provider_contract", + server.uri(), + provider_openai::credential::ResponsesTransport::Http, + provider_openai::credential::ApiKeyProtocol::Messages, + ) + .await; + let pricing = if priced { + serde_json::from_value(json!({"openai":{"gpt-5.4":{ + "multiplierBps":10000,"bands":{"standard":{ + "input":"2","output":"4","cacheRead":"0.5","cacheWrite":"3" + }} + }}})) + .unwrap() + } else { + Default::default() + }; + let connection = + selected_adapter_connection(provider(&store), "req_messages_adapter", pricing).await; + let headers = connection.authorization().unwrap(); + assert_eq!(headers.len(), 1); + assert_eq!(headers[0].name(), "x-api-key"); + assert_eq!(headers[0].value(), b"sk-api-test-only".as_slice()); + let cost = connection.calculate_cost( + None, + &Usage { + input_tokens: Some(16), + output_tokens: Some(2), + cached_input_tokens: Some(2), + cache_write_input_tokens: Some(3), + ..Usage::new() + }, + ); + if priced { + assert_eq!( + cost.unwrap() + .into_estimate() + .total() + .unwrap() + .amount() + .canonical(), + "0.00004" + ); + } else { + assert!(cost.is_none()); + } + assert!(server.received_requests().await.unwrap().is_empty()); + } +} + #[tokio::test] async fn guardian_reservation_survives_upstream_adapters_and_metadata_precedence() { // 普通池上限 2 且已满,审批独立池仍有空位;关闭独立池后审批也受普通容量约束 @@ -1194,8 +1252,12 @@ async fn upstream_adapter_reloads_rotated_credentials_and_proxy_without_acceptin store.set_egress(account_id, Some(old_proxy.clone()), None); let upstream = MockServer::start().await; let provider = provider_with_base_url(&store, upstream.uri()); - let old = - selected_adapter_connection(Arc::clone(&provider), "req_adapter_before_refresh").await; + let old = selected_adapter_connection( + Arc::clone(&provider), + "req_adapter_before_refresh", + Default::default(), + ) + .await; let before = store.account(account_id).unwrap(); assert_eq!(old.outbound_proxy(), Some(&old_proxy)); @@ -1211,7 +1273,9 @@ async fn upstream_adapter_reloads_rotated_credentials_and_proxy_without_acceptin .await .unwrap(); store.set_egress(account_id, Some(new_proxy.clone()), None); - let current = selected_adapter_connection(provider, "req_adapter_after_refresh").await; + let current = + selected_adapter_connection(provider, "req_adapter_after_refresh", Default::default()) + .await; assert_eq!(current.account_id(), old.account_id()); assert_eq!(current.credential_revision(), revision); assert_ne!(current.credential_revision(), old.credential_revision()); diff --git a/backend/crates/providers/openai/tests/provider/live.rs b/backend/crates/providers/openai/tests/provider/live.rs index 9aa82ffd8..319fc3b7b 100644 --- a/backend/crates/providers/openai/tests/provider/live.rs +++ b/backend/crates/providers/openai/tests/provider/live.rs @@ -978,7 +978,6 @@ async fn accept_live_proxy( .unwrap() } -#[cfg(target_os = "linux")] async fn read_live_head(stream: &mut (impl tokio::io::AsyncRead + Unpin)) -> String { use tokio::io::AsyncReadExt; let mut head = Vec::new(); diff --git a/backend/crates/providers/openai/tests/support.rs b/backend/crates/providers/openai/tests/support.rs index df9f0f6e4..4c70d6387 100644 --- a/backend/crates/providers/openai/tests/support.rs +++ b/backend/crates/providers/openai/tests/support.rs @@ -103,6 +103,22 @@ impl MemoryAccountStore { id: &str, base_url: String, transport: provider_openai::credential::ResponsesTransport, + ) { + self.seed_api_key_for_protocol( + id, + base_url, + transport, + provider_openai::credential::ApiKeyProtocol::Responses, + ) + .await; + } + + pub(crate) async fn seed_api_key_for_protocol( + &self, + id: &str, + base_url: String, + transport: provider_openai::credential::ResponsesTransport, + protocol: provider_openai::credential::ApiKeyProtocol, ) { let credential = provider_openai::credential::CodexCredentialCodec::encode_complete( provider_openai::credential::CodexCredentialData::ApiKey( @@ -110,6 +126,7 @@ impl MemoryAccountStore { schema_version: 1, installation_id: uuid::Uuid::new_v4().to_string(), base_url, + protocol, api_key: "sk-api-test-only".to_owned(), transport, }, diff --git a/deploy/README.md b/deploy/README.md index 120ab74bc..521cd152d 100644 --- a/deploy/README.md +++ b/deploy/README.md @@ -661,7 +661,7 @@ metrics_exporter = "none" 验证 WebSocket 时直接连接后端,当前 Vite 代理未显式开启 WebSocket 转发 其他客户端使用 Responses API、`/v1` Base URL 和代理密钥即可,不需要 Actor 标记。 -路由与请求格式见 [API 参考](../docs/api.md#3-openai-数据面与模型目录) +路由与请求格式见 [API 参考](../docs/api.md#3-模型数据面与模型目录) ## 停止与重启 diff --git a/docs/api.md b/docs/api.md index 0171d8a24..82fd2d981 100644 --- a/docs/api.md +++ b/docs/api.md @@ -7,7 +7,7 @@ | 查找内容 | 入口 | | --- | --- | | 鉴权与响应 | [公共约定](#1-鉴权与公共约定) · [浏览器会话与 Key 自助页](#4-浏览器认证) | -| 客户端协议 | [Responses、Chat、Images、模型与 Provider 操作](#3-openai-数据面与模型目录) · [额度查询](#api-key-额度查询) | +| 客户端协议 | [Responses、Chat、Messages、Images 与模型目录](#3-模型数据面与模型目录) · [额度查询](#api-key-额度查询) | | 账号与授权范围 | [账号](#5-账号) · [代理](#独立代理管理--managed-proxies) · [分组](#6-账号分组) · [Client Key](#7-client-key) | | 系统与运维 | [健康检查](#2-健康检查) · [运行设置](#8-运行设置) · [备份](#9-备份) · [统计与诊断](#10-dashboard用量与错误) · [版本与更新](#11-版本更新与重启) | | 插件 | [安装包与来源](#安装包与来源) · [运行实例](#121-运行实例) · [管理扩展](#122-管理扩展页面与原始-api) | @@ -18,7 +18,7 @@ 可改写请求、覆盖本次请求设置、直接返回响应或接管 WebSocket 升级;管理、模型、健康检查和静态资源使用同一入口。 挂载与覆盖合同见 [SDK 洋葱中间件](../backend/crates/gateway-plugin/sdk/docs/capabilities.md#洋葱中间件) -### OpenAI 数据面客户端接口 +### 数据面客户端接口 默认情况下,`/v1/*` 使用管理端创建的 Client Key: @@ -29,6 +29,9 @@ Authorization: Bearer sk_... 自动生成的 Key 保持 `sk_` 格式;迁入的自定义 Key 使用保存时的原值,不限制前缀或固定长度。 无论格式如何,只有已保存且启用的 Client Key 能通过鉴权 +`/v1/messages` 与 `/v1/messages/count_tokens` 也接受 `x-api-key: `。 +同时提供两个认证头时优先使用 `Authorization`;客户端提交的是网关 Client Key,上游密钥由选中的账号提供 + 启用[入口认证插件](../backend/crates/gateway-plugin/sdk/docs/capabilities.md#数据面入口认证)时, `Authorization` 可按插件协议校验,并由宿主将外部身份映射到明确绑定的 Client Key。 账号范围、模型权限、并发和预算仍由该 Key 决定;插件认证不接管管理员或 Key 自助页登录 @@ -59,7 +62,7 @@ ChatGPT 远程控制使用 `(codex_chatgpt_<平台>_remote; <版本>)` 形式的 远程客户端版本不能替代 Desktop 应用版本,因此也无法保证其满足 Desktop 最低版本要求。 携带 `version` 头或 Desktop 应用版本后缀时仍按上述规则校验,非法版本不会因远程标记而放行 -低版本响应使用 OpenAI 风格错误格式: +Responses 和 Chat 入口的低版本响应使用 OpenAI 风格错误格式: ```json { @@ -98,7 +101,7 @@ HTTPS 来源以及缺失、`null` 或非法来源保留 `Secure`。`HttpOnly`、 小响应、SSE、其他流式正文及已有内容编码的响应不再压缩;模型执行接口不经过管理端压缩层 配置了 CORS 白名单 origin 时,跨域请求以凭据模式放行,仅允许 `GET`/`POST` 方法和 -`authorization`、`content-type`、`x-api-key` 与 request ID 四个请求头,不使用通配符 +`authorization`、`content-type`、`x-api-key`、`anthropic-version`、`anthropic-beta` 和 request ID 请求头,不使用通配符 普通成功响应使用以下信封: @@ -208,9 +211,9 @@ Dashboard 的 `lastUsedRelative` 和账号额度的 `refreshedAtRelative` 由后 两个接口均返回空正文。探针并行执行,共用 2 秒截止时间 -## 3. OpenAI 数据面与模型目录 +## 3. 模型数据面与模型目录 -除下述入站解压保护外,Responses、Chat Completions、Images 和 standalone Search HTTP body、 +除下述入站解压保护外,Responses、Chat Completions、Messages、Images 和 standalone Search HTTP body、 WebSocket message 和 frame 不设置网关私有长度上限;请求字段与协议限制见各入口说明 | 方法 | 路由 | 说明 | @@ -218,16 +221,30 @@ WebSocket message 和 frame 不设置网关私有长度上限;请求字段与 | `POST` | `/v1/responses` | OpenAI Responses JSON;`stream=true` 返回 SSE,否则返回完整 JSON | | `GET` | `/v1/responses` | 通过 HTTP Upgrade 建立 Responses WebSocket | | `POST` | `/v1/chat/completions` | Chat Completions 转 Responses 执行;返回单 choice 的 Chat JSON 或 SSE | +| `POST` | `/v1/messages` | Anthropic Messages JSON;`stream=true` 返回 SSE,否则返回完整 JSON | +| `POST` | `/v1/messages/count_tokens` | 返回 Messages 请求的输入 Token 数;原生计数与本地估算边界见下 | | `POST` | `/v1/alpha/search` | Codex standalone web search;JSON 请求与响应正文原样转发 | | `POST` | `/v1/images/generations` | 通过 OpenAI Provider 发起图像生成;JSON 请求与响应正文原样转发 | | `POST` | `/v1/images/edits` | 通过 OpenAI Provider 发起图像编辑;JSON 原样转发,multipart 上传转为原生 Images JSON | | `GET` | `/v1/models` | 返回当前 Client Key 账号范围内各 Provider 的可用公开模型并集;有两种响应形态,见下 | | `GET` | `/v1/models/{model_id}` | 返回 OpenAI 兼容的单模型详情 | -| `POST` | `/v1/providers/{provider}/models/{model}/count_tokens` | 调用指定 Provider/model 声明的精确 Token 计数;请求和响应均为 JSON | +| `POST` | `/v1/providers/{provider}/models/{model}/count_tokens` | 调用指定 Provider/model 声明的 Token 计数;请求和响应均为 JSON,计数方式由 Provider 决定 | | `GET` / `POST` | `/v1/providers/{provider}/http/{endpoint}` | 调用指定 Provider 预先声明的固定 HTTP 操作;不是任意 URL 代理 | | `GET` | `/v1/usage` | 查询当前 Client Key 的日与周额度,仅使用网关已结算的 USD 账本 | | `GET` | `/v1/cpr/link` | 返回当前 Key 获准公开的预算及直连账号池观测 | +生成接口支持三种入站协议;API Key 账号通过 `protocol` 选择 Responses 或 Messages 上游,仍使用 `openai` Provider。 +OAuth 账号使用 Responses 上游。入站路由不决定上游协议,实际执行由 Client Key 的账号范围、模型和调度结果决定 + +| 入站 | Responses 上游 | Messages 上游 | +| --- | --- | --- | +| Responses | 原生 Responses wire | Responses 与 Messages 双向转换 | +| Chat Completions | Chat 与 Responses 双向转换 | Chat 经 Responses 与 Messages 双向转换 | +| Messages | Messages 与 Responses 双向转换 | 原生 Messages wire | + +同协议保留原生业务 wire,观测和计量不用于重建响应正文;跨协议按目标格式转换请求、完整响应及 SSE。 +Messages 与 Responses 的转换边界见 [Messages 请求](#messages-请求),账号配置见[账号能力、导入与 OAuth](#账号能力导入与-oauth) + ### Chat Completions 请求 `POST /v1/chat/completions` 接受 Chat 消息历史,转换为 Responses 请求执行,再交付 Chat 格式结果。 @@ -254,7 +271,8 @@ print(completion.choices[0].message.content) #### 请求字段 -入口负责将 Chat 结构映射为 Responses;同语义字段的模型支持范围、取值范围与业务有效性由 Provider 和上游判断。 +入口负责将 Chat 结构映射为 Responses;下表描述这一入口映射,选择 Messages 上游后还会按目标协议转换。 +同语义字段的模型支持范围、取值范围与业务有效性由 Provider 和上游判断。 只有结构无法解码或不能正确表达的语义在本地返回 `400`,错误中的 `param` 指向字段,不回显字段值 | 字段 | 支持与映射 | @@ -321,13 +339,87 @@ OpenAI 是此入口的兼容目标,混合分组沿用账号范围内的选路 每项为 `type: "image_url"` 和包含 data URL 的 `image_url` 对象;流中带图片 `index`,预览与最终结果可能更新同一项。 这是 Chat 扩展,需要客户端支持;音频输出和需要客户端执行的其他未映射动作不受支持 -Chat 沿用 [Client Key 鉴权](#openai-数据面客户端接口)、[请求期限](#请求期限)、[请求解压](#请求解压)、 -[请求头与身份](#请求头与身份)及[隐私策略](#隐私策略)。隐私策略的 `request_body` 面向转换后的 Responses 正文, -例如 `$.input`,不需要另外维护一套针对 `messages` 的规则 +Chat 沿用 [Client Key 鉴权](#数据面客户端接口)、[请求期限](#请求期限)、[请求解压](#请求解压)、 +[请求头与身份](#请求头与身份)及[隐私策略](#隐私策略)。隐私策略的 `request_body` 面向目标上游正文, +Responses 上游使用 `$.input`,Messages 上游使用 `$.messages` 转换后的请求按选中的 Provider 执行。OpenAI 的字段处理见[正文兼容](#正文兼容); 输出上限原值交给上游校验,低于模型下限时会收到上游错误 +### Messages 请求 + +`POST /v1/messages` 接受非空字符串 `model`、非空 `messages` 数组和非负整数 `max_tokens`。 +消息角色为 `user`、`assistant` 或 `system`,`content` 为字符串或内容块数组;初始系统指令放在顶层 `system`, +会话中的 `system` 消息保留其位置,具体模型支持情况由上游校验。 +`stream` 缺省或 `false` 返回 JSON,`true` 返回 SSE。每轮由客户端携带所需的完整上下文。Claude Code 用 `--resume` 恢复本地会话后,仍通过 `messages` 发送上下文;网关不缓存对话正文用于下一轮。 +Messages 没有服务端历史续接或 WebSocket 入口 + +```bash +curl https://gateway.example.com/v1/messages \ + -H "x-api-key: ${CPR_CLIENT_KEY}" \ + -H 'anthropic-version: 2023-06-01' \ + -H 'Content-Type: application/json' \ + -d '{"model":"","max_tokens":128,"messages":[{"role":"user","content":"你好"}]}' +``` + +Messages 上游保留 `system`、工具、thinking、缓存控制和未知扩展字段,由上游判断具体能力。 +流式结果使用 `message_start`、`content_block_start/delta/stop`、`message_delta` 和 `message_stop` 等原生事件, +同协议 SSE 保留原始事件帧;流结束不附加 OpenAI 的 `[DONE]`。`usage` 保留输入、输出及缓存用量,缺失值不补造 + +跨 Responses 与 Messages 转换参考 CLIProxyAPI(CPA)的字段映射与降级规则:文本、图片、文档、工具调用及结果按目标结构映射, +无对应语义的可选字段或内容可能被忽略或降级,具体参数仍由目标上游校验。 +推理签名与加密内容按来源回传,不能作为另一协议的原生签名使用;未知内容需要完整保留时应选择同协议上游。 +Messages 细粒度工具流转向 Responses 时保留原始 function 参数字符串,完成状态取自上游停止原因; +以 `max_tokens` 等明确中断结束时返回 `incomplete`。 +截断的 custom 包装提取已生成字符串,未完成转义按原片段保留。 +Messages 上游返回的单个非流式 JSON 正文最多 16 MiB,超限即结束请求;此上限不针对 SSE 全流。 +Messages 非流式聚合要求工具输入可解析;结构无法解码或缺少必要终态时返回错误 + +转向 Messages 时,工具结果按紧邻调用轮次配对,并排在用户消息其他内容之前。 +缺失结果补为调用中断错误,延迟或孤立结果按普通内容承载;同一用户轮次的重复结果保留最后一条。 +Responses 流已交付工具调用时,即使终帧不再列出输出项,Messages 仍返回 `stop_reason: tool_use`;明确的截断或暂停原因优先。 + +Responses 的 `allowed_tools` 只向 Messages 上游声明本轮允许的工具,历史调用仍保留原名; +若没有可用工具,或上游不能执行 `required` 约束,则拒绝请求。 +跨协议搜索保留域名允许和禁止列表;缓存或索引搜索不会转为实时联网。Messages 搜索带有单工具 `max_uses` 限制时,转向 Responses 的生成请求会被拒绝 + +跨协议推理设置读取顶层 `thinking`、`output_config.effort` 或 `reasoning.effort`。 +转向 Messages 时按所选账号模型目录声明的能力选择 adaptive 或手动预算,并约束输出上限和 effort 等级。 +不支持关闭的 adaptive 模型将 `none` 降到最低可用 effort;手动预算至少为 1024、严格小于输出上限,不足时关闭推理。 +生成请求最多等待目录 500 ms;未及时取得目录或未声明能力时沿用 CPA 手动预算,`auto` 使用 8192,不根据模型别名猜测能力。 +强制工具与手动推理冲突时显式关闭推理;紧接着只回传工具结果且未指定 effort 时,沿用无思考模式。 +adaptive 路径将普通强制选择降为 `auto`,保留串行约束。 +仅设置 `parallel_tool_calls:false` 也会生成串行工具选择,`none` 不携带并行选项。 +生成启用推理的配置时省略不相容的 `temperature/top_p`,同协议不执行这些转换 + +服务档位按目标协议映射:Responses `default` 对应 Messages `standard_only`,`auto` 保留,无法对应的档位省略。 +按 CPA 将 Responses `priority` 与 Messages `speed:fast` 双向映射;这两个字段不代表相同的服务承诺。 +跨协议生成 fast 请求时补充 `fast-mode-2026-02-01` beta,并保留已有 beta;目标是否支持 fast 由上游校验。 +Codex OAuth 出站省略 `auto/default`,Responses API Key 保留这些公开 API 参数。 +会话内配置、工具增删和指令生效期限等扩展需要完整保留时使用同协议上游 + +Messages 错误使用 `{"type":"error","error":{"type":"...","message":"..."}}`;SSE 开始后使用 `event: error`。 +入口沿用 Client Key 的账号范围、模型权限、并发、预算、取消和[请求解压](#请求解压)保护。 +请求中间件处理 Messages 正文,隐私策略的 `request_body` 对应目标上游实际发送的协议结构 + +Messages 费用按管理员显式配置的模型价格计算,未配置时保留用量并将费用标为未知 +当前价格合同未分别表达 fast 加速、1 小时缓存写入和服务端工具单价;请求 fast 或出现这些费用项目时保留用量,费用标为未知 + +#### Messages 输入计数 + +`POST /v1/messages/count_tokens` 接受同一格式的 `model`、`messages`、可选 `system` 和 `tools`,不要求 `max_tokens`, +返回 `{"input_tokens":123}`。该接口只计算输入,不生成助手输出;账号范围、模型映射与准入规则沿用模型请求 + +| 选中的上游 | 计数方式 | +| --- | --- | +| Messages,地址为官方 `https://api.anthropic.com`,HTTPS 端口为 443 | 请求上游 API 前缀下的 `messages/count_tokens`,返回原生计数结果 | +| 自定义 Messages 上游 | 对 Messages 内容使用本地 tokenizer 估算 | +| Responses 上游,包括 OAuth | 先投影为 Responses 内容,再使用本地 tokenizer 估算 | + +本地估算按模型选择 tokenizer,计算可提取的文本、工具定义与工具内容,不包含图片、音频、视频、二进制文档及隐藏推理的模型专用成本。 +它不保证与上游账单或完整多模态上下文一致,也不发送上游生成请求或产生上游用量。 +官方原生计数失败时保留失败,不静默切换为估算 + ### Images 请求 Images 使用原生非流式 JSON 端点,JSON 请求与响应正文原样转发。 @@ -357,8 +449,9 @@ multipart 的 `image` 和 `image[]` 上传按出现顺序组成 `images` 数组 `POST /v1/providers/{provider}/models/{model}/count_tokens` 接受最多 8 MiB 的合法 JSON,且只路由到 为该模型明确声明 `count_tokens` 的 Provider。Core 不解释或重写请求/响应 JSON,响应必须是目标 Provider 按其 -声明的本地精确 tokenizer 或上游精确计数合同返回的原始 JSON;没有准确实现时返回不支持,不从 usage -或字符数推算。响应固定使用 `application/json` 并重算 `Content-Length` +声明的计数合同返回的原始 JSON,不从生成 usage 或字符数推算。OpenAI Provider 接受 Messages 的计数正文, +模型由路径指定;官方 Messages 使用原生计数,其他账号使用与 `/v1/messages/count_tokens` 相同的本地 BPE 估算。 +响应固定使用 `application/json` 并重算 `Content-Length` `GET|POST /v1/providers/{provider}/http/{endpoint}` 只允许 Provider descriptor 中该 endpoint 声明的 方法;`HEAD`、其他方法、未声明 endpoint 和未声明的方法在出站前拒绝。GET 不能携带正文,POST 正文 @@ -384,7 +477,8 @@ Codex 的 review 等子代理请求仍使用 `/v1/responses`,并通过 `x-open #### 请求解压 -`POST /v1/responses` 与 `POST /v1/chat/completions` 在鉴权后按 `Content-Encoding` 解压,再解析 JSON;支持单一 `gzip`、 +`POST /v1/responses`、`POST /v1/chat/completions`、`POST /v1/messages` 与 `/v1/messages/count_tokens` +在鉴权后按 `Content-Encoding` 解压,再解析 JSON;支持单一 `gzip`、 `deflate`(zlib 封装)和 `zstd`,缺省、空值或 `identity` 直接使用原始正文。gzip 多成员与 zstd 多帧连续解码,整体展开结果受运行设置 `responsesMaxDecompressedBodyBytes` 约束(默认 64 MiB), 超限在继续展开前返回 `400 request_too_large`,错误信息包含当前请求的上限字节数。zstd @@ -393,7 +487,8 @@ Codex 的 review 等子代理请求仍使用 `/v1/responses`,并通过 `x-open 见[请求解压上限](#请求解压上限)。 不支持的编码、逗号分隔的叠加编码和重复 `Content-Encoding` 头返回 `400 unsupported_content_encoding`;压缩正文损坏、截断或解压后不是合法 JSON 返回 -`400 invalid_json`。本地错误不包含原始正文或解压库细节。WebSocket 文本帧不经过这条解压路径 +`400 invalid_json`,Messages 入口使用对应的 `invalid_request_error` 错误封套。 +本地错误不包含原始正文或解压库细节。WebSocket 文本帧不经过这条解压路径 #### 请求头与身份 @@ -401,7 +496,7 @@ Responses 不透传下游的逐跳头、反代元数据(如 `cf-*`、`x-forwar `cdn-loop`)以及 `Accept-Encoding` / `Content-Encoding`。链路元数据和编解码能力 由各段传输层独立管理;其余业务扩展头继续透传,不使用固定业务头白名单。 此规则同时适用于上游 HTTP 和 WebSocket,不影响上游响应的 `cf-ray` 等诊断信息。 -API Key 与 OAuth 共用模拟客户端画像(`User-Agent`、`originator`、`version`)和业务头透传规则, +Responses API Key 与 OAuth 共用模拟客户端画像(`User-Agent`、`originator`、`version`)和业务头透传规则, 包括会话、线程、Lite 和其他业务扩展头。 上游认证只来自选中的账号;API Key 不携带 OAuth Cookie、ChatGPT 账号身份或下游的 `X-OpenAI-Actor-Authorization` 托管认证声明。 @@ -532,8 +627,9 @@ HTTP/SSE 与 WS 入站共用此判断;新链在发送前重新建连,依赖 控制帧发送成功不等于上游已确认中断;若上游仍返回 `response.completed`,按正常完成处理 OAuth 账号默认 `prefer_websocket`,客户端使用 HTTP/SSE 时仍可能选择上游 WebSocket; -可将账号上游传输方式设为 `http`,固定使用 HTTP/SSE。API Key 账号默认使用 HTTP/SSE, -也可配置 `prefer_websocket`。必须依赖 WS 的协议预热、非持久化新链和连接内续接不使用 HTTP-only 账号。 +可将账号上游传输方式设为 `http`,固定使用 HTTP/SSE。Responses API Key 账号默认使用 HTTP/SSE, +也可配置 `prefer_websocket`;Messages API Key 账号只支持 `http`。 +必须依赖 WS 的协议预热、非持久化新链和连接内续接不使用 HTTP-only 账号。 客户端配置的 `supports_websockets` 只控制第一段连接,不是服务端传输策略开关。 上游在响应终态前发送 Close 1000 仍属于失败,不能按“正常关闭”计为成功 @@ -573,7 +669,14 @@ HTML 或截断正文当作 message。 ### 模型目录 -`GET /v1/models` 默认返回 OpenAI 兼容列表 `{"object": "list", "data": [...]}`;请求携带非空 +携带 `anthropic-version` 或 `x-api-key` 请求头时,`GET /v1/models` 返回 Messages 模型目录: +`{ data, first_id, last_id, has_more }`,单条模型使用 `type: "model"`、`id`、`display_name` 和 `created_at` +模型范围仍由 Client Key 权限、分组与别名决定,未知发布日期使用 Unix epoch,未知能力和 Token 上限为 null + +该格式支持 `after_id`、`before_id` 游标和 `limit`,默认每页 20 条,范围 1–1000;未知游标或无效限制返回 400 +`GET /v1/models/{model_id}` 使用同一显式协议头选择格式和错误合同,不根据 User-Agent 猜测协议 + +未携带上述协议头时,`GET /v1/models` 默认返回 OpenAI 兼容列表 `{"object": "list", "data": [...]}`;请求携带非空 `client_version` query 参数(Codex 客户端)时改为返回 Codex 专用目录合同 `{"models": [...]}` OpenAI Provider 按客户端传入的 `client_version` 请求上游目录,完整保留每个模型 JSON 对象,包括 @@ -621,7 +724,7 @@ Codex 专用目录中的 `context_window` 与 `max_context_window` 分别表示 #### OpenAI 透传 -OpenAI 路径保留客户端 Responses wire 语义:除[正文兼容](#正文兼容)、[身份归一](#请求头与身份)、模型映射及已配置的请求策略外, +Responses 同协议路径保留客户端 wire 语义:除[正文兼容](#正文兼容)、[身份归一](#请求头与身份)、模型映射及已配置的请求策略外, 请求 body 的未知字段和字段顺序保持不变。HTTP SSE 与 WebSocket 的上游业务事件除下述客户端错误兼容及响应头隔离外按原始字节转发, response ID 按 opaque 值处理而不假设 UUID 或固定长度;除客户端错误兼容与原生续写额度恢复外, OpenAI 上游错误 envelope 和允许下发的 opaque header 值也不由 canonical 观测结果重写。 @@ -1466,27 +1569,33 @@ API Key 账号使用以下独立凭据形态: "name": "团队上游", "base_url": "https://api.example.com/v1", "api_key": "", + "protocol": "responses", "transport": "http" } } ``` -`base_url` 是 API 前缀,追加 `responses`、`models`、`images/generations`、`images/edits` 或 `alpha/search`, -不会自动补 `/v1`;支持根路径和自定义前缀。 +`protocol` 可省略(默认 `responses`)或设为 `messages`,两者都使用 `provider: "openai"`。 +`base_url` 是 API 前缀,不会自动补 `/v1`,支持根路径和自定义前缀。 +Responses 上游追加 `responses`、`models`、`images/generations`、`images/edits` 或 `alpha/search`; +Messages 上游追加 `messages`、`messages/count_tokens` 或 `models`。官方 Anthropic 的前缀为 `https://api.anthropic.com/v1` + 地址支持 HTTP 和 HTTPS,包括内网 IP 与容器名,拒绝 URL 中的认证信息、查询串和 fragment。 HTTP 会明文传输 API Key 和请求内容,仅用于可信网络。 -`transport` 可省略(默认 `http`)或设为 `prefer_websocket`。API Key 使用 Bearer 认证与普通 JSON, -不携带 OAuth Cookie 或 ChatGPT 身份。上游模型列表使用标准 `/models` 格式,按账号和凭据版本隔离; +`transport` 缺省为 `http`,Responses 可设为 `prefer_websocket`,Messages 只接受 `http`。 +Responses 使用 Bearer 认证,Messages 使用 `x-api-key` 与 `anthropic-version`,都不携带 OAuth Cookie 或 ChatGPT 身份。 +上游模型列表从 API 前缀下的 `/models` 读取,按账号和凭据版本隔离; 目录用于模型发现,不作为能力白名单,未列出的模型仍交由上游判断。 API Key 每次导入创建独立账号;更新已有账号使用 `/api/admin/accounts/update` 的 `connection` 字段。 -导出会显式包含密钥,沿用敏感导出的确认合同 +导出保留协议和传输设置,并显式包含密钥,沿用敏感导出的确认合同 sub2api 的 `platform=openai`、`type=apikey` 使用 `credentials.base_url` / `credentials.api_key`; 导入时按其端点规则将服务根、版本前缀或完整 `/responses` 地址转换为 API 前缀,缺省地址为官方 `/v1`。 非空模型映射、请求头覆盖、其他协议和启用的 `extra.openai_*` 设置尚未适配,返回输入错误,需先移除并在本项目重新配置 -API Key 账号与 OAuth 共用现有 Responses、Images 和 standalone Search 请求与响应链路, +Responses API Key 账号与 OAuth 共用 Responses、Images 和 standalone Search 请求与响应链路, 包括 Responses Lite 和原生压缩协议的透传,实际支持情况由上游决定;不提供独立 compact 路由。 +Messages API Key 账号支持生成与输入计数,通过协议转换承接 Responses 和 Chat 入站;不提供 Images、standalone Search、Live 或 Responses 原生续接能力。 模型目录、连接测试和本地用量统计可用;OAuth 刷新/重新授权、ChatGPT 额度、个人资料、订阅和重置卡不适用。 客户端的 `image_generation` 和 `X-OpenAI-Actor-Authorization` 声明不改变账号的实际能力。 未识别为 CPR 互联的 API Key 账号,其列表和详情 `usage` 汇总账号创建后仍保留的本地请求记录, @@ -1531,7 +1640,7 @@ OpenAI 的 CPR 导出保持 OAuth 账号的既有 token 与过期时间字段。 导入条目未提供 `modelAccess` 且 `settings` 未指定该字段时,新账号默认 `all`,已有账号保留原值;凭据刷新、重新授权和目录刷新均保留政策。 sub2api 的 `credentials.model_mapping` 不转换为本项目的账号模型限制 -编辑 Codex API Key 账号时,在 `POST /api/admin/accounts/update` 的账号设置中附带 `connection`: +编辑 API Key 账号时,在 `POST /api/admin/accounts/update` 的账号设置中附带 `connection`: ```json { @@ -1542,18 +1651,21 @@ sub2api 的 `credentials.model_mapping` 不转换为本项目的账号模型限 "groupIds": [], "connection": { "baseUrl": "https://api.example.com/v1", + "protocol": "responses", "transport": "http", "apiKey": "..." } } ``` -`connection.transport` 支持 `http`、`prefer_websocket`。省略 `connection` 时只更新账号设置; +`connection.protocol` 支持 `responses`、`messages`,省略时保留当前协议。 +`connection.transport` 支持 `http`、`prefer_websocket`,Messages 只接受 `http`;切换协议时须同时提交合法的传输组合。 +省略 `connection` 时只更新账号设置; 省略 `connection.apiKey` 保留当前密钥,空字符串无效。 -Codex OAuth 账号只接受 `connection: { transport }`,不接受 `baseUrl`、`apiKey` 或 OAuth token。 +Codex OAuth 账号只接受 `connection: { transport }`,不接受 `protocol`、`baseUrl`、`apiKey` 或 OAuth token。 连接设置不能修改账号 ID、Provider 或认证类型,也不接受通用凭据文档。 凭据与设置在同一事务中保存,任一校验或持久化失败均不落库。 -`GET /api/admin/accounts/detail` 对 API Key 账号额外返回 `credentialConfiguration: { base_url, transport }`; +`GET /api/admin/accounts/detail` 对 API Key 账号额外返回 `credentialConfiguration: { base_url, protocol, transport }`; OAuth 账号返回 `credentialConfiguration: { transport }`。响应不回显密钥或 token;不适用的账号省略该字段。 更新会推进凭据 revision 并失效目录与连接;旧版本会话不可静默续接到新上游 @@ -1815,6 +1927,7 @@ GET 和 POST 均返回 `enabled`、`leadMinutes`、`nextDiscoveryAtDisplay`、`n - 关闭:将 `priority`(含 `fast` 别名)改为显式 `default`,继续处理请求 策略只作用于 OpenAI Responses 的顶层 `service_tier`,不改变 `flex`、`ultrafast` 等其他显式档位、嵌套字段或其他 Provider。 +选定 Codex OAuth 后,出站兼容层按其合同省略 `auto/default`,默认档位仍按标准价格计费;Responses API Key 保留这两个值。 宿主策略在 request 中间件之后应用,形成 attempt 输入基线;attempt 中间件继续改写档位时,以改写后的实际发送值为准。 HTTP 和每个 WebSocket `response.create` 均使用请求开始时的分组策略,同一请求重试保持该策略; HTTP 请求头及新建 WS 的握手提示按当时的最终出站档位构造;复用 WS 时不重发握手头, diff --git a/docs/architecture.md b/docs/architecture.md index f3d5be0e5..ce2870003 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -15,14 +15,16 @@ Codex Proxy RS 是单进程、单副本运行的多 Provider AI 网关,同时提供: -- 面向客户端的 OpenAI Responses、Chat Completions、Images、standalone Search 和模型目录协议 +- 面向客户端的 Responses、Chat Completions、Anthropic Messages、Images、standalone Search 和模型目录协议 - 面向管理员的 `/api/admin/*` 控制面和 Vue 管理端 - 面向 Key 持有者的 `/api/key-usage/*` 用量与客户端配置接口、独立 `/key-usage` 页面,以及复用数据面认证的 `/v1/usage` 额度查询 - 固定的 OpenAI 与 xAI 两个编译期 Provider,以及插件提供的认证、中间件和管理扩展 - PostgreSQL 持久化、Redis 协调状态以及 S3/R2 数据库备份 -Chat Completions 通过 API 协议转换复用 Responses 执行链。系统不存在 Provider Instance 层,也不支持 -通过复制应用容器进行多副本扩容。Client Key 限定账号分组,而不是绑定某个 Provider;一次请求的 +Responses、Chat Completions 和 Messages 共用生成执行链,API Key 账号可选择 Responses 或 Messages 上游协议, +仍由 OpenAI Provider 管理。Chat 在 API 层转为 Responses,Provider 在选定账号后处理 Messages 与 Responses 的转换。 +系统不存在 Provider Instance 层,也不支持通过复制应用容器进行多副本扩容。 +Client Key 限定账号分组,而不是绑定某个 Provider;一次请求的 Provider 候选由账号范围、模型能力和运行时健康共同决定 ## 2. 运行拓扑 @@ -59,7 +61,7 @@ flowchart TB | --- | --- | | `backend/apps/gateway` | 读取顶层配置、连接 Bundle、注册 Provider 与 Worker | | `backend/apps/plugin-cli`(包名 `codex-proxy-plugin-cli`) | `cpr-plugin package` 校验作者清单并生成平台元数据、资源摘要与归档;内部仅依赖 SDK,不参与网关运行时加载 | -| `gateway-protocol` | 跨层共享的 OpenAI 与 CPR 互联线协议、SSE 编解码与无业务 owner 的解析事实,不依赖其他 workspace crate | +| `gateway-protocol` | 跨层共享的 Responses、Messages 与 CPR 互联线协议、纯协议转换、SSE 编解码与无业务 owner 的解析事实,不依赖其他 workspace crate | | `gateway-core` | operation、canonical event、请求快照、路由、admission、attempt 协调、交付边界和计量 | | `gateway-admin` | 管理领域、Key 用量、互联共享查询与上游同步、Provider/Store 端口、审计语义、备份与历史保留策略 | | `gateway-api` | HTTP/WS/SSE 解码与交付、Admin 与 Key 用量 wire、静态 Web UI;不直接访问 Store 或具体 Provider | @@ -67,7 +69,7 @@ flowchart TB | `gateway-host` | 配置加载、日志、HTTP 生命周期、Worker 监督与历史保留任务、系统更新、互联 HTTP 与外部价格源适配 | | `gateway-plugin/sdk`(包名 `gateway-plugin-sdk`) | 公开插件清单与线协议,独立于网关领域;异步收发通过可选 `io` feature 提供 | | `gateway-plugin/runtime`(包名 `gateway-plugin-runtime`) | 插件包校验、能力适配、双向 RPC 与发布集合;通过 Host 管理子进程和受管 HTTP | -| `providers/openai` | OpenAI OAuth、账号选择、目录、额度、Responses/Images/Search transport | +| `providers/openai` | OpenAI OAuth、API Key 凭据、账号选择、目录、额度和 Responses/Messages/Images/Search transport | | `providers/xai` | xAI OAuth session、账号选择、目录、额度和 Grok/Responses 转换 | | `frontend` | Vue 管理端与 Key 用量页,仅通过各自身份允许的控制面 API 访问状态 | | 独立仓库 `codex-proxy-ui` | 管理端与插件页面共用的 Vue 基础组件、纯主题算法和样式,不依赖宿主业务状态、路由或 API | @@ -445,7 +447,7 @@ Client Key 鉴权完成后,API adapter 从有界请求头识别客户端,Cor SSE 注释不构成业务输出或上游已发送的证明,也不改变重放资格 Core 单独维护重放屏障,仅 Provider 明确标记的可替换前导保留重试资格,仍检查错误分类、续接归属、发送状态、副作用及预算 - API 在最终错误编码出口投影客户端恢复信号;该投影不修改 Provider 上游事实,也不改变 Core 的 - 重试与提交边界。具体错误合同见 [数据面接口](api.md#3-openai-数据面与模型目录) + 重试与提交边界。具体错误合同见 [数据面接口](api.md#3-模型数据面与模型目录) - Provider 为有界同账号退避显式选择耗尽动作:允许换号,或返回客户端错误;Core 在既有安全重放边界内执行,按账号维护请求内预算 该退避消耗总路由预算,与 WS 传输恢复、OAuth 刷新及账号额度冷却分开;具体次数、退避与 `Retry-After` 规则见[容量拒绝与重试](api.md#容量拒绝与重试) - `RetryThenReturnError` 的终态失败按 Client Key、逻辑线程与轮次写入 Redis,后续同轮次请求命中时跳过该策略的退避重试,直接交回错误;其他恢复策略不受影响 @@ -465,15 +467,17 @@ Client Key 鉴权完成后,API adapter 从有界请求头识别客户端,Cor - 跨 Provider 只在账号范围和能力都允许,且请求尚未到达上游或已被证明可安全重放时发生 - 可恢复观测写入失败不能替换已经确定的客户端协议结果 -Responses 按模型目录编译候选;全局模型映射是精确映射,未命中时模型名原样交给候选 Provider。 -Chat Completions 由 API 将入站消息规范化为 Responses 正文,进入共用 Generate 执行链; -request 中间件回程经过 Responses 协议复核后,再由 API 投影成 Chat JSON 或 SSE。 -HTTP 中间件位于转换外侧,request 与 attempt 中间件处理 Responses,实际 endpoint 始终为 `/v1/chat/completions`。 -Chat 复用既有提交、取消与终结生命周期;Core 继续独占路由、重试、交付事实与结算, -Provider 继续独占上游身份、字段兼容、隐私策略及账号隔离,Chat 层只负责协议映射。 -转换只拥有协议结构:同语义字段交给 Provider 与上游,无对应语义的可选控制项可降级忽略; -丢失用户输入、客户端动作或无法表达响应的转换须明确失败,不补造结果。 -字段合同见 [Chat Completions](api.md#chat-completions-请求),插件视图见 [SDK 请求中间件](../backend/crates/gateway-plugin/sdk/docs/capabilities.md#模型请求与-attempt) +生成请求按模型目录编译候选;全局模型映射是精确映射,未命中时模型名原样交给候选 Provider。 +Responses 与 Messages 保留各自的协议正文进入共用 Generate 执行链;Chat 在 API 层规范化为 Responses, +回程再投影成 Chat JSON 或 SSE。HTTP 中间件位于入口转换外侧,request 与 attempt 中间件处理该逻辑协议正文, +实际 endpoint 保留客户端路由。Provider 选定账号后按账号协议转换出站,`outbound` 处理实际发送的上游请求 + +三个入口共用提交、取消与终结生命周期;Core 独占路由、重试、交付事实与结算, +Provider 独占上游身份、字段适配、隐私策略及账号隔离。`gateway-protocol` 只拥有结构转换和单次响应的流状态, +响应转换器只保留客户端模型名及还原工具调用所需的名称映射,不持有输入历史、账号、连接或调度状态。 +Messages 与 Responses 的映射、忽略和降级规则参考 CPA, +同语义字段交给目标上游校验;结构解码或必要流状态失败按协议错误终结,不补造成功结果。 +字段合同见 [Chat Completions](api.md#chat-completions-请求)和 [Messages](api.md#messages-请求),插件视图见 [SDK 请求中间件](../backend/crates/gateway-plugin/sdk/docs/capabilities.md#模型请求与-attempt) Images 与 standalone Search 是 OpenAI Provider 自有端点:两者都不参与文本模型映射,只在 Client Key 的账号范围确实包含 Codex 账号时生成单一 OpenAI 候选。Images 的图片模型由 Provider 从正文旁路 @@ -512,18 +516,20 @@ OpenAI Provider 统一处理 Responses 的账号归属与 turn state 隔离,HT 全量请求缺少本地归属记录时保留客户端回传的路由 token,明确换号或可信续接状态不属于同一轮时清除; turn state 不参与选号,也不授权其他账号状态或 response ID 的复用 -OpenAI 的 OAuth 与 API Key 共用现有账号和事务。API Key 的 Base URL、密钥和传输策略属于 Provider 凭据 JSON, +OpenAI 的 OAuth 与 API Key 共用现有账号和事务。API Key 的 Base URL、密钥、上游协议和传输策略属于 Provider 凭据 JSON, 随 credential revision 更新;普通详情只投影非敏感连接设置。API Key 客户端目录按账号、凭据版本和客户端版本隔离, 标准 `data` 模型列表通过通用画像输出,完整 Codex `models` 目录保留原生对象。通用账号层按 Provider 提交的 credential state 调度,不以是否存在上游用户 ID 推断可用性;OAuth 未完成身份投影时由 Provider 保持 `unknown`。 状态恢复和未补齐身份的凭据轮换保留 `unknown`。 -API Key 默认 HTTP/SSE,可选 WS 优先;选号先验证传输资格,WS pool 与 continuation 按凭据版本隔离。 -OAuth 与 API Key 共用业务请求、响应和能力透传链路,差异限定在上游地址、认证、传输配置及明确的上游请求合同适配。 +API Key 默认使用 Responses 协议和 HTTP/SSE,Responses 可选 WS 优先,Messages 只支持 HTTP。 +协议和传输资格在选号阶段验证,WS pool 与 continuation 按凭据版本隔离。 +Responses API Key 与 OAuth 共用原生请求与响应链路;Messages API Key 使用独立 HTTP transport, +在同一 Provider 的账号租约内执行生成和输入计数,不进入 Images、Search、Live 或 Responses 原生续接路径。 OpenAI 模型目录用于发现与原生 Responses 账号资格筛选,OAuth 按套餐、API Key 按账号与凭据版本匹配目录。 目录与账号白名单的优先级见[路由与账号范围](#6-路由账号范围与-continuation) -- OpenAI 是透明边界。正文兼容、身份归一和显式请求策略之外的业务字段保留原始语义; - 业务响应按原始字节转发,客户端错误兼容与原生续写额度恢复按明确例外处理,见 [OpenAI 透传](api.md#openai-透传)。 +- Responses 同协议执行是透明边界。正文兼容、身份归一和显式请求策略之外的业务字段保留原始语义; + 同协议业务响应使用原始 wire,跨协议才调用转换器;客户端错误兼容与原生续写额度恢复按明确例外处理,见 [OpenAI 透传](api.md#openai-透传)。 `transport/correlation` 在出站副本上按本次安装身份统一映射关联标识。 Responses 的账号归属判断及换号头部清理由 Provider 统一执行,各传输消费同一出站请求。 原生安装身份由 OpenAI Provider 按 Key 种子、Key ID 与选中账号 ID 确定性派生,无需额外映射表;未配置种子时取自账号,与 UA 继承方式无关。模型目录缓存按生效身份隔离,Live 后续阶段使用引导时冻结的种子;插件的身份生成、持久化及关联字段改写通过既有中间件链路自行完成 @@ -534,7 +540,11 @@ OpenAI 模型目录用于发现与原生 Responses 账号资格筛选,OAuth 非流式 Responses 由 API 聚合 wire:终态省略或清空 `output` 时,使用同一响应的 `output_item.done` 按 `output_index` 还原完整输出;已有非空终态输出不改写。完成项缺失或冲突时在下游提交前拒绝, 不凭 canonical 增量补造内容,也不让 SSE/WS 转发额外保存整份输出 -- Responses、Images 与 standalone Search 的业务扩展头保留原始多值字节。API 负责剥离鉴权、账号身份和 HTTP 传输字段, +- Messages 上游只使用所选账号的 API Key 认证与 Anthropic 协议头,不继承 Codex OAuth 身份。 + Messages 原生 SSE 交付原始帧,canonical facts 旁路提取用量、终态和错误;跨协议转换状态由单次响应独占。 + 输入计数通过 CountTokens operation 复用准入、账号选择、租约与终结链,由 Provider 决定调用官方原生计数或本地 tokenizer。 + 本地估算不创建生成请求、不记录上游发送或伪造上游用量;精度与多模态边界见 [Messages 输入计数](api.md#messages-输入计数) +- Responses、Messages、Images 与 standalone Search 的业务扩展头保留原始多值字节。API 负责剥离鉴权、账号身份和 HTTP 传输字段, 并提取会话语义;`gateway-protocol` 共享 HTTP 传输与网关链路字段分类。客户端兼容规则集中在 `providers/openai/src/compat/`,与上游缺陷补偿统一管理:`headers.rs` 管理下游环境头和已提取语义的头部别名, `request.rs` 管理参数过滤、缺省值及请求形状适配;兼容基准为 Codex Core/Desktop 请求协议。 @@ -546,7 +556,7 @@ OpenAI 模型目录用于发现与原生 Responses 账号资格筛选,OAuth 长期协议适配与临时缺陷补偿按文件区分;临时补偿注明外部依据、适用范围和移除条件,直连验证修复后清理对应规则与合同场景。 `transport/headers.rs` 负责上游身份保护和官方头组装。 会话别名只规范化请求头,不清除正文身份字段;未知业务扩展与响应诊断头不受影响,字段见 - [Responses 合同](api.md#3-openai-数据面与模型目录) + [Responses 合同](api.md#3-模型数据面与模型目录) - Live 共用 OpenAI 的头部身份、下游环境和传输边界,业务扩展不使用固定白名单。 引导、sideband 与 hangup 由 Provider 在选定或加载钉住账号后统一处理出站关联标识; API 保留原始入站事实,Core 只传递头值字节和通话归属,具体合同见 [Codex Live 语音通话](api.md#codex-live-语音通话) @@ -635,8 +645,9 @@ client,OIDC 的 JWKS 缓存与单飞归属对应出口状态。自动刷新提 错误信息按用途分成三层,不能用同一个 `message` 同时承担协议、界面和诊断职责: -1. **数据面协议错误**:`/v1/*` 继续遵守 OpenAI/xAI wire 合同。可交付原始上游响应时保留其状态、headers、 - content type 和 body;原生续写额度恢复由 Provider 单独投影客户端响应,真实上游事实仍用于诊断和记账。 +1. **数据面协议错误**:`/v1/*` 遵守调用入口的 wire 合同,Messages 使用 Anthropic 错误封套与 SSE error 事件。 + 可交付原始上游响应时保留其状态、headers、content type 和 body;原生续写额度恢复由 Provider 单独投影客户端响应, + 真实上游事实仍用于诊断和记账。 本地 fallback 使用数据面稳定机器码与安全英文,不受管理端中文化影响 2. **控制面展示错误**:`/api/admin/*` 由 API 统一 HTTP 状态与数值业务码,由 Admin/API owner 提供安全中文 文案。extractor rejection、namespace 404 和 method 405 也使用同一 JSON 信封;任意 Store、Serde、 @@ -792,7 +803,7 @@ Continuation 受原请求的 Client Key、账号范围、Provider 和发送/交 完整历史。体积测量复用 WS 编码结构,Provider session state 仍只携带元数据,不保存 transcript - OpenAI 在有效输出交付前收到可安全重放的明确额度拒绝时,先隔离账号,再投影 `ClientReplayRequired`; 丢弃未交付的原错误帧,由客户端提交完整历史开启新链,不把原增量输入交给其他账号。 - 真实错误分类、状态码、发送状态和上游诊断保持不变,客户端合同见 [Responses API](api.md#3-openai-数据面与模型目录) + 真实错误分类、状态码、发送状态和上游诊断保持不变,客户端合同见 [Responses API](api.md#3-模型数据面与模型目录) - OpenAI 按 native → replay owner → replay any 推进,并保留官方 `previous_response_id` 语义; 已知为 connection-local 的原生续接进入重放阶段时,在选号前返回 `ClientReplayRequired`,不认领或迁移会话绑定。 正常 native 续接仍由连接池核对原连接及 response ID 是否可用 @@ -1170,7 +1181,7 @@ Store 按生命周期原子更新所属分组,保留其他阶段的事实; 进程退出后停止刷新,Worker 按过期租约收敛遗留的 running 记录;该观测续期失败不取消客户端执行 模型执行以 `model_requests.id` 标识,上游身份由 `upstream_request_id` 保存。 -API 输出模型执行与上游请求的关联信息,具体响应头规则见 [数据面接口](api.md#3-openai-数据面与模型目录)。 +API 输出模型执行与上游请求的关联信息,具体响应头规则见 [数据面接口](api.md#3-模型数据面与模型目录)。 入口 middleware 的 ID 用于入口日志,不作为模型请求的主键或检索映射。 失败终态及中间失败的上游请求 ID 优先取对应 `ProviderError`,缺失时再取该 attempt 的响应 observation、调用 metadata;最终失败的关联头不与 opening 身份混合 diff --git a/docs/development.md b/docs/development.md index 709086145..0013fbf25 100644 --- a/docs/development.md +++ b/docs/development.md @@ -65,6 +65,16 @@ pnpm --dir frontend dev 共享 UI 的命名与目录见[组件架构](../modules/ui/playground/guide/architecture.md) +Messages 与 Responses 的纯协议转换位于 `backend/crates/gateway-protocol/src/anthropic/`, +HTTP 入口位于 `backend/crates/gateway-api/src/openai/messages.rs`, +账号协议分派、HTTP 执行和计数位于 `backend/crates/providers/openai/src/provider/messages/`。 +模块职责见 [Provider 与协议边界](architecture.md#5-provider-与协议边界) + +联调协议时分别准备使用 `responses` 和 `messages` 的 API Key 账号,并通过账号分组与 Client Key 固定上游范围, +避免混合账号池使一次请求选中其他协议。对 Responses、Chat 和 Messages 三个入口分别检查 JSON 与 SSE, +再核对工具往返、取消、错误和输入计数;请求格式及六种组合见 [模型数据面](api.md#3-模型数据面与模型目录)。 +Messages 账号只配置 HTTP;本地计数估算不能替代上游计费核对 + ## 源码联调 宿主、组件库和官方插件保留独立仓库,通过 Git 子模块在同一目录开发: diff --git a/frontend/src/api/modules/accounts/management.ts b/frontend/src/api/modules/accounts/management.ts index 0199fa2d4..8923754e1 100644 --- a/frontend/src/api/modules/accounts/management.ts +++ b/frontend/src/api/modules/accounts/management.ts @@ -52,7 +52,7 @@ interface AccountListParams { } interface AccountUpdateParam { - connection?: { baseUrl?: string, transport: ApiKeyConfiguration['transport'], apiKey?: string } + connection?: { baseUrl?: string, protocol?: ApiKeyConfiguration['protocol'], transport: ApiKeyConfiguration['transport'], apiKey?: string } outboundProxyUrl?: string outboundProxyId?: string accountId: string @@ -94,6 +94,7 @@ interface AccountConcurrencyParams extends AccountIdParam { export interface ApiKeyConfiguration { base_url: string + protocol: 'responses' | 'messages' transport: 'http' | 'prefer_websocket' } diff --git a/frontend/src/i18n/locales/en/accounts.json b/frontend/src/i18n/locales/en/accounts.json index 0a7a3a182..72ffc79e3 100644 --- a/frontend/src/i18n/locales/en/accounts.json +++ b/frontend/src/i18n/locales/en/accounts.json @@ -128,14 +128,17 @@ "apiPrefix": "API prefix", "apiKeyPlaceholder": "Leave blank to keep the current key", "enterUpstreamKey": "Enter the upstream key", + "protocolLabel": "Upstream protocol", "transportLabel": "Transport", "webSocketHelp": "WS requires upstream support for Responses WebSocket", + "messagesTransportHelp": "Messages upstreams use HTTP/SSE", "nameRequired": "Enter an account name", "validation": { "urlLength": "Upstream API URL must not exceed 2,048 characters", "urlFormat": "Enter an HTTP or HTTPS URL without credentials, query parameters, or a fragment", "urlRequired": "Enter the full upstream API URL", "apiKeyFormat": "API key cannot contain spaces or control characters", + "protocolRequired": "Select an upstream protocol", "transportRequired": "Select a transport" }, "apiKeyRequired": "Enter an API key" @@ -339,7 +342,7 @@ "jsonDescription": "Paste or upload account JSON to import accounts or update matching credentials", "packageDescription": "Paste or upload a CPR account package to import accounts from multiple providers", "oauthDescription": "Import a {label} account through browser authorization", - "apiKeyDescription": "Connect an upstream service compatible with the OpenAI Responses API", + "apiKeyDescription": "Connect an upstream service using Responses or Messages", "pasteAccessTokenLineByLineIf": "Paste the Access token line by line. If the Refresh token is not included, it cannot be automatically renewed", "refreshTokenDescription": "Paste one refresh token per line, access tokens are obtained automatically during import", "accountSettings": "Account settings", diff --git a/frontend/src/i18n/locales/zh-Hans/accounts.json b/frontend/src/i18n/locales/zh-Hans/accounts.json index 0ddba1d12..765efc057 100644 --- a/frontend/src/i18n/locales/zh-Hans/accounts.json +++ b/frontend/src/i18n/locales/zh-Hans/accounts.json @@ -128,14 +128,17 @@ "apiPrefix": "API 前缀", "apiKeyPlaceholder": "留空保留当前密钥", "enterUpstreamKey": "输入上游密钥", + "protocolLabel": "上游协议", "transportLabel": "传输方式", "webSocketHelp": "WS 需要上游支持 Responses WebSocket", + "messagesTransportHelp": "Messages 上游使用 HTTP/SSE", "nameRequired": "请输入账号名称", "validation": { "urlLength": "上游 API 地址不能超过 2048 个字符", "urlFormat": "请输入不含认证、查询参数或片段的 HTTP 或 HTTPS 地址", "urlRequired": "请输入完整的上游 API 地址", "apiKeyFormat": "API密钥不能包含空格或控制字符", + "protocolRequired": "请选择上游协议", "transportRequired": "请选择传输方式" }, "apiKeyRequired": "请输入 API密钥" @@ -339,7 +342,7 @@ "jsonDescription": "粘贴或上传账号 JSON,匹配已有账号时更新凭据", "packageDescription": "粘贴或上传 CPR 账号包,一次导入多个平台账号", "oauthDescription": "通过浏览器授权导入 {label} 账号", - "apiKeyDescription": "接入 OpenAI Responses 兼容上游", + "apiKeyDescription": "接入 Responses 或 Messages 协议上游", "pasteAccessTokenLineByLineIf": "逐行粘贴 Access Token,未包含 Refresh Token 时无法自动续期", "refreshTokenDescription": "逐行粘贴 Refresh Token,导入时将自动换取 Access Token", "accountSettings": "账号设置", diff --git a/frontend/src/i18n/locales/zh-Hant/accounts.json b/frontend/src/i18n/locales/zh-Hant/accounts.json index d9502e8b9..88eca1600 100644 --- a/frontend/src/i18n/locales/zh-Hant/accounts.json +++ b/frontend/src/i18n/locales/zh-Hant/accounts.json @@ -128,14 +128,17 @@ "apiPrefix": "API 前綴", "apiKeyPlaceholder": "留空保留當前密鑰", "enterUpstreamKey": "輸入上游密鑰", + "protocolLabel": "上游協議", "transportLabel": "傳輸方式", "webSocketHelp": "WS 需要上游支持 Responses WebSocket", + "messagesTransportHelp": "Messages 上游使用 HTTP/SSE", "nameRequired": "請輸入賬號名稱", "validation": { "urlLength": "上游 API 地址不能超過 2048 個字符", "urlFormat": "請輸入不含認證、查詢參數或片段的 HTTP 或 HTTPS 地址", "urlRequired": "請輸入完整的上游 API 地址", "apiKeyFormat": "API密鑰不能包含空格或控制字符", + "protocolRequired": "請選擇上游協議", "transportRequired": "請選擇傳輸方式" }, "apiKeyRequired": "請輸入 API密鑰" @@ -339,7 +342,7 @@ "jsonDescription": "粘貼或上傳賬號 JSON,匹配已有賬號時更新憑據", "packageDescription": "粘貼或上傳 CPR 賬號包,一次導入多個平臺賬號", "oauthDescription": "通過瀏覽器授權導入 {label} 賬號", - "apiKeyDescription": "接入 OpenAI Responses 兼容上游", + "apiKeyDescription": "接入 Responses 或 Messages 協議上游", "pasteAccessTokenLineByLineIf": "逐行粘貼 Access Token,未包含 Refresh Token 時無法自動續期", "refreshTokenDescription": "逐行粘貼 Refresh Token,導入時將自動換取 Access Token", "accountSettings": "賬號設置", diff --git a/frontend/src/views/accounts/components/AccountApiKeyFields.vue b/frontend/src/views/accounts/components/AccountApiKeyFields.vue index a134baa78..b5dc67e49 100644 --- a/frontend/src/views/accounts/components/AccountApiKeyFields.vue +++ b/frontend/src/views/accounts/components/AccountApiKeyFields.vue @@ -3,6 +3,7 @@ import type { ApiKeyAccountForm } from '../utils/upstreamApiKey' import { ZFormItem, ZInput, ZSegmented } from '@codex-proxy/ui' +import { computed } from 'vue' import { useI18n } from 'vue-i18n' defineProps<{ disabled?: boolean, editing?: boolean }>() @@ -10,10 +11,26 @@ defineProps<{ disabled?: boolean, editing?: boolean }>() const { t } = useI18n({ useScope: 'global' }) const form = defineModel({ required: true }) -const transportOptions = [ - { label: 'SSE', value: 'http' }, - { label: 'WS', value: 'prefer_websocket' }, +const protocolOptions = [ + { label: 'Responses', value: 'responses' }, + { label: 'Messages', value: 'messages' }, ] +const transportOptions = computed(() => [ + { label: 'SSE', value: 'http' }, + { label: 'WS', value: 'prefer_websocket', disabled: form.value.protocol === 'messages' }, +]) + +function updateProtocol(protocol: string) { + if (protocol !== 'responses' && protocol !== 'messages') + return + form.value = { + ...form.value, + protocol, + transport: protocol === 'messages' + ? 'http' + : form.value.transport, + } +} diff --git a/frontend/src/views/accounts/components/AccountEditModal.vue b/frontend/src/views/accounts/components/AccountEditModal.vue index 6603322cf..94f93bce6 100644 --- a/frontend/src/views/accounts/components/AccountEditModal.vue +++ b/frontend/src/views/accounts/components/AccountEditModal.vue @@ -105,8 +105,6 @@ async function requestSave() { - - -