Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.
Rust ai-agentsai-gatewayclaude-codecodexcoding-agentcost-optimizationdeepseekllm-gatewayllm-routerlocal-firstmodel-routingrusttask-routingtauri
//! Trusted synthesis for catalog-registered model checks and same-source edit fencing.
use super::{LocalControlAdapter, map_port};
use hiroute_application::control::ComputeManagementControlError;
use hiroute_application_api::{
ComputeCandidateProducerV2, ComputeCandidateTargetV2, ComputeCatalogProvenanceViewV1,
ComputeModelMembershipV2, RegisteredModelConnectionCheckRequestV1,
};
use hiroute_domain::{
AuthenticationKind, CanonicalDigest, ComputeManagementProvenanceV2,
ComputeManagementRepositoryPort, ComputeManagementSourceV2, ConnectionOrigin,
ProtocolEndpointV1, ResolvedConnectionOptionV1,
};
use hiroute_integrations::{
ModelConnectionBaseKindV1, ModelConnectionTargetInputV1, NativeCandidateFactBasisV1,
NativeCandidateFactValueV1, NativeConnectionProvenanceInputV1, NativeConnectionQualificationV1,
NativeModelCapabilityDeclarationV1, NativeModelConnectionDraftV1, NativeModelDeclarationV1,
normalize_model_connection_target,
};
impl LocalControlAdapter {
pub(super) fn trusted_registered_draft(
&self,
request: &RegisteredModelConnectionCheckRequestV1,
) -> Result<NativeModelConnectionDraftV1, ComputeManagementControlError> {
let source = if let (Some(source_id), Some(expected_revision)) = (
request.existing_source_id.as_deref(),
request.expected_source_revision,
) {
let source = self
.stores_lock()
.map_err(|_| ComputeManagementControlError::Unavailable)?
.control()
.compute_management_source(source_id)
.map_err(map_port)?
.ok_or(ComputeManagementControlError::NotFound)?;
source
.validate()
.map_err(|_| ComputeManagementControlError::Corrupt)?;
if source.revision != expected_revision {
return Err(ComputeManagementControlError::Conflict);
}
Some(source)
} else {
None
};
self.trusted_registered_draft_for_source(request, source.as_ref())
}
pub(super) fn trusted_registered_draft_for_saved_source(
&self,
request: &RegisteredModelConnectionCheckRequestV1,
source: &ComputeManagementSourceV2,
) -> Result<NativeModelConnectionDraftV1, ComputeManagementControlError> {
self.trusted_registered_draft_for_source(request, Some(source))
}
fn trusted_registered_draft_for_source(
&self,
request: &RegisteredModelConnectionCheckRequestV1,
source: Option<&ComputeManagementSourceV2>,
) -> Result<NativeModelConnectionDraftV1, ComputeManagementControlError> {
let catalog = self
.current_catalog()
.ok_or(ComputeManagementControlError::Unavailable)?;
let provenance = catalog
.compute_catalog_provenance()
.map_err(|_| ComputeManagementControlError::Corrupt)?;
let public = ComputeCatalogProvenanceViewV1 {
product_release: provenance.product_release.clone(),
catalog_binding_id: provenance.catalog_binding_id.clone(),
release_sequence: provenance.release_sequence,
connector_registry_digest: provenance.connector_registry_digest.clone(),
model_data_digest: provenance.model_data_digest.clone(),
cross_reference_digest: provenance.cross_reference_digest.clone(),
};
if public != request.expected_catalog {
return Err(ComputeManagementControlError::RegisteredCatalogChanged);
}
let resolved = catalog
.resolve_connection_option(&request.connection_option_id)
.map_err(|_| ComputeManagementControlError::RegisteredOptionUnavailable)?;
if resolved.option.origin == ConnectionOrigin::AgentSubscription
|| resolved.connector.runtime_kind
!= hiroute_domain::ConnectorRuntimeKind::BuiltinNative
|| resolved.connector.authentication != AuthenticationKind::ProviderApiKey
{
return Err(ComputeManagementControlError::RegisteredOptionUnavailable);
}
let endpoint = select_registered_endpoint(&resolved, source)?;
let inventory_path = endpoint.inventory_path.clone();
let authentication = endpoint
.authentication_semantics
.clone()
.ok_or(ComputeManagementControlError::RegisteredOptionUnavailable)?;
let additional_native_endpoints = if let Some(source) = source {
if !super::registered_source_matches_current_option(source, &resolved) {
return Err(ComputeManagementControlError::RegisteredSourceMismatch);
}
source.additional_native_endpoints.clone()
} else {
registered_additional_endpoints(&resolved, endpoint)?
};
let model_data = catalog.model_data();
let native_reasoning = catalog.native_reasoning();
let mut models = model_data
.model_endpoint_capabilities
.iter()
.filter(|capability| {
capability.endpoint_profile_id == resolved.endpoint_profile.endpoint_profile_id
&& capability.endpoint_profile_revision == resolved.endpoint_profile.revision
&& capability.protocol_endpoint_id == endpoint.protocol_endpoint_id
&& capability.upstream_protocol == endpoint.protocol
&& capability.connector_id == resolved.connector.connector_id
&& capability.connector_revision == resolved.connector.revision
})
.map(|capability| {
let model = model_data
.model(&capability.model_configuration_id)
.ok_or(ComputeManagementControlError::Corrupt)?;
let reasoning = native_reasoning
.iter()
.find(|value| value.model_configuration_id == capability.model_configuration_id)
.ok_or(ComputeManagementControlError::Corrupt)?;
Ok(NativeModelDeclarationV1 {
upstream_model_id: capability.upstream_model_id.clone(),
display_name: model.display_name.clone(),
catalog_configuration_id: Some(model.model_configuration_id.clone()),
membership: ComputeModelMembershipV2::Catalog,
capabilities: capability_declaration(&catalog, capability, model, reasoning),
})
})
.collect::<Result<Vec<_>, ComputeManagementControlError>>()?;
for declaration in &request.models {
if declaration.catalog_configuration_id.is_some()
|| declaration.membership != ComputeModelMembershipV2::UserDeclared
{
return Err(ComputeManagementControlError::Invalid);
}
// Exact built-in models retain server-owned facts. Additional IDs carry only
// source-local declarations and can never inherit prices or free qualification.
if !models
.iter()
.any(|model| model.upstream_model_id == declaration.upstream_model_id)
{
models.push(super::user_model(declaration.clone()));
}
}
models.sort_by(|left, right| left.upstream_model_id.cmp(&right.upstream_model_id));
Ok(NativeModelConnectionDraftV1 {
display_template_id: None,
inference_model_id: request.inference_model_id.clone(),
candidate_ref: request.candidate_ref.clone(),
lineage_ref: request.lineage_ref.clone(),
trusted_lineage_digest: None,
display_name: request
.display_name
.clone()
.unwrap_or_else(|| resolved.option.display_name.clone()),
existing_source_id: request.existing_source_id.clone(),
edit_revision: request.edit_revision,
check_id: request.check_id.clone(),
base_url: endpoint.base_url.clone(),
base_kind: ModelConnectionBaseKindV1::ApiRoot,
request_path_override: Some(endpoint.request_path.clone()),
inventory_path_override: inventory_path,
protocol: endpoint.protocol,
protocol_profile_id: endpoint.adapter_ref.clone(),
protocol_profile_revision: endpoint.adapter_revision,
protocol_header_semantics: super::registered_endpoint_header_semantics(endpoint),
authentication,
additional_native_endpoints,
provenance: NativeConnectionProvenanceInputV1::Registered {
connection_option_id: request.connection_option_id.clone(),
registry_version: catalog.registry().registry_version.clone(),
catalog_digest: provenance.cross_reference_digest,
},
qualification: NativeConnectionQualificationV1 {
free_access: None,
evidence_ref: None,
},
runtime_fallback_denied_model_ids: super::runtime_fallback_denied_model_ids(Some(
&catalog,
)),
models,
})
}
pub(super) fn validate_registered_source_edit(
&self,
request: &RegisteredModelConnectionCheckRequestV1,
draft: &NativeModelConnectionDraftV1,
) -> Result<(), ComputeManagementControlError> {
let (Some(source_id), Some(expected_revision)) = (
request.existing_source_id.as_deref(),
request.expected_source_revision,
) else {
return Ok(());
};
let source = self
.stores_lock()
.map_err(|_| ComputeManagementControlError::Unavailable)?
.control()
.compute_management_source(source_id)
.map_err(map_port)?
.ok_or(ComputeManagementControlError::NotFound)?;
if source.revision != expected_revision {
return Err(ComputeManagementControlError::Conflict);
}
self.validate_registered_source_identity(&source, draft)?;
let NativeConnectionProvenanceInputV1::Registered {
connection_option_id,
..
} = &draft.provenance
else {
return Err(ComputeManagementControlError::Corrupt);
};
let stable_provenance = serde_json::json!({
"kind": "registered",
"connection_option_id": connection_option_id,
});
let lineage = CanonicalDigest::of(&(
"hiroute.compute-management-lineage/v3",
ComputeCandidateProducerV2::Native,
&draft.lineage_ref,
stable_provenance,
))
.map_err(|_| ComputeManagementControlError::Corrupt)?;
if source.lineage_digest != lineage {
return Err(ComputeManagementControlError::RegisteredSourceMismatch);
}
Ok(())
}
pub(super) fn validate_registered_source_identity(
&self,
source: &hiroute_domain::ComputeManagementSourceV2,
draft: &NativeModelConnectionDraftV1,
) -> Result<ComputeCandidateTargetV2, ComputeManagementControlError> {
let NativeConnectionProvenanceInputV1::Registered {
connection_option_id,
..
} = &draft.provenance
else {
return Err(ComputeManagementControlError::Corrupt);
};
if !matches!(
&source.provenance,
ComputeManagementProvenanceV2::Registered {
connection_option_id: stored_option,
..
} if stored_option == connection_option_id
) {
return Err(ComputeManagementControlError::RegisteredSourceMismatch);
}
let target = normalize_model_connection_target(ModelConnectionTargetInputV1 {
base_url: &draft.base_url,
base_kind: draft.base_kind,
protocol: draft.protocol,
request_path_override: draft.request_path_override.as_deref(),
inventory_path_override: draft.inventory_path_override.as_deref(),
protocol_profile_id: &draft.protocol_profile_id,
protocol_profile_revision: draft.protocol_profile_revision,
protocol_header_semantics: &draft.protocol_header_semantics,
authentication: &draft.authentication,
})
.map_err(|_| ComputeManagementControlError::Corrupt)?;
let expected_target = &target.candidate_target;
if source.target.scheme != expected_target.scheme
|| source.target.authority != expected_target.authority
|| source.target.port != expected_target.port
|| source.target.request_path != expected_target.request_path
|| source.target.upstream_protocol != expected_target.upstream_protocol
|| source.target.protocol_profile_id != expected_target.protocol_profile_id
|| source.target.protocol_profile_revision != expected_target.protocol_profile_revision
|| source.authentication != draft.authentication
|| source.additional_native_endpoints != draft.additional_native_endpoints
|| source.native_recheck.as_ref()
!= Some(&hiroute_domain::ComputeNativeRecheckDescriptorV2 {
display_template_id: None,
inventory_path: target.inventory_path.clone(),
protocol_header_semantics: draft.protocol_header_semantics.clone(),
})
{
return Err(ComputeManagementControlError::RegisteredSourceMismatch);
}
Ok(expected_target.clone())
}
}
pub(super) fn registered_additional_endpoints(
resolved: &ResolvedConnectionOptionV1,
primary: &ProtocolEndpointV1,
) -> Result<Vec<hiroute_domain::ComputeNativeEndpointV3>, ComputeManagementControlError> {
let mut endpoints = resolved
.endpoint_profile
.protocol_endpoints
.iter()
.filter(|other| other.protocol != primary.protocol)
.collect::<Vec<_>>();
endpoints.sort_by_key(|other| other.stable_preference);
endpoints
.into_iter()
.map(|other| {
let authentication = other
.authentication_semantics
.clone()
.ok_or(ComputeManagementControlError::RegisteredOptionUnavailable)?;
let normalized = normalize_model_connection_target(ModelConnectionTargetInputV1 {
base_url: &other.base_url,
base_kind: ModelConnectionBaseKindV1::ApiRoot,
protocol: other.protocol,
request_path_override: Some(&other.request_path),
inventory_path_override: other.inventory_path.as_deref(),
protocol_profile_id: &other.adapter_ref,
protocol_profile_revision: other.adapter_revision,
protocol_header_semantics: &super::registered_endpoint_header_semantics(other),
authentication: &authentication,
})
.map_err(|_| ComputeManagementControlError::RegisteredOptionUnavailable)?;
let target = normalized.candidate_target;
Ok(hiroute_domain::ComputeNativeEndpointV3 {
target: hiroute_domain::ComputeManagementTargetV2 {
scheme: target.scheme,
authority: target.authority,
port: target.port,
request_path: target.request_path,
upstream_protocol: target.upstream_protocol,
protocol_profile_id: target.protocol_profile_id,
protocol_profile_revision: target.protocol_profile_revision,
},
authentication,
recheck: super::registered_endpoint_recheck_descriptor(resolved, other),
})
})
.collect()
}
fn select_registered_endpoint<'a>(
resolved: &'a ResolvedConnectionOptionV1,
source: Option<&ComputeManagementSourceV2>,
) -> Result<&'a ProtocolEndpointV1, ComputeManagementControlError> {
let endpoints = &resolved.endpoint_profile.protocol_endpoints;
if let Some(source) = source {
let mut compatible = endpoints.iter().filter(|endpoint| {
super::registered_endpoint_matches_source(source, resolved, endpoint)
});
let endpoint = compatible
.next()
.ok_or(ComputeManagementControlError::RegisteredSourceMismatch)?;
if compatible.next().is_some() {
return Err(ComputeManagementControlError::RegisteredSourceMismatch);
}
return Ok(endpoint);
}
endpoints
.iter()
.filter(|endpoint| endpoint.authentication_semantics.is_some())
.min_by_key(|endpoint| endpoint.stable_preference)
.ok_or(ComputeManagementControlError::RegisteredOptionUnavailable)
}
pub(in crate::control::runtime) fn capability_declaration(
catalog: &hiroute_integrations::TrustedReleaseCatalog,
capability: &hiroute_domain::ModelEndpointCapabilityV1,
model: &hiroute_domain::ModelDefinitionV1,
reasoning: &hiroute_domain::ModelNativeReasoningV1,
) -> NativeModelCapabilityDeclarationV1 {
let defaults = hiroute_integrations::compute::official_capability_defaults(
catalog, capability, model, reasoning,
);
fn fact<T>(
value: hiroute_domain::ComputeManagementFactValueV2<T>,
) -> NativeCandidateFactValueV1<T> {
NativeCandidateFactValueV1 {
value: value.value,
basis: if value.basis == hiroute_domain::ComputeManagementFactBasisV2::Unknown {
NativeCandidateFactBasisV1::Unknown
} else {
NativeCandidateFactBasisV1::RegisteredCatalog
},
}
}
NativeModelCapabilityDeclarationV1 {
tool: fact(defaults.tool),
vision: fact(defaults.vision),
streaming: fact(defaults.streaming),
context_tokens: fact(defaults.context_tokens),
max_output_tokens: fact(defaults.max_output_tokens),
native_reasoning: fact(defaults.native_reasoning),
}
}
#[cfg(test)]
mod tests {
use super::*;
use hiroute_domain::{
GatewayAuthenticationSemanticsV1, NativeReasoningCapabilityV1, UpstreamProtocol,
};
const TEST_NAME: &str = "control::runtime::model_connections::registered::tests::registered_drafts_use_only_verified_catalog_facts";
fn request(
catalog: &hiroute_integrations::TrustedReleaseCatalog,
connection_option_id: &str,
) -> RegisteredModelConnectionCheckRequestV1 {
let provenance = catalog.compute_catalog_provenance().unwrap();
RegisteredModelConnectionCheckRequestV1 {
inference_model_id: None,
models: Vec::new(),
connection_option_id: connection_option_id.into(),
display_name: Some("团队 API".into()),
expected_catalog: ComputeCatalogProvenanceViewV1 {
product_release: provenance.product_release,
catalog_binding_id: provenance.catalog_binding_id,
release_sequence: provenance.release_sequence,
connector_registry_digest: provenance.connector_registry_digest,
model_data_digest: provenance.model_data_digest,
cross_reference_digest: provenance.cross_reference_digest,
},
candidate_ref: None,
lineage_ref: format!("lineage/{connection_option_id}"),
edit_revision: 1,
check_id: format!("check/{connection_option_id}/1"),
input_candidate: hiroute_application_api::ComputeCandidateRefV2 {
candidate_ref: format!("candidate/native/{connection_option_id}"),
candidate_revision: 1,
},
existing_source_id: None,
expected_source_revision: None,
}
}
#[test]
fn registered_drafts_use_only_verified_catalog_facts() {
if crate::test_support::isolated_agent_home(TEST_NAME) {
return;
}
let catalog = crate::release_catalog::current_fixture_catalog();
let root = tempfile::tempdir().unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(root.path(), std::fs::Permissions::from_mode(0o700)).unwrap();
}
let runtime = super::super::super::ProductionControlRuntime::open_with_release_catalog(
root.path(),
catalog.clone(),
)
.unwrap();
let listed = hiroute_application::control::ComputeFactsPort::connection_options(
runtime.adapter.as_ref(),
)
.unwrap();
let listed_bytes = serde_json::to_vec(&listed).unwrap();
assert!(
listed_bytes.len() <= hiroute_application_api::LOCAL_CONTROL_MAX_FRAME_BYTES - 8 * 1024,
"current metadata options exceed the bounded Local Control frame budget: {} bytes",
listed_bytes.len()
);
let metadata = listed.metadata_catalog.as_ref().unwrap();
// Connection clients receive the complete verified catalog. Inference provenance and
// rule explanations must not disappear at the transport boundary.
assert_eq!(
metadata,
&catalog.current_release_model_data().metadata_catalog
);
// The equality above protects every catalog record at the transport
// boundary; counts grow as model facts and their evidence are extended.
assert!(!metadata.provider_records.is_empty());
assert!(!metadata.model_records.is_empty());
assert!(!metadata.inference_rules.is_empty());
assert!(!metadata.evidence_sources.is_empty());
assert!(!metadata.endpoint_bindings.is_empty());
let token_plan_team = metadata
.access_products
.iter()
.find(|product| product.product_key == "bailian-token-team-cn-beijing")
.unwrap();
assert_eq!(token_plan_team.documented_upstream_model_ids.len(), 20);
assert!(
token_plan_team
.documented_upstream_model_ids
.iter()
.any(|id| id == "deepseek-v4.1-flash")
);
assert!(
metadata
.model_records
.iter()
.any(|model| !model.field_provenance.is_empty())
);
assert!(
listed
.options
.iter()
.filter(|option| option.origin != ConnectionOrigin::AgentSubscription)
.all(|option| option.registered_check_available)
);
let bailian = runtime
.adapter
.trusted_registered_draft(&request(&catalog, "bailian.payg.cn.v1"))
.unwrap();
assert_eq!(bailian.display_name, "团队 API");
let legacy = serde_json::from_str::<hiroute_application_api::ComputeConnectionTestRequestV1>(
include_str!("../../../../../application-api/tests/fixtures/v0.3.0-registered-connection-test.json"),
).unwrap();
let hiroute_application_api::ComputeConnectionTestRequestV1::Registered {
request: mut legacy,
} = legacy
else {
panic!("released fixture is not registered");
};
// The released request shape remains supported. Its pinned catalog must still
// reject changed metadata; a client refreshes that public snapshot before retrying.
assert!(matches!(
runtime.adapter.trusted_registered_draft(&legacy),
Err(ComputeManagementControlError::RegisteredCatalogChanged)
));
legacy.expected_catalog = request(&catalog, &legacy.connection_option_id).expected_catalog;
let legacy_draft = runtime.adapter.trusted_registered_draft(&legacy).unwrap();
let option = listed
.options
.iter()
.find(|option| option.connection_option_id == legacy.connection_option_id)
.unwrap();
assert_eq!(legacy_draft.display_name, option.display_name);
let app = hiroute_application::ApplicationService::new(runtime.application_ports());
let protected = |payload| {
hiroute_application_api::LocalControlWireRequestV2 {
schema_version: hiroute_application_api::SchemaVersion::new(2, 0),
request_id: "registered-name-authority".into(),
operation_id:
hiroute_application_api::CHECK_REGISTERED_MODEL_CONNECTION_OPERATION_V1.into(),
payload,
protected_grant: Some(hiroute_application_api::ProtectedClientGrantV2 {
principal_kind: hiroute_application_api::PrincipalKind::Desktop,
capability: "invalid-capability".into(),
}),
}
.authenticate_ambient()
};
let absent_name = app.dispatch(protected(serde_json::to_value(&legacy).unwrap()));
assert_eq!(
absent_name.error.unwrap().code,
hiroute_application_api::ErrorCode::InvalidArguments
);
let current = request(&catalog, "bailian.payg.cn.v1");
let named = app.dispatch(protected(serde_json::to_value(current).unwrap()));
assert_eq!(
named.error.unwrap().code,
hiroute_application_api::ErrorCode::CapabilityDenied
);
assert_eq!(legacy_draft.protocol, UpstreamProtocol::ChatCompletions);
let mut forged = legacy.clone();
forged.expected_catalog.cross_reference_digest =
hiroute_domain::CanonicalDigest::of_bytes(b"untrusted");
assert!(runtime.adapter.trusted_registered_draft(&forged).is_err());
assert_eq!(bailian.base_url, "https://dashscope.aliyuncs.com");
assert_eq!(
bailian.request_path_override.as_deref(),
Some("/compatible-mode/v1/chat/completions")
);
assert_eq!(
bailian.inventory_path_override.as_deref(),
Some("/api/v1/models")
);
assert_eq!(bailian.protocol, UpstreamProtocol::ChatCompletions);
assert_eq!(
bailian.authentication,
GatewayAuthenticationSemanticsV1::Bearer
);
assert!(
bailian
.protocol_header_semantics
.required_headers
.is_empty()
);
let anthropic = runtime
.adapter
.trusted_registered_draft(&request(&catalog, "anthropic.platform.global.v1"))
.unwrap();
assert_eq!(
anthropic.authentication,
GatewayAuthenticationSemanticsV1::ApiKeyHeader {
header: "x-api-key".into(),
}
);
assert_eq!(
anthropic.protocol_header_semantics.required_headers,
[("anthropic-version".into(), "2023-06-01".into())]
);
assert_eq!(
bailian
.models
.iter()
.map(|model| model.upstream_model_id.as_str())
.collect::<Vec<_>>(),
["qwen3-max-2026-01-23"]
);
assert!(matches!(
&bailian.models[0].capabilities.native_reasoning,
NativeCandidateFactValueV1 {
value: Some(NativeReasoningCapabilityV1::Toggle { parameter }),
basis: NativeCandidateFactBasisV1::RegisteredCatalog,
} if parameter == "enable_thinking"
));
let deepseek = runtime
.adapter
.trusted_registered_draft(&request(&catalog, "deepseek.official.global.v1"))
.unwrap();
assert_eq!(deepseek.display_name, "团队 API");
assert_eq!(deepseek.base_url, "https://api.deepseek.com");
assert_eq!(deepseek.inventory_path_override.as_deref(), Some("/models"));
assert_eq!(deepseek.protocol, UpstreamProtocol::Responses);
assert!(deepseek.models.is_empty());
assert!(
!deepseek
.runtime_fallback_denied_model_ids
.contains("deepseek-future-text-model")
);
let coding_plan = runtime
.adapter
.trusted_registered_draft(&request(&catalog, "zhipu.coding-plan.cn.v1"))
.unwrap();
assert_eq!(coding_plan.protocol, UpstreamProtocol::Responses);
assert_eq!(coding_plan.base_url, "https://open.bigmodel.cn");
assert_eq!(
coding_plan.request_path_override.as_deref(),
Some("/api/v1/responses")
);
assert!(
coding_plan
.protocol_header_semantics
.required_headers
.is_empty()
);
assert_eq!(coding_plan.models[0].upstream_model_id, "glm-5.3");
let mut stale = request(&catalog, "bailian.payg.cn.v1");
stale.expected_catalog.release_sequence += 1;
assert!(matches!(
runtime.adapter.trusted_registered_draft(&stale),
Err(ComputeManagementControlError::RegisteredCatalogChanged)
));
for supported in [
"bailian.coding-plan.cn.v1",
"bailian.token-plan.cn.v1",
"kimi.code.cn.v1",
"kimi.open-platform.cn.v1",
"zhipu.coding-plan.cn.v1",
"zhipu.general.cn.v1",
] {
let draft = runtime
.adapter
.trusted_registered_draft(&request(&catalog, supported))
.unwrap();
assert_eq!(draft.inventory_path_override, None);
assert_eq!(
draft.authentication,
GatewayAuthenticationSemanticsV1::Bearer
);
}
}
}