mirror of
https://github.com/zyycn/codex-proxy-rs.git
synced 2026-11-20 08:01:46 +00:00
* feat(plugins): select upstream adapters within account scopes * fix(plugins): defer adapter decisions until account selection Keep scoped adapters pending until an account is known so unavailable fallbacks cannot mask a healthy earlier match. Filter native xAI accounts when only an adapter can accept the request, preserving normal selection and cold-stream behavior. Cover fallback precedence and mixed-pool prewarm eligibility regressions. Co-authored-by: Codex <noreply@openai.com> --------- Co-authored-by: Zyy <zyycn@users.noreply.github.com> Co-authored-by: Codex <noreply@openai.com>
294 lines
9.3 KiB
Rust
294 lines
9.3 KiB
Rust
//! 插件集成测试使用的原生 Provider 与执行事件替身
|
|
|
|
use std::{collections::BTreeSet, sync::Arc};
|
|
|
|
use async_trait::async_trait;
|
|
use gateway_admin::{
|
|
model::{
|
|
observability::{CalculatedBillingBreakdown, DashboardWireProfile, ProviderBillingInput},
|
|
provider_credentials::{
|
|
AuthorizationStarted, CompleteAuthorization, PendingAuthorizationMutation,
|
|
PrepareCredentialImport, PrepareCredentialRefresh, PrepareCredentialRotation,
|
|
PreparedAuthorizationCommit, PreparedCredentialImport, PreparedCredentialRotation,
|
|
ProviderExport, ProviderExportCredentialInput, ProviderModels, ProviderQuota,
|
|
ProviderQuotaRequest,
|
|
},
|
|
},
|
|
ports::provider::{
|
|
ProviderAdmin, ProviderAdminError, ProviderAdminErrorKind, ProviderAdminRegistry,
|
|
},
|
|
};
|
|
use gateway_core::{
|
|
account::ProviderAccountId,
|
|
engine::{
|
|
AttemptContext,
|
|
provider::{
|
|
Provider, ProviderCallMetadata, ProviderRegistry, ProviderRequest, ProviderStream,
|
|
},
|
|
},
|
|
error::{ProviderError, ProviderErrorKind},
|
|
event::{GatewayEvent, ProtocolWireEvent, ProviderEvent, ResponseMeta},
|
|
operation::{Operation, OperationKind},
|
|
routing::{
|
|
ModelCapabilities, ProviderCatalogGeneration, ProviderKind, ProviderModelCapabilities,
|
|
UpstreamModelId,
|
|
},
|
|
upstream::{UpstreamSendState, UpstreamTransport},
|
|
};
|
|
use serde_json::json;
|
|
|
|
pub const MODEL: &str = "native-fixture-model";
|
|
|
|
struct NativeProvider(&'static str);
|
|
|
|
#[async_trait]
|
|
impl Provider for NativeProvider {
|
|
fn name(&self) -> &'static str {
|
|
self.0
|
|
}
|
|
|
|
fn catalog_generation(&self) -> ProviderCatalogGeneration {
|
|
ProviderCatalogGeneration::default()
|
|
}
|
|
|
|
async fn query_model_capabilities(
|
|
&self,
|
|
) -> Result<Vec<ProviderModelCapabilities>, ProviderError> {
|
|
if self.0 != "openai" {
|
|
return Ok(Vec::new());
|
|
}
|
|
Ok(vec![ProviderModelCapabilities::new(
|
|
UpstreamModelId::new(MODEL).unwrap(),
|
|
ModelCapabilities::new(BTreeSet::from([OperationKind::Generate]), None),
|
|
)])
|
|
}
|
|
|
|
async fn execute(
|
|
self: Arc<Self>,
|
|
request: ProviderRequest,
|
|
context: AttemptContext,
|
|
) -> Result<ProviderStream, ProviderError> {
|
|
let account = context.required_account().cloned().ok_or_else(|| {
|
|
ProviderError::new(ProviderErrorKind::Unavailable, UpstreamSendState::NotSent)
|
|
})?;
|
|
let candidate = request.candidate();
|
|
let model = candidate.upstream_model().cloned().ok_or_else(|| {
|
|
ProviderError::new(ProviderErrorKind::Unavailable, UpstreamSendState::NotSent)
|
|
})?;
|
|
let adapter =
|
|
context.upstream_adapter_for_account(candidate.provider(), &model, &account)?;
|
|
let metadata = ProviderCallMetadata::new(
|
|
candidate.provider().clone(),
|
|
model,
|
|
account,
|
|
UpstreamTransport::new(
|
|
adapter
|
|
.as_ref()
|
|
.map_or("http_sse", |adapter| adapter.transport()),
|
|
)
|
|
.unwrap(),
|
|
);
|
|
if let Some(adapter) = adapter {
|
|
let account = Arc::new(FixtureConnection(metadata.provider_account_id().clone()));
|
|
let events = adapter.execute(
|
|
gateway_core::engine::upstream_adapter::UpstreamAdapterInvocation {
|
|
operation: request.operation().clone(),
|
|
headers: vec![],
|
|
context,
|
|
metadata: metadata.clone(),
|
|
account,
|
|
},
|
|
);
|
|
return Ok(ProviderStream::new(metadata, events, ()));
|
|
}
|
|
let response = ResponseMeta::new("fixture-response", MODEL);
|
|
let event = |name: &str, fact| {
|
|
ProviderEvent::canonical_with_wire(
|
|
vec![fact],
|
|
ProtocolWireEvent::json(
|
|
"openai",
|
|
Some(name.to_owned()),
|
|
json!({"type":name,"response":{"id":"fixture-response","model":MODEL}}),
|
|
)
|
|
.unwrap(),
|
|
)
|
|
};
|
|
Ok(ProviderStream::new(
|
|
metadata,
|
|
Box::pin(futures::stream::iter([
|
|
Ok(event(
|
|
"response.created",
|
|
GatewayEvent::Started(response.clone()),
|
|
)),
|
|
Ok(event(
|
|
"response.completed",
|
|
GatewayEvent::Completed(response),
|
|
)),
|
|
])),
|
|
(),
|
|
))
|
|
}
|
|
}
|
|
|
|
// 仅测试 Core / Runtime / Store 组合;真实 Provider 的凭据解释由各自合同测试验证
|
|
struct FixtureConnection(ProviderAccountId);
|
|
|
|
impl gateway_core::engine::upstream_adapter::UpstreamAccountConnection for FixtureConnection {
|
|
fn account_id(&self) -> &ProviderAccountId {
|
|
&self.0
|
|
}
|
|
fn credential_revision(&self) -> gateway_core::account::CredentialRevision {
|
|
gateway_core::account::CredentialRevision::new(1).unwrap()
|
|
}
|
|
fn authentication_kind(&self) -> &str {
|
|
"oauth"
|
|
}
|
|
fn outbound_proxy(&self) -> Option<&gateway_core::account::OutboundProxy> {
|
|
None
|
|
}
|
|
fn authorization(
|
|
&self,
|
|
) -> Result<Vec<gateway_core::engine::middleware::MiddlewareHeader>, ProviderError> {
|
|
Ok(vec![
|
|
gateway_core::engine::middleware::MiddlewareHeader::new(
|
|
"authorization",
|
|
bytes::Bytes::from_static(b"Bearer fixture-native-token"),
|
|
),
|
|
])
|
|
}
|
|
fn calculate_cost(
|
|
&self,
|
|
_: Option<&str>,
|
|
_: &gateway_core::metering::Usage,
|
|
) -> Option<gateway_core::metering::CalculatedCost> {
|
|
gateway_core::metering::CalculatedCost::from_usd_ticks(123).ok()
|
|
}
|
|
fn record_failure(
|
|
&self,
|
|
error: ProviderError,
|
|
) -> futures::future::BoxFuture<'_, ProviderError> {
|
|
Box::pin(async move { error })
|
|
}
|
|
}
|
|
|
|
pub fn provider_registry() -> ProviderRegistry {
|
|
ProviderRegistry::new([
|
|
Arc::new(NativeProvider("openai")) as Arc<dyn Provider>,
|
|
Arc::new(NativeProvider("xai")) as Arc<dyn Provider>,
|
|
])
|
|
.unwrap()
|
|
}
|
|
|
|
struct NativeAdmin(ProviderKind);
|
|
|
|
impl NativeAdmin {
|
|
fn unsupported() -> ProviderAdminError {
|
|
ProviderAdminError::new(ProviderAdminErrorKind::Unsupported)
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl ProviderAdmin for NativeAdmin {
|
|
fn evaluate_usage_pricing(
|
|
&self,
|
|
_: &gateway_admin::ports::provider::ProviderUsagePricingInput,
|
|
_: Option<&gateway_core::metering::ModelPriceOverride>,
|
|
) -> Result<Option<gateway_core::metering::CalculatedCostBreakdown>, ProviderAdminError> {
|
|
use gateway_core::metering::*;
|
|
let zero = Money::new(Decimal::ZERO, CurrencyCode::new("USD").unwrap());
|
|
let total = Money::new("1.25".parse().unwrap(), CurrencyCode::new("USD").unwrap());
|
|
Ok(Some(CalculatedCostBreakdown::new(
|
|
CalculatedCostAmounts::new(total, zero, zero, zero, total, total),
|
|
CalculatedCostRates::new(total, zero, zero, zero),
|
|
None,
|
|
100,
|
|
)))
|
|
}
|
|
|
|
fn provider_kind(&self) -> &ProviderKind {
|
|
&self.0
|
|
}
|
|
|
|
async fn account_unavailable(&self, _: &ProviderAccountId) {}
|
|
|
|
async fn connection_test_operation(
|
|
&self,
|
|
_: &UpstreamModelId,
|
|
_: &str,
|
|
) -> Result<Operation, ProviderAdminError> {
|
|
Err(Self::unsupported())
|
|
}
|
|
|
|
fn dashboard_wire_profile(&self) -> Option<DashboardWireProfile> {
|
|
None
|
|
}
|
|
|
|
fn calculated_billing(
|
|
&self,
|
|
_: &ProviderBillingInput,
|
|
) -> Result<Option<CalculatedBillingBreakdown>, ProviderAdminError> {
|
|
Ok(None)
|
|
}
|
|
|
|
async fn prepare_import(
|
|
&self,
|
|
_: PrepareCredentialImport,
|
|
) -> Result<PreparedCredentialImport, ProviderAdminError> {
|
|
Err(Self::unsupported())
|
|
}
|
|
|
|
async fn start_authorization(
|
|
&self,
|
|
_: PendingAuthorizationMutation,
|
|
) -> Result<AuthorizationStarted, ProviderAdminError> {
|
|
Err(Self::unsupported())
|
|
}
|
|
|
|
async fn complete_authorization(
|
|
&self,
|
|
_: CompleteAuthorization,
|
|
) -> Result<PreparedAuthorizationCommit, ProviderAdminError> {
|
|
Err(Self::unsupported())
|
|
}
|
|
|
|
async fn prepare_rotation(
|
|
&self,
|
|
_: PrepareCredentialRotation,
|
|
) -> Result<PreparedCredentialRotation, ProviderAdminError> {
|
|
Err(Self::unsupported())
|
|
}
|
|
|
|
async fn prepare_refresh(
|
|
&self,
|
|
_: PrepareCredentialRefresh,
|
|
) -> Result<PreparedCredentialRotation, ProviderAdminError> {
|
|
Err(Self::unsupported())
|
|
}
|
|
|
|
async fn quota(&self, _: ProviderQuotaRequest) -> Result<ProviderQuota, ProviderAdminError> {
|
|
Err(Self::unsupported())
|
|
}
|
|
|
|
async fn models(
|
|
&self,
|
|
_: &ProviderAccountId,
|
|
_: bool,
|
|
) -> Result<ProviderModels, ProviderAdminError> {
|
|
Err(Self::unsupported())
|
|
}
|
|
|
|
async fn export_credentials(
|
|
&self,
|
|
_: Vec<ProviderExportCredentialInput>,
|
|
) -> Result<ProviderExport, ProviderAdminError> {
|
|
Err(Self::unsupported())
|
|
}
|
|
}
|
|
|
|
pub fn admin_registry() -> ProviderAdminRegistry {
|
|
ProviderAdminRegistry::new(["openai", "xai"].map(|name| {
|
|
Arc::new(NativeAdmin(ProviderKind::new(name).unwrap())) as Arc<dyn ProviderAdmin>
|
|
}))
|
|
.unwrap()
|
|
}
|