[11/13] refactor: provider config is plain data

CHANGELOG.md

@@ -710,6 +710,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   labels goes to the only matching call whose structured arguments are not
   complete. Parallel same-name calls whose ids are missing or reused are no
   longer merged into the first call.
+- `SigV4Fetch::with_clock` takes a plain function (`fn() -> DateTime<Utc>`)
+  instead of a closure.
 
 **Rust (aimux-providers)**
 
@@ -727,6 +729,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   `type` is validated when present, ids missing from the wire come from the
   provider's `generate_id`, and `DeltaToolCall.index` is required again, so a
   chunk without it fails to parse.
+- The private per-model configs hold data where they held closures: base
+  URLs (`OpenAIUrl`, `MessagesUrl`, `BaseUrl`), provider headers
+  (`ProviderHeaders`, `EndpointHeaders`), endpoint sources (Vertex, Bedrock,
+  Polly) and supported-URL rules. A registry row selects its chat usage
+  accounting with `profile.convert_usage` (`"alibaba"`, `"moonshotai"`)
+  instead of a name match. Public settings, requests and errors are
+  unchanged; the closures callers pass in settings (`transform_request_body`,
+  `generate_id`, the compatible `supported_urls`, `convert_usage` and
+  `metadata_extractor`) are kept as given.
+- `PresetDescriptor` gains a crate-private field (the row's usage converter),
+  so code outside the crate can no longer build one with a struct literal;
+  descriptors come from the registry JSON.
 
 **Rust (provider factory, RFC-0036)**
 

aimux-provider-utils/src/sigv4_fetch.rs

@@ -13,7 +13,6 @@
 //! Reference: <https://docs.aws.amazon.com/IAM/latest/UserGuide/create-signed-request.html>
 
 use std::fmt;
-use std::sync::Arc;
 
 use async_trait::async_trait;
 use chrono::{DateTime, Utc};
@@ -344,7 +343,9 @@ fn hmac_sha256(key: &[u8], data: &[u8]) -> Vec<u8> {
     mac.finalize().into_bytes().to_vec()
 }
 
-type Clock = Arc<dyn Fn() -> DateTime<Utc> + Send + Sync>;
+/// The signing clock: a plain function, so a fixed time in tests is a named
+/// function or a non-capturing closure.
+type Clock = fn() -> DateTime<Utc>;
 
 /// A [`Fetch`] decorator that signs every request with SigV4 and forwards it
 /// to the wrapped transport. A request marked [`RequestCredentials::Omit`] is
@@ -396,15 +397,15 @@ impl SigV4Fetch {
             inner,
             credentials,
             service: service.into(),
-            clock: Arc::new(Utc::now),
+            clock: Utc::now,
             signing,
         }
     }
 
     /// Replace the signing clock (deterministic signatures in tests).
     #[must_use]
-    pub fn with_clock(mut self, clock: impl Fn() -> DateTime<Utc> + Send + Sync + 'static) -> Self {
-        self.clock = Arc::new(clock);
+    pub fn with_clock(mut self, clock: fn() -> DateTime<Utc>) -> Self {
+        self.clock = clock;
         self
     }
 }
@@ -467,7 +468,7 @@ impl Fetch for SigV4Fetch {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Mutex;
+    use std::sync::{Arc, Mutex};
 
     use bytes::Bytes;
     use chrono::TimeZone;

aimux-providers/src/anthropic/config.rs

@@ -12,34 +12,76 @@
 use std::collections::{BTreeSet, HashMap};
 use std::sync::Arc;
 
-use futures::future::BoxFuture;
 use serde_json::Value;
 
+use crate::shared::{Credential, ProviderHeaders};
 use aimux_core::AiMuxError;
 use aimux_core::language_model::SupportedUrls;
 use aimux_provider_utils::{
-    ExchangeContext, FetchFunction, HeaderMapOpt, HeadersFn, HttpRequest, ResponseHandler,
-    combine_headers, normalize_headers,
+    ExchangeContext, FetchFunction, HeaderMapOpt, HttpRequest, ResponseHandler, combine_headers,
+    normalize_headers,
 };
 
 use super::convert::RequestProfile;
+use crate::shared::Endpoint;
 pub use crate::shared::TransformRequestBody;
 
-/// Maps an endpoint path (`"/messages"`) to the full request URL.
-pub(crate) type UrlFn = Arc<dyn Fn(&str) -> String + Send + Sync>;
+/// Where the messages call of a model goes.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub(crate) enum MessagesUrl {
+    /// `url("/messages")`: the first-party API and hosts that mirror it.
+    #[default]
+    Messages,
+    /// `{base_url}/{model id}:rawPredict`, or `:streamRawPredict` when
+    /// streaming: Anthropic on Vertex AI.
+    RawPredict,
+}
 
-/// `(model id, streaming)` to the full URL of the messages call, for hosts
-/// that put the model and the mode in the path.
-pub(crate) type RequestUrlFn = Arc<dyn Fn(&str, bool) -> String + Send + Sync>;
+/// Where a model's endpoint (base URL and provider headers) comes from.
+#[derive(Clone, Default)]
+pub(crate) enum AnthropicEndpoint {
+    /// The config's own `base_url` and `headers`.
+    #[default]
+    Fixed,
+    /// The Vertex endpoint of Anthropic's models, resolved for every request:
+    /// the project, location and credentials are only known when a call is
+    /// made. The config's own `base_url` and `headers` then only describe the
+    /// model's static identity.
+    Vertex(Arc<crate::vertex::Resolver>),
+    /// Claude Platform on AWS with no explicit base URL: every request goes
+    /// to `https://aws-external-anthropic.{region}.api.aws/v1` for the region
+    /// resolved then (`getBaseURL`, anthropic-aws-provider.ts:229-231).
+    AwsRegional(Arc<crate::anthropic_aws::Auth>),
+    /// An invalid base URL setting (`ANTHROPIC_BASE_URL`): every request
+    /// fails with this error before it is sent.
+    Invalid(AiMuxError),
+}
 
-/// Rewrites the request body a host-specific way.
-pub(crate) type BodyFn = Arc<dyn Fn(Value) -> Value + Send + Sync>;
+/// Where the provider headers of a request come from.
+#[derive(Clone)]
+pub(crate) enum AnthropicHeaders {
+    /// Credential, fixed and user headers (the common case).
+    Provider(ProviderHeaders),
+    /// Claude Platform on AWS: `anthropic-version`, the workspace id, the
+    /// caller's headers and, on the API-key path, `x-api-key` last, all
+    /// resolved on every request.
+    Aws(crate::anthropic_aws::AwsHeaders),
+}
+
+impl From<ProviderHeaders> for AnthropicHeaders {
+    fn from(headers: ProviderHeaders) -> Self {
+        Self::Provider(headers)
+    }
+}
 
-/// Builds the configuration of one request, for hosts whose endpoint or
-/// credentials (a Vertex project and location, say) can only be known when a
-/// call is made.
-pub(crate) type ResolveFn =
-    Arc<dyn Fn() -> BoxFuture<'static, Result<AnthropicModelConfig, AiMuxError>> + Send + Sync>;
+impl AnthropicHeaders {
+    async fn resolve(&self) -> Result<HeaderMapOpt, AiMuxError> {
+        match self {
+            Self::Provider(headers) => headers.resolve().await,
+            Self::Aws(headers) => headers.resolve().await,
+        }
+    }
+}
 
 /// Builds the host's error handler for non-2xx responses.
 pub(crate) type ErrorHandlerFn = fn() -> ResponseHandler<AiMuxError>;
@@ -49,12 +91,11 @@ pub(crate) type ErrorHandlerFn = fn() -> ResponseHandler<AiMuxError>;
 /// and `supportsStrictTools` config members, plus its error shape).
 #[derive(Clone)]
 pub(crate) struct AnthropicModelHooks {
-    /// The messages URL when it depends on the model and the mode. `None`:
-    /// `url("/messages")`.
-    pub(crate) request_url: Option<RequestUrlFn>,
+    /// Where the messages call goes.
+    pub(crate) messages_url: MessagesUrl,
     /// Applied to the finished request body before the provider's own
     /// `transform_request_body`.
-    pub(crate) prepare_body: Option<BodyFn>,
+    pub(crate) prepare_body: Option<fn(Value) -> Value>,
     /// Parses a failed response.
     pub(crate) failed_response_handler: ErrorHandlerFn,
     /// Structured outputs and their beta header.
@@ -67,7 +108,7 @@ impl Default for AnthropicModelHooks {
     /// The first-party API.
     fn default() -> Self {
         Self {
-            request_url: None,
+            messages_url: MessagesUrl::Messages,
             prepare_body: None,
             failed_response_handler: super::anthropic_failed_response_handler,
             supports_native_structured_output: true,
@@ -83,55 +124,79 @@ impl Default for AnthropicModelHooks {
 pub(crate) struct AnthropicModelConfig {
     /// The identity the model reports from `provider()`.
     pub(crate) provider: String,
-    /// Endpoint path to full URL.
-    pub(crate) url: UrlFn,
     /// Provider headers (credential, `anthropic-version`, user headers),
     /// resolved on every request.
-    pub(crate) headers: HeadersFn,
+    pub(crate) headers: AnthropicHeaders,
     /// Transport; `None` uses the process default, resolved per request.
     pub(crate) fetch: Option<FetchFunction>,
     /// URLs the model fetches itself. Empty: the caller downloads them.
     pub(crate) supported_urls: SupportedUrls,
     /// Provider-level request-body rewrite.
     pub(crate) transform_request_body: Option<TransformRequestBody>,
-    /// The origin credentialed headers may be sent to. Never read for URLs.
+    /// The URL every endpoint path is appended to; also the origin
+    /// credentialed headers may be sent to.
     pub(crate) base_url: String,
     /// The providerOptions key read in addition to `anthropic` and written
     /// on response metadata.
     pub(crate) provider_options_name: String,
     /// Host differences.
     pub(crate) hooks: AnthropicModelHooks,
-    /// Late binding: when set, every request uses the configuration this
-    /// returns (its own `resolve` is `None`) instead of the fields above,
-    /// which then only describe the model's static identity.
-    pub(crate) resolve: Option<ResolveFn>,
+    /// Where `base_url` and `headers` of a request come from.
+    pub(crate) endpoint: AnthropicEndpoint,
 }
 
 impl AnthropicModelConfig {
-    /// The configuration to use for one request: itself, or what the host's
-    /// `resolve` builds now.
+    /// The configuration to use for one request: itself, or itself with the
+    /// endpoint the host resolves now.
     ///
     /// # Errors
     ///
     /// Returns the error of the host's setting or credential loading, for
     /// instance `AiMuxError::LoadSetting` for an unset Vertex project.
     pub(crate) async fn resolved(&self) -> Result<Self, AiMuxError> {
-        match &self.resolve {
-            Some(resolve) => resolve().await,
-            None => Ok(self.clone()),
+        match &self.endpoint {
+            AnthropicEndpoint::Fixed => Ok(self.clone()),
+            AnthropicEndpoint::Invalid(error) => Err(error.clone()),
+            AnthropicEndpoint::Vertex(resolver) => {
+                let Endpoint { base_url, headers } = resolver
+                    .endpoint(crate::vertex::Publisher::Anthropic)
+                    .await?;
+                Ok(Self {
+                    base_url,
+                    headers: ProviderHeaders::bearer(Credential::None, Vec::new(), Some(headers))
+                        .into(),
+                    endpoint: AnthropicEndpoint::Fixed,
+                    ..self.clone()
+                })
+            }
+            AnthropicEndpoint::AwsRegional(auth) => {
+                let region = auth.host_region()?;
+                Ok(Self {
+                    base_url: format!("https://aws-external-anthropic.{region}.api.aws/v1"),
+                    endpoint: AnthropicEndpoint::Fixed,
+                    ..self.clone()
+                })
+            }
         }
     }
 
-    /// The full URL of an endpoint path.
+    /// The full URL of an endpoint path: `base_url` followed by `path`.
     pub(crate) fn url(&self, path: &str) -> String {
-        (self.url)(path)
+        format!("{}{path}", self.base_url)
     }
 
     /// The URL of the messages call for a model.
     pub(crate) fn messages_url(&self, model_id: &str, stream: bool) -> String {
-        match &self.hooks.request_url {
-            Some(request_url) => request_url(model_id, stream),
-            None => self.url("/messages"),
+        match self.hooks.messages_url {
+            MessagesUrl::Messages => self.url("/messages"),
+            MessagesUrl::RawPredict => {
+                let method = if stream {
+                    "streamRawPredict"
+                } else {
+                    "rawPredict"
+                };
+                format!("{}/{model_id}:{method}", self.base_url)
+            }
         }
     }
 
@@ -218,7 +283,7 @@ impl AnthropicModelConfig {
 
     /// Run the host's body preparation, then the provider-level rewrite.
     pub(crate) fn transform_body(&self, mut body: Value) -> Value {
-        if let Some(prepare) = &self.hooks.prepare_body {
+        if let Some(prepare) = self.hooks.prepare_body {
             body = prepare(body);
         }
         match &self.transform_request_body {

aimux-providers/src/anthropic/mod.rs

@@ -35,6 +35,7 @@ use std::sync::{Arc, OnceLock};
 use futures::future::BoxFuture;
 use serde_json::Value;
 
+use crate::shared::ProviderHeaders;
 use aimux_core::decision_model::DecisionModel;
 use aimux_core::embedding_model::EmbeddingModel;
 use aimux_core::error::AiMuxError;
@@ -44,12 +45,12 @@ use aimux_core::language_model::{LanguageModel, SupportedUrls};
 use aimux_core::model_catalogue::RuntimeModel;
 use aimux_core::provider::{Provider, ProviderDiscovery};
 use aimux_provider_utils::{
-    DecisionLanguageModel, FetchFunction, HeaderMapOpt, HeadersFn, Resolvable, validate_base_url,
+    DecisionLanguageModel, FetchFunction, HeaderMapOpt, Resolvable, validate_base_url,
 };
 
-use crate::shared::{AuthScheme, Credential, credential_headers};
+use crate::shared::{AuthScheme, Credential};
 
-use config::{AnthropicModelConfig, AnthropicModelHooks};
+use config::{AnthropicEndpoint, AnthropicModelConfig, AnthropicModelHooks};
 
 pub(crate) fn anthropic_failed_response_handler()
 -> aimux_provider_utils::ResponseHandler<AiMuxError> {
@@ -201,13 +202,13 @@ pub fn create_anthropic(
     Ok(AnthropicProvider {
         name: settings.name.unwrap_or_else(|| DEFAULT_NAME.to_string()),
         base_url,
-        headers: aimux_provider_utils::headers::with_user_agent_suffix_fn(
-            credential_headers(
-                credential,
-                scheme,
-                vec![("anthropic-version".to_string(), API_VERSION.to_string())],
-                settings.headers,
-            ),
+        headers: ProviderHeaders::new(
+            credential,
+            scheme,
+            vec![("anthropic-version".to_string(), API_VERSION.to_string())],
+            settings.headers,
+        )
+        .with_user_agent(
             crate::shared::aisdk_pins::ANTHROPIC.name,
             crate::shared::aisdk_pins::ANTHROPIC.version,
         ),
@@ -238,7 +239,7 @@ pub struct AnthropicProvider {
     /// The normalized base URL, or the error of an invalid
     /// `ANTHROPIC_BASE_URL`, which every request reports.
     base_url: Result<String, AiMuxError>,
-    headers: HeadersFn,
+    headers: ProviderHeaders,
     fetch: Option<FetchFunction>,
     supported_urls: SupportedUrls,
     generate_id: Option<Arc<dyn Fn() -> String + Send + Sync>>,
@@ -248,11 +249,9 @@ impl AnthropicProvider {
     /// The model configuration reporting `provider` as its identity.
     fn model_config(&self, provider: String) -> AnthropicModelConfig {
         let base_url = self.base_url.clone().unwrap_or_default();
-        let base = base_url.clone();
         AnthropicModelConfig {
             provider,
-            url: Arc::new(move |path| format!("{base}{path}")),
-            headers: self.headers.clone(),
+            headers: self.headers.clone().into(),
             fetch: self.fetch.clone(),
             supported_urls: self.supported_urls.clone(),
             transform_request_body: None,
@@ -261,12 +260,10 @@ impl AnthropicProvider {
             hooks: AnthropicModelHooks::default(),
             // Every request resolves its configuration first; an invalid
             // `ANTHROPIC_BASE_URL` fails it there.
-            resolve: self.base_url.as_ref().err().map(|error| {
-                let error = error.clone();
-                let resolve: config::ResolveFn =
-                    Arc::new(move || Box::pin(std::future::ready(Err(error.clone()))));
-                resolve
-            }),
+            endpoint: match &self.base_url {
+                Ok(_) => AnthropicEndpoint::Fixed,
+                Err(error) => AnthropicEndpoint::Invalid(error.clone()),
+            },
         }
     }