Align the request pipeline with the AI SDK

README.md

@@ -98,7 +98,7 @@ aimux/
 ├── aimux-core            # Core abstractions: LanguageModel / Provider / Message / StreamPart
 ├── aimux-providers       # 329 provider implementations (251 registry-backed + native)
 ├── aimux-stream          # SSE / NDJSON stream parsing
-├── aimux-provider-utils  # HTTP utilities: retry, backoff, error parsing, API-key loading
+├── aimux-provider-utils  # One-exchange HTTP helpers, response handlers, API-key loading
 ├── aimux-ffi             # C ABI (opaque handles + JSON results + owned aimux_error_t *) for non-native bindings
 └── tools/                # aimux-cli (cache probe) · aimux-replay · aimux-web (console)
 ```
@@ -122,7 +122,7 @@ cargo add aimux-core aimux-providers
 | `aimux-core` | Core abstractions: `LanguageModel` / `Provider` / `Message` / `StreamPart` | [crates.io](https://crates.io/crates/aimux-core) |
 | `aimux-providers` | 325 provider implementations | [crates.io](https://crates.io/crates/aimux-providers) |
 | `aimux-stream` | SSE / NDJSON stream parsing | [crates.io](https://crates.io/crates/aimux-stream) |
-| `aimux-provider-utils` | HTTP utilities: retry, backoff, error parsing | [crates.io](https://crates.io/crates/aimux-provider-utils) |
+| `aimux-provider-utils` | One-exchange HTTP helpers and typed response handlers | [crates.io](https://crates.io/crates/aimux-provider-utils) |
 | `aimux-ffi` | C ABI for non-native bindings | [crates.io](https://crates.io/crates/aimux-ffi) |
 
 **Node.js**:

aimux-core/Cargo.toml

@@ -17,11 +17,19 @@ futures = { workspace = true }
 async-stream = { workspace = true }
 tracing = { workspace = true }
 ts-rs = { workspace = true }
+# Deliberately narrower than the workspace-wide `full`: core's production
+# code uses only timers (`time`) and `select!` (`macros`). Keeping the
+# declaration at the real API surface documents what Core actually asks
+# of the runtime (RFC-0016 had removed core's tokio dependency; RFC-0031
+# reintroduces it for operation deadlines and retry backoff).
+tokio = { version = "1", features = ["time", "macros", "rt", "sync"] }
 tokio-util = "0.7"
+httpdate = { workspace = true }
+rand = { workspace = true }
 base64 = "0.22"
 
 [dev-dependencies]
-tokio = { workspace = true, features = ["macros", "rt"] }
+tokio = { workspace = true, features = ["macros", "rt", "test-util"] }
 
 [lints]
 workspace = true

aimux-core/src/abort_signal.rs

@@ -0,0 +1,37 @@
+//! Cooperative caller cancellation for Core operations.
+
+use tokio_util::sync::CancellationToken;
+
+/// A cancellation signal analogous to the Web `AbortSignal`.
+///
+/// Timeouts are deliberately not encoded as cancellation reasons. Core owns
+/// timeout deadlines and returns [`crate::AiMuxError::Timeout`] directly;
+/// this type represents only caller-requested cancellation.
+#[derive(Debug, Clone, Default)]
+pub struct AbortSignal {
+    token: CancellationToken,
+}
+
+impl AbortSignal {
+    /// Create a fresh signal.
+    #[must_use]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Cancel with the default reason.
+    pub fn abort(&self) {
+        self.token.cancel();
+    }
+
+    /// Whether cancellation has been requested.
+    #[must_use]
+    pub fn is_aborted(&self) -> bool {
+        self.token.is_cancelled()
+    }
+
+    /// Resolve when cancellation is requested.
+    pub fn cancelled(&self) -> impl std::future::Future<Output = ()> + Send + 'static {
+        self.token.clone().cancelled_owned()
+    }
+}

aimux-core/src/embedding_model.rs

@@ -1,4 +1,4 @@
-//! The `EmbeddingModel` trait — the provider-facing interface for text embeddings.
+//! The `EmbeddingModel` trait — the provider-facing interface for text embeddings.
 //!
 //! Aligned with Vercel AI SDK `EmbeddingModelV4`
 //! (`reference/ai/packages/provider/src/embedding-model/v4/`).
@@ -11,9 +11,8 @@ use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 
 use crate::error::AiMuxError;
-use crate::shared::{
-    AbortSignal, SharedHeaders, SharedProviderMetadata, SharedProviderOptions, Warning,
-};
+use crate::shared::{SharedHeaders, SharedProviderMetadata, SharedProviderOptions, Warning};
+use crate::{AbortSignal, retry, timeout};
 
 /// A single embedding vector.
 ///
@@ -36,6 +35,12 @@ pub struct EmbeddingCallOptions {
     #[ts(skip)]
     pub abort_signal: Option<AbortSignal>,
 
+    /// Per-call retry override. `None` uses the model default.
+    pub max_retries: Option<u32>,
+
+    /// Per-call operation timeout.
+    pub timeout: Option<crate::options::TimeoutConfiguration>,
+
     /// Additional provider-specific options, keyed by provider name.
     pub provider_options: Option<SharedProviderOptions>,
 
@@ -49,6 +54,8 @@ impl EmbeddingCallOptions {
         Self {
             values: vec![value.into()],
             abort_signal: None,
+            max_retries: None,
+            timeout: None,
             provider_options: None,
             headers: None,
         }
@@ -121,6 +128,10 @@ pub trait EmbeddingModel: Send + Sync {
     /// Provider-specific model ID, e.g. `"text-embedding-3-small"`.
     fn model_id(&self) -> &str;
 
+    fn retry_config(&self) -> crate::retry::RetryConfig {
+        crate::retry::RetryConfig::default()
+    }
+
     /// Limit of how many embeddings can be generated in a single API call.
     ///
     /// `None` means the model has no fixed limit. The TS spec allows this to
@@ -136,3 +147,27 @@ pub trait EmbeddingModel: Send + Sync {
     async fn do_embed(&self, options: &EmbeddingCallOptions)
     -> Result<EmbeddingResult, AiMuxError>;
 }
+
+/// User-facing embedding operation with Core-owned retry and timeout.
+///
+/// # Errors
+///
+/// Returns the provider failure, retry exhaustion, timeout, or caller abort.
+pub async fn embed(
+    model: &dyn EmbeddingModel,
+    options: EmbeddingCallOptions,
+) -> Result<EmbeddingResult, AiMuxError> {
+    let timeout = timeout::OperationTimeout::new(options.timeout.unwrap_or_default())?;
+    let abort_signal = options.abort_signal.clone();
+    let retries = retry::prepare_retries(
+        options.max_retries,
+        model.retry_config(),
+        abort_signal.clone(),
+    );
+    timeout::run(
+        retries.retry(|| model.do_embed(&options)),
+        abort_signal.as_ref(),
+        timeout,
+    )
+    .await
+}