[7/8] feat: the remaining upstream model kinds

CHANGELOG.md

@@ -566,8 +566,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - The native Decision/Jev extension from master is retained. Its typed
   `JevConfig` / `JevProvider::new` entry point and `Provider::decision_model`
   remain available. Decision replay now takes the caller's registry;
-  recordings contain provider identity only and keep decision capabilities
-  separately under input. Decision retries use the core call-level policy.
+  recordings contain provider identity only and no capability snapshot
+  (see the DecisionModelV4 entry). Decision retries use the core call-level
+  policy.
 
 - `OpenAIProvider::language_model(id)` (and so `create_provider("openai", ..)`
   and the registry id `openai:<model>`) returns the **Responses** model, as
@@ -661,9 +662,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   replay time with an error that names it: its empty `provider_id`
   (`ProviderRecord::registry_id`) for a rebuild from a registry, a prompt in
   the older format (`InputRecord::unreadable_prompt`, loaded as empty),
-  older call options, or decision capabilities that only the older
-  `provider.profile` holds. `rebuild_provider(record, registry)` resolves
-  `provider_id` through the caller-supplied registry, retaining its settings.
+  older call options, or the pre-V4 decision options and results.
+  `rebuild_provider(record, registry)` resolves `provider_id` through the
+  caller-supplied registry, retaining its settings.
   If the default model method differs from the recorded one, pass the model
   to `replay_with_model`. Recorded provider strings change with the next item.
 - `model.provider()` follows the package's fixed identity or, where offered,
@@ -773,6 +774,52 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   with `InvalidArgument` before a request is sent.
 - `ExternalProviderEntry` debug output reports only whether `api_key` is
   present, keeping literal keys out of debug logs.
+- `TranscriptionModel::do_stream` is optional, as the AI SDK's `doStream?`:
+  it returns `Option<BoxFuture<…>>` and is `None` by default, instead of a
+  default method that fails with `UnsupportedFunctionality`. Implementors
+  return `Some(Box::pin(…))`. `stream_transcribe` reports a model without the
+  method as `UnsupportedFunctionality` before any I/O
+  (`The {provider} model "{id}" does not support streaming transcription.`).
+- `SpeechResult` has `usage: Option<JsonObject>`, the provider's usage in its
+  native shape, as the AI SDK's `SpeechModelV4Result.usage`. Google speech
+  passes its `usageMetadata` through; other vendors report `None`. Speech
+  model implementors set the field.
+- Decision recordings no longer store a capability snapshot:
+  `InputRecord::decision_capabilities` is removed, and
+  `InputRecord::from_decision_options` and `Recorder::record_decision_input`
+  no longer take capabilities. `MockDecisionReplayModel` does not read the
+  field; replay rebuilds the model from the host registry. The recording
+  schema stays 2, and older recordings with the field still load.
+- Decisions follow the AI SDK's `DecisionModelV4` (`@ai-sdk/provider@4.0.22`)
+  and `decide` (`ai@7.0.128`). Questions are a map keyed by id; Choice and
+  Score questions take `criteria` (option names to descriptions, ordered
+  levels). Answers are `{choice, probabilities?}`, `{score, probabilities?}`
+  (keyed `"0"`, `"1"`, …) and `{probability}`. `decide` takes `DecideOptions`
+  (the call options plus `max_retries`, default 2, and `timeout`) and returns
+  `DecideResult` (answers, usage with `total_tokens`, warnings, rounding,
+  provider metadata, response). It validates the input, rejects unsupported
+  question types before any I/O and validates the answers once after the
+  retries, with the upstream messages. The model call runs inside
+  `operation::OperationSettings::scope` with the decision's `max_retries` and
+  `timeout`, as `generate_text`'s does.
+- `DecisionModel` has `specification_version`, `provider`, `model_id`,
+  `supported_question_types` and `do_decide(&DecisionCallOptions)`;
+  `capabilities()` and `DecisionCapabilities` are removed, and provider limits
+  are checked in `do_decide` before HTTP. Images and OpenAI typed choice
+  values move to `provider_options.<provider>`; the probability source,
+  confidence, OpenAI typed values, Laya abstentions and `latency_ms` move to
+  `provider_metadata.<provider>`. An OpenAI refusal or a vLLM skipped question
+  fails the decision instead of returning a partial answer. Decision
+  recordings hold the `DecideOptions` and the `DecideResult`; recordings made
+  before this change load but do not replay.
+- `Provider::decision_model` returns `Option<Result<Arc<dyn DecisionModel>, _>>`,
+  `None` by default; the registry and `custom_provider` report `None` as
+  `NoSuchModel` with `model_type = "decisionModel"`. `Provider::evaluation_model`
+  and the `evaluation_model` module are removed: Google's `decision_model` is
+  the language-model adapter (`google.evaluation`), OpenAI's stays the native
+  Decisions API and `OpenAIProvider::evaluation` builds the Responses adapter.
+  `EvaluationLanguageModel` is renamed `DecisionLanguageModel`; its default
+  provider is `"{language provider}.decision"`.
 
 **C ABI**
 
@@ -782,6 +829,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   the key's description (`"OpenAI"`) or the setting name (`"region"`); no new
   symbol. `aimux_error_model_type` carries `NoSuchModel.model_type`. These two
   failures used to surface as `AIMUX_E_INVALID_ARGUMENT`.
+- `aimux_decide` takes `DecideOptions` JSON and returns `DecideResult` JSON.
+  `aimux_decision_capabilities` keeps its name and signature but returns
+  `{specification_version, provider, model_id, supported_question_types}`.
+  `aimux_provider_decision_model` on a provider without decision models
+  returns `AIMUX_E_NO_SUCH_MODEL` (was `AIMUX_E_UNSUPPORTED_FUNCTIONALITY`).
 - `aimux_provider_new`, `aimux_provider_handle_new` and `config_json` resolve
   names through the binding compatibility module (overlays, vendor packages
   and presets); `config_json` accepts
@@ -808,6 +860,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   `InvalidArgumentError`.
 - Recorded and traced provider strings follow `"{name}.{method}"`
   (`openai.chat`, not `openai`).
+- Decisions use the `DecideOptions` / `DecideResult` JSON. Node
+  `decisionCapabilities(model)` is replaced by `describeDecisionModel(model)`
+  and Python `decision_capabilities` by `describe_decision_model`; the native
+  `capabilities()` method is `describe()`. Python
+  `decide(model, state, questions, **options)` takes the questions as a dict
+  keyed by id.
 
 **Go / Java / Kotlin / Swift / Dart**
 
@@ -819,6 +877,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   have been silently ignored). The provider `config_json` helpers
   (`ProviderConfig` in Go and Dart) drop `max_retries` / `body_overrides` and
   gain `params`; call-level `max_retries` is unchanged.
+- Decisions use the `DecideOptions` / `DecideResult` JSON; the decision model's
+  `Capabilities()` / `capabilities()` is `Describe()` / `describe()` and
+  returns the model's V4 properties.
 
 **All bindings**
 
@@ -870,6 +931,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `OpenAIProvider::tools` and `AzureOpenAIProvider::tools`: the provider tools
   on the provider instance, as the AI SDK's `openai.tools` and `azure.tools`
   (`openai().tools.web_search(…)`). Azure's holds its upstream subset.
+- `custom_provider` forwards model discovery as it forwards files and
+  skills: `CustomProviderOptions::discovery`, else the fallback provider's
+  `discovery()`.
 - `aimux_core::wrap_provider`, the AI SDK's `wrapProvider`: wraps every
   language model of a provider with language-model middleware and, when
   given, every image model with image-model middleware; all other members

aimux-core/src/custom_provider.rs

@@ -0,0 +1,176 @@
+//! `custom_provider`: a provider assembled from alias tables, with an optional
+//! fallback provider.
+//!
+//! Mirrors the AI SDK's `customProvider` (`ai/src/registry/custom-provider.ts`).
+//! A lookup consults the alias table of its modality first, then the fallback
+//! provider; with neither, it is [`AiMuxError::NoSuchModel`]. There are no
+//! string aliases that resolve through a global default provider: Rust has
+//! none.
+//!
+//! The aimux discovery extension ([`Provider::discovery`]) is forwarded the
+//! way upstream forwards files and skills
+//! (`ai@7.0.127 src/registry/custom-provider.ts:268-283`: the configured
+//! interface, else the fallback provider's): the configured
+//! [`CustomProviderOptions::discovery`], else the fallback provider's.
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use crate::decision_model::DecisionModel;
+use crate::embedding_model::EmbeddingModel;
+use crate::error::AiMuxError;
+use crate::files_model::Files;
+use crate::image_model::ImageModel;
+use crate::language_model::LanguageModel;
+use crate::provider::{Provider, ProviderDiscovery};
+use crate::reranking_model::RerankingModel;
+use crate::search_model::SearchModel;
+use crate::skills_model::Skills;
+use crate::speech_model::SpeechModel;
+use crate::transcription_model::TranscriptionModel;
+use crate::video_model::VideoModel;
+
+/// Options of [`custom_provider`]; every field is optional.
+#[derive(Default)]
+pub struct CustomProviderOptions {
+    pub language_models: HashMap<String, Arc<dyn LanguageModel>>,
+    pub embedding_models: HashMap<String, Arc<dyn EmbeddingModel>>,
+    pub image_models: HashMap<String, Arc<dyn ImageModel>>,
+    pub transcription_models: HashMap<String, Arc<dyn TranscriptionModel>>,
+    pub speech_models: HashMap<String, Arc<dyn SpeechModel>>,
+    pub reranking_models: HashMap<String, Arc<dyn RerankingModel>>,
+    pub video_models: HashMap<String, Arc<dyn VideoModel>>,
+    pub search_models: HashMap<String, Arc<dyn SearchModel>>,
+    pub decision_models: HashMap<String, Arc<dyn DecisionModel>>,
+    /// A files interface for uploading files.
+    pub files: Option<Arc<dyn Files>>,
+    /// A skills interface for uploading skills.
+    pub skills: Option<Arc<dyn Skills>>,
+    /// aimux extension: a model-discovery interface. Without one, the
+    /// fallback provider's discovery is used.
+    pub discovery: Option<Arc<dyn ProviderDiscovery>>,
+    /// Consulted when a requested model is not in the alias tables.
+    pub fallback_provider: Option<Arc<dyn Provider>>,
+}
+
+/// A provider built by [`custom_provider`].
+pub struct CustomProvider {
+    options: CustomProviderOptions,
+}
+
+/// Create a custom provider from alias tables and an optional fallback.
+#[must_use]
+pub fn custom_provider(options: CustomProviderOptions) -> CustomProvider {
+    CustomProvider { options }
+}
+
+/// The aliased model, else what the fallback offers, else `NoSuchModel`.
+fn resolve<T: ?Sized>(
+    models: &HashMap<String, Arc<T>>,
+    id: &str,
+    model_type: &str,
+    fallback: impl FnOnce() -> Option<Result<Arc<T>, AiMuxError>>,
+) -> Result<Arc<T>, AiMuxError> {
+    models
+        .get(id)
+        .map(|model| Ok(Arc::clone(model)))
+        .or_else(fallback)
+        .unwrap_or_else(|| Err(AiMuxError::no_such_model(id, model_type)))
+}
+
+impl Provider for CustomProvider {
+    fn language_model(&self, id: &str) -> Result<Arc<dyn LanguageModel>, AiMuxError> {
+        let o = &self.options;
+        resolve(&o.language_models, id, "languageModel", || {
+            o.fallback_provider.as_ref().map(|p| p.language_model(id))
+        })
+    }
+
+    fn embedding_model(&self, id: &str) -> Result<Arc<dyn EmbeddingModel>, AiMuxError> {
+        let o = &self.options;
+        resolve(&o.embedding_models, id, "embeddingModel", || {
+            o.fallback_provider.as_ref().map(|p| p.embedding_model(id))
+        })
+    }
+
+    fn image_model(&self, id: &str) -> Result<Arc<dyn ImageModel>, AiMuxError> {
+        let o = &self.options;
+        resolve(&o.image_models, id, "imageModel", || {
+            o.fallback_provider.as_ref().map(|p| p.image_model(id))
+        })
+    }
+
+    // The optional modalities are always defined here, as upstream: an id
+    // neither table nor fallback serves is `NoSuchModel`, never `None`.
+
+    fn transcription_model(
+        &self,
+        id: &str,
+    ) -> Option<Result<Arc<dyn TranscriptionModel>, AiMuxError>> {
+        let o = &self.options;
+        Some(resolve(
+            &o.transcription_models,
+            id,
+            "transcriptionModel",
+            || o.fallback_provider.as_ref()?.transcription_model(id),
+        ))
+    }
+
+    fn speech_model(&self, id: &str) -> Option<Result<Arc<dyn SpeechModel>, AiMuxError>> {
+        let o = &self.options;
+        Some(resolve(&o.speech_models, id, "speechModel", || {
+            o.fallback_provider.as_ref()?.speech_model(id)
+        }))
+    }
+
+    fn reranking_model(&self, id: &str) -> Option<Result<Arc<dyn RerankingModel>, AiMuxError>> {
+        let o = &self.options;
+        Some(resolve(&o.reranking_models, id, "rerankingModel", || {
+            o.fallback_provider.as_ref()?.reranking_model(id)
+        }))
+    }
+
+    fn video_model(&self, id: &str) -> Option<Result<Arc<dyn VideoModel>, AiMuxError>> {
+        let o = &self.options;
+        Some(resolve(&o.video_models, id, "videoModel", || {
+            o.fallback_provider.as_ref()?.video_model(id)
+        }))
+    }
+
+    fn search_model(&self, id: &str) -> Option<Result<Arc<dyn SearchModel>, AiMuxError>> {
+        let o = &self.options;
+        Some(resolve(&o.search_models, id, "searchModel", || {
+            o.fallback_provider.as_ref()?.search_model(id)
+        }))
+    }
+
+    /// `ai@7.0.128 src/registry/custom-provider.ts:241-258`: the alias, else
+    /// the fallback provider's decision model, else `NoSuchModel`.
+    fn decision_model(&self, id: &str) -> Option<Result<Arc<dyn DecisionModel>, AiMuxError>> {
+        let o = &self.options;
+        Some(resolve(&o.decision_models, id, "decisionModel", || {
+            o.fallback_provider.as_ref()?.decision_model(id)
+        }))
+    }
+
+    fn files(&self) -> Option<Arc<dyn Files>> {
+        let o = &self.options;
+        o.files
+            .clone()
+            .or_else(|| o.fallback_provider.as_ref()?.files())
+    }
+
+    fn skills(&self) -> Option<Arc<dyn Skills>> {
+        let o = &self.options;
+        o.skills
+            .clone()
+            .or_else(|| o.fallback_provider.as_ref()?.skills())
+    }
+
+    fn discovery(&self) -> Option<&dyn ProviderDiscovery> {
+        let o = &self.options;
+        o.discovery
+            .as_deref()
+            .or_else(|| o.fallback_provider.as_ref()?.discovery())
+    }
+}