diff --git a/samples/cosmos_read_item_native_tls/src/main.rs b/samples/cosmos_read_item_native_tls/src/main.rs
index 5508dc7e863..dd77510c28a 100644
--- a/samples/cosmos_read_item_native_tls/src/main.rs
+++ b/samples/cosmos_read_item_native_tls/src/main.rs
@@ -24,7 +24,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .await?;
 
     let db_client = client.database_client(&args.database);
-    let container_client = db_client.container_client(&args.container).await?;
+    let container_client = db_client.container_client(&args.container, None).await?;
 
     let response = container_client
         .read_item(&args.partition_key, &args.item_id, None)
diff --git a/sdk/cosmos/azure_data_cosmos/CHANGELOG.md b/sdk/cosmos/azure_data_cosmos/CHANGELOG.md
index 154e208cba9..2cc11fb67b5 100644
--- a/sdk/cosmos/azure_data_cosmos/CHANGELOG.md
+++ b/sdk/cosmos/azure_data_cosmos/CHANGELOG.md
@@ -22,6 +22,7 @@
 
 ### Breaking Changes
 
+- `DatabaseClient::container_client` now requires a second argument of type `Option<ContainerClientOptions>`; pass `None` to retain the previous behavior.
 - `CosmosClient::database_client` and `DatabaseClient::container_client` now take `impl Into<ResourceIdentity>` instead of `&str`; call sites passing a deref-able string (for example a `Cow<str>` field) need `&*value` or `.as_ref()`. ([#4687](https://github.com/Azure/azure-sdk-for-rust/pull/4687))
 - `DatabaseClient::id()` now returns `&ResourceIdentity` instead of `&str`. ([#4687](https://github.com/Azure/azure-sdk-for-rust/pull/4687))
 - Control-plane APIs are now gated behind the new `control_plane` feature, which is **not** enabled by default. Code using database or container management (`CosmosClient::create_database`/`query_databases`, `DatabaseClient::read`/`create_container`/`query_containers`/`delete`, `ContainerClient::replace`/`delete`), throughput management (`read_throughput`/`begin_replace_throughput`, `ThroughputPoller`), or the associated model and options types (`DatabaseProperties`, `ThroughputProperties`, and the container create/replace/delete/query, database, and throughput option types) must now enable the `control_plane` feature. Reading container properties via `ContainerClient::read()` — along with `ContainerProperties`, `IndexingPolicy`, `ResourceResponse`, and `ReadContainerOptions` — remains available without the feature, since it works with Entra ID authentication and mirrors the metadata read the SDK already performs internally. ([#4854](https://github.com/Azure/azure-sdk-for-rust/pull/4854))
diff --git a/sdk/cosmos/azure_data_cosmos/README.md b/sdk/cosmos/azure_data_cosmos/README.md
index 794142038ca..c950ebdab24 100644
--- a/sdk/cosmos/azure_data_cosmos/README.md
+++ b/sdk/cosmos/azure_data_cosmos/README.md
@@ -123,7 +123,10 @@ async fn example(cosmos_client: CosmosClient) -> Result<(), Box<dyn std::error::
         value: "2".into(),
     };
 
-    let container = cosmos_client.database_client("myDatabase").container_client("myContainer").await?;
+    let container = cosmos_client
+        .database_client("myDatabase")
+        .container_client("myContainer", None)
+        .await?;
 
     // Create an item
     container.create_item("partition1", "1", item, None).await?;
diff --git a/sdk/cosmos/azure_data_cosmos/examples/cosmos/batch.rs b/sdk/cosmos/azure_data_cosmos/examples/cosmos/batch.rs
index 9f733afbcdd..48def41552f 100644
--- a/sdk/cosmos/azure_data_cosmos/examples/cosmos/batch.rs
+++ b/sdk/cosmos/azure_data_cosmos/examples/cosmos/batch.rs
@@ -28,7 +28,7 @@ pub struct BatchCommand {
 impl BatchCommand {
     pub async fn run(&self, client: &CosmosClient) -> Result<(), Box<dyn Error>> {
         let db_client = client.database_client(&self.database);
-        let container_client = db_client.container_client(&self.container).await?;
+        let container_client = db_client.container_client(&self.container, None).await?;
 
         // Parse the operations JSON
         let operations: Vec<Value> = serde_json::from_str(&self.operations)?;
diff --git a/sdk/cosmos/azure_data_cosmos/examples/cosmos/create.rs b/sdk/cosmos/azure_data_cosmos/examples/cosmos/create.rs
index f3cee87dde3..3f9abad6c3d 100644
--- a/sdk/cosmos/azure_data_cosmos/examples/cosmos/create.rs
+++ b/sdk/cosmos/azure_data_cosmos/examples/cosmos/create.rs
@@ -89,7 +89,7 @@ impl CreateCommand {
                 show_updated,
             } => {
                 let db_client = client.database_client(&database);
-                let container_client = db_client.container_client(&container).await?;
+                let container_client = db_client.container_client(&container, None).await?;
 
                 let pk = PartitionKey::from(&partition_key);
                 let item: serde_json::Value = serde_json::from_str(&json)?;
diff --git a/sdk/cosmos/azure_data_cosmos/examples/cosmos/delete.rs b/sdk/cosmos/azure_data_cosmos/examples/cosmos/delete.rs
index 91553b60c09..00a6c674076 100644
--- a/sdk/cosmos/azure_data_cosmos/examples/cosmos/delete.rs
+++ b/sdk/cosmos/azure_data_cosmos/examples/cosmos/delete.rs
@@ -58,7 +58,7 @@ impl DeleteCommand {
                 partition_key,
             } => {
                 let db_client = client.database_client(&database);
-                let container_client = db_client.container_client(&container).await?;
+                let container_client = db_client.container_client(&container, None).await?;
 
                 let response = container_client
                     .delete_item(partition_key, &item_id, None)
@@ -81,7 +81,7 @@ impl DeleteCommand {
 
             Subcommands::Container { database, id } => {
                 let db_client = client.database_client(&database);
-                let container_client = db_client.container_client(&id).await?;
+                let container_client = db_client.container_client(&id, None).await?;
                 container_client.delete(None).await?;
                 Ok(())
             }
diff --git a/sdk/cosmos/azure_data_cosmos/examples/cosmos/metadata.rs b/sdk/cosmos/azure_data_cosmos/examples/cosmos/metadata.rs
index a7a2b8b43a8..8c97adb64be 100644
--- a/sdk/cosmos/azure_data_cosmos/examples/cosmos/metadata.rs
+++ b/sdk/cosmos/azure_data_cosmos/examples/cosmos/metadata.rs
@@ -21,7 +21,7 @@ impl MetadataCommand {
     pub async fn run(self, client: CosmosClient) -> Result<(), Box<dyn Error>> {
         let db_client = client.database_client(&self.database);
         if let Some(container_name) = &self.container {
-            let container_client = db_client.container_client(container_name).await?;
+            let container_client = db_client.container_client(container_name, None).await?;
             let response = container_client.read(None).await?.into_model()?;
             println!("{:#?}", response);
             return Ok(());
diff --git a/sdk/cosmos/azure_data_cosmos/examples/cosmos/query.rs b/sdk/cosmos/azure_data_cosmos/examples/cosmos/query.rs
index 9de13133baf..a926efe6ece 100644
--- a/sdk/cosmos/azure_data_cosmos/examples/cosmos/query.rs
+++ b/sdk/cosmos/azure_data_cosmos/examples/cosmos/query.rs
@@ -53,7 +53,7 @@ impl QueryCommand {
                 partition_key,
             } => {
                 let db_client = client.database_client(&database);
-                let container_client = db_client.container_client(&container).await?;
+                let container_client = db_client.container_client(&container, None).await?;
 
                 let scope = match partition_key {
                     Some(pk) => FeedScope::partition(pk),
diff --git a/sdk/cosmos/azure_data_cosmos/examples/cosmos/read.rs b/sdk/cosmos/azure_data_cosmos/examples/cosmos/read.rs
index c39cc5d03b6..05a59f40a52 100644
--- a/sdk/cosmos/azure_data_cosmos/examples/cosmos/read.rs
+++ b/sdk/cosmos/azure_data_cosmos/examples/cosmos/read.rs
@@ -53,7 +53,7 @@ impl ReadCommand {
                 partition_key,
             } => {
                 let db_client = client.database_client(&database);
-                let container_client = db_client.container_client(&container).await?;
+                let container_client = db_client.container_client(&container, None).await?;
 
                 let response = container_client
                     .read_item(&partition_key, &item_id, None)
@@ -93,7 +93,7 @@ impl ReadCommand {
                 container,
             } => {
                 let db_client = client.database_client(&database);
-                let container_client = db_client.container_client(&container).await?;
+                let container_client = db_client.container_client(&container, None).await?;
                 let response = container_client.read(None).await?.into_model()?;
                 println!("Container:");
                 println!("  {:#?}", response);
diff --git a/sdk/cosmos/azure_data_cosmos/examples/cosmos/replace.rs b/sdk/cosmos/azure_data_cosmos/examples/cosmos/replace.rs
index 080a5e05037..f4c18080e8b 100644
--- a/sdk/cosmos/azure_data_cosmos/examples/cosmos/replace.rs
+++ b/sdk/cosmos/azure_data_cosmos/examples/cosmos/replace.rs
@@ -72,7 +72,7 @@ impl ReplaceCommand {
                 show_updated,
             } => {
                 let db_client = client.database_client(&database);
-                let container_client = db_client.container_client(&container).await?;
+                let container_client = db_client.container_client(&container, None).await?;
 
                 let pk = PartitionKey::from(&partition_key);
                 let item: serde_json::Value = serde_json::from_str(&json)?;
@@ -127,7 +127,7 @@ impl ReplaceCommand {
             } => {
                 let throughput_properties = throughput_options.try_into()?;
                 let db_client = client.database_client(&database);
-                let container_client = db_client.container_client(&container).await?;
+                let container_client = db_client.container_client(&container, None).await?;
                 let new_throughput = container_client
                     .begin_replace_throughput(throughput_properties, None)
                     .await?
diff --git a/sdk/cosmos/azure_data_cosmos/examples/cosmos/upsert.rs b/sdk/cosmos/azure_data_cosmos/examples/cosmos/upsert.rs
index ff0d466d20d..4eec4f8d60f 100644
--- a/sdk/cosmos/azure_data_cosmos/examples/cosmos/upsert.rs
+++ b/sdk/cosmos/azure_data_cosmos/examples/cosmos/upsert.rs
@@ -36,7 +36,7 @@ pub struct UpsertCommand {
 impl UpsertCommand {
     pub async fn run(self, client: CosmosClient) -> Result<(), Box<dyn Error>> {
         let db_client = client.database_client(&self.database);
-        let container_client = db_client.container_client(&self.container).await?;
+        let container_client = db_client.container_client(&self.container, None).await?;
 
         let pk = PartitionKey::from(&self.partition_key);
         let item: serde_json::Value = serde_json::from_str(&self.json)?;
diff --git a/sdk/cosmos/azure_data_cosmos/src/clients/container_client.rs b/sdk/cosmos/azure_data_cosmos/src/clients/container_client.rs
index f4bea0e7e0a..890029b97b6 100644
--- a/sdk/cosmos/azure_data_cosmos/src/clients/container_client.rs
+++ b/sdk/cosmos/azure_data_cosmos/src/clients/container_client.rs
@@ -49,13 +49,14 @@ impl ContainerClient {
         context: ClientContext,
         database: &ResourceIdentity,
         container: ResourceIdentity,
+        options: crate::options::ContainerClientOptions,
     ) -> crate::Result<Self> {
         // The container's addressing mode must match the database's: name-with-name
         // or RID-with-RID. Mixing the two is not supported by the service routing.
         let container_ref = match (database, &container) {
             (ResourceIdentity::Name(db_name), ResourceIdentity::Name(container_name)) => context
                 .driver
-                .resolve_container(db_name, container_name)
+                .resolve_container(db_name, container_name, options.operation)
                 .await
                 .map_err(|e| {
                     azure_data_cosmos_driver::error::CosmosErrorBuilder::from_error(e)
@@ -77,38 +78,20 @@ impl ContainerClient {
                             ))
                             .build()
                     })?;
-
-                // The parent database RID is derived from the container RID, not
-                // taken from this `DatabaseClient`. Reject a container whose parent
-                // database does not match the addressed database so callers can't
-                // accidentally reach into a different database.
                 if resolved.database_rid() != db_rid.as_str() {
                     return Err(azure_data_cosmos_driver::error::CosmosError::builder()
-                        .with_status(
-                            azure_data_cosmos_driver::error::CosmosStatus::CLIENT_INVALID_RESOURCE_ID,
-                        )
-                        .with_message(format!(
-                            "container RID '{}' belongs to database '{}', not the addressed database '{}'",
-                            container_rid.as_str(),
-                            resolved.database_rid(),
-                            db_rid.as_str()
-                        ))
+                        .with_status(azure_data_cosmos_driver::error::CosmosStatus::CLIENT_INVALID_RESOURCE_ID)
+                        .with_message(format!("container RID '{}' belongs to database '{}', not the addressed database '{}'", container_rid.as_str(), resolved.database_rid(), db_rid.as_str()))
                         .build()
                         .into());
                 }
-
                 resolved
             }
             (ResourceIdentity::Name(_), ResourceIdentity::Rid(_))
             | (ResourceIdentity::Rid(_), ResourceIdentity::Name(_)) => {
                 return Err(azure_data_cosmos_driver::error::CosmosError::builder()
-                    .with_status(
-                        azure_data_cosmos_driver::error::CosmosStatus::CLIENT_MIXED_NAME_RID_ADDRESSING,
-                    )
-                    .with_message(
-                        "database and container must use the same addressing mode: \
-                         address both by name or both by RID",
-                    )
+                    .with_status(azure_data_cosmos_driver::error::CosmosStatus::CLIENT_MIXED_NAME_RID_ADDRESSING)
+                    .with_message("database and container must use the same addressing mode: address both by name or both by RID")
                     .build()
                     .into());
             }
@@ -119,7 +102,6 @@ impl ContainerClient {
             context,
         })
     }
-
     /// Builds the SDK-side [`CosmosOperationContext`] for this container's
     /// operations, carrying the operation name plus the database and container
     /// identity the driver context does not know.
diff --git a/sdk/cosmos/azure_data_cosmos/src/clients/database_client.rs b/sdk/cosmos/azure_data_cosmos/src/clients/database_client.rs
index 977ca9a5916..991fac3c5d1 100644
--- a/sdk/cosmos/azure_data_cosmos/src/clients/database_client.rs
+++ b/sdk/cosmos/azure_data_cosmos/src/clients/database_client.rs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 use crate::clients::{ClientContext, ContainerClient};
+use crate::options::ContainerClientOptions;
 use crate::{ResourceId, ResourceIdentity};
 #[cfg(feature = "control_plane")]
 use azure_data_cosmos_driver::models::DatabaseReference;
@@ -71,28 +72,24 @@ impl DatabaseClient {
     /// Gets a [`ContainerClient`] that can be used to access the container with the
     /// specified identity.
     ///
-    /// This method eagerly resolves immutable container metadata (resource ID and partition key
-    /// definition) from the service, so the returned client is ready for immediate use without
-    /// per-operation cache lookups.
-    ///
-    /// The container's addressing mode must match this database's: a name-addressed
-    /// database accepts only name-addressed containers, and a RID-addressed database
-    /// accepts only [`ResourceId`](crate::ResourceId)-addressed containers.
+    /// This method eagerly resolves immutable container metadata before returning the client.
     ///
     /// # Arguments
     /// * `container` - The name or RID of the container.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the container does not exist, the metadata cannot be
-    /// resolved, or the addressing mode does not match this database's.
+    /// * `options` - Optional parameters for creating the client.
     pub async fn container_client(
         &self,
         container: impl Into<ResourceIdentity>,
+        options: Option<ContainerClientOptions>,
     ) -> crate::Result<ContainerClient> {
-        ContainerClient::new(self.context.clone(), &self.identity, container.into()).await
+        ContainerClient::new(
+            self.context.clone(),
+            &self.identity,
+            container.into(),
+            options.unwrap_or_default(),
+        )
+        .await
     }
-
     /// Returns the identity (name or RID) used to construct this client.
     pub fn id(&self) -> &ResourceIdentity {
         &self.identity
@@ -404,6 +401,7 @@ mod tests {
     fn _assert_futures_are_send() {
         fn assert_send<T: Send>(_: T) {}
         let client: &DatabaseClient = todo!();
+        assert_send(client.container_client(todo!(), None));
         let container_identity: ResourceIdentity = todo!();
         assert_send(client.container_client(container_identity));
         assert_send(client.read(todo!()));
diff --git a/sdk/cosmos/azure_data_cosmos/src/options/container.rs b/sdk/cosmos/azure_data_cosmos/src/options/container.rs
index 38b15680511..701a10f21cf 100644
--- a/sdk/cosmos/azure_data_cosmos/src/options/container.rs
+++ b/sdk/cosmos/azure_data_cosmos/src/options/container.rs
@@ -8,6 +8,14 @@ use azure_data_cosmos_driver::options::OperationOptions;
 #[cfg(feature = "control_plane")]
 use crate::models::ThroughputProperties;
 
+/// Options to be passed to [`DatabaseClient::container_client()`](crate::clients::DatabaseClient::container_client()).
+#[derive(Clone, Default)]
+#[non_exhaustive]
+pub struct ContainerClientOptions {
+    /// General-purpose options used when resolving the container metadata.
+    pub operation: OperationOptions,
+}
+
 /// Options to be passed to [`DatabaseClient::create_container()`](crate::clients::DatabaseClient::create_container()).
 #[cfg(feature = "control_plane")]
 #[derive(Clone, Default)]
diff --git a/sdk/cosmos/azure_data_cosmos/src/options/mod.rs b/sdk/cosmos/azure_data_cosmos/src/options/mod.rs
index e1f264cfb84..f937e26dc15 100644
--- a/sdk/cosmos/azure_data_cosmos/src/options/mod.rs
+++ b/sdk/cosmos/azure_data_cosmos/src/options/mod.rs
@@ -29,7 +29,7 @@ pub use batch::{
 pub use change_feed::{ChangeFeedMode, ChangeFeedOptions, ChangeFeedStartFrom};
 pub use client::CosmosClientOptions;
 pub use consistency::ConsistencyLevel;
-pub use container::ReadContainerOptions;
+pub use container::{ContainerClientOptions, ReadContainerOptions};
 #[cfg(feature = "control_plane")]
 pub use container::{
     CreateContainerOptions, DeleteContainerOptions, QueryContainersOptions, ReplaceContainerOptions,
diff --git a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_aad.rs b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_aad.rs
index bede8fd05da..9939d1e8baf 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_aad.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_aad.rs
@@ -76,7 +76,7 @@ pub async fn aad_item_crud_roundtrip() -> Result<(), Box<dyn Error>> {
             let (aad_client, recorder) = run_context.aad_client().await?;
             let aad_container = aad_client
                 .database_client(db_client.id())
-                .container_client(&container_id)
+                .container_client(&container_id, None)
                 .await?;
 
             let unique = Uuid::new_v4().to_string();
@@ -183,7 +183,7 @@ pub async fn aad_read_container_metadata() -> Result<(), Box<dyn Error>> {
             let (aad_client, recorder) = run_context.aad_client().await?;
             let aad_container = aad_client
                 .database_client(db_client.id())
-                .container_client(&container_id)
+                .container_client(&container_id, None)
                 .await?;
 
             let properties = aad_container.read(None).await?.into_model()?;
diff --git a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_batch.rs b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_batch.rs
index f56eaa45754..5fcc0d1ab8a 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_batch.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_batch.rs
@@ -36,7 +36,7 @@ async fn create_container(
             None,
         )
         .await?;
-    let container_client = db_client.container_client(&container_id).await?;
+    let container_client = db_client.container_client(&container_id, None).await?;
 
     Ok(container_client)
 }
diff --git a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_containers.rs b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_containers.rs
index 42bb7811b26..0977192293b 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_containers.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_containers.rs
@@ -97,6 +97,7 @@ pub async fn container_crud_simple() -> Result<(), Box<dyn Error>> {
             }
             assert_eq!(vec![properties.id.clone()], ids);
 
+            let container_client = db_client.container_client(&properties.id, None).await?;
             let container_client = db_client.container_client(properties.id.as_ref()).await?;
             let mut updated_indexing_policy = IndexingPolicy::default();
             updated_indexing_policy.automatic = false;
diff --git a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_fault_injection.rs b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_fault_injection.rs
index ffd62d2e630..450d16dd4a7 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_fault_injection.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_fault_injection.rs
@@ -99,7 +99,9 @@ pub async fn fault_injection_probability_zero_never_fails() -> Result<(), Box<dy
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // With probability 0.0, all reads should succeed
             for i in 1..=5 {
@@ -169,7 +171,9 @@ pub async fn fault_injection_probability_one_always_fails() -> Result<(), Box<dy
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // With probability 1.0, all reads should fail
             for i in 1..=5 {
@@ -242,7 +246,9 @@ pub async fn fault_injection_429_retry_with_hit_limit() -> Result<(), Box<dyn Er
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // First request - should succeed after retries
             let result = fault_container_client.read_item(&pk, &item_id, None).await;
@@ -313,7 +319,9 @@ pub async fn fault_injection_delete_item_fault_crud_succeeds() -> Result<(), Box
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Read should succeed
             let read_result = fault_container_client.read_item(&pk, &item_id, None).await;
@@ -405,7 +413,9 @@ pub async fn fault_injection_container_specific() -> Result<(), Box<dyn Error>>
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Read should succeed since container name doesn't match "FaultyContainer"
             let result = fault_container_client.read_item(&pk, &item_id, None).await;
@@ -428,7 +438,7 @@ pub async fn fault_injection_container_specific() -> Result<(), Box<dyn Error>>
 
             // Now try to read using the fault client - should fail because container name contains "FaultyContainer"
             let faulty_fault_container_client = fault_db_client
-                .container_client(faulty_container_id)
+                .container_client(faulty_container_id, None)
                 .await?;
             let faulty_result = faulty_fault_container_client
                 .read_item(&pk, &item_id, None)
@@ -508,7 +518,9 @@ pub async fn fault_injection_multiple_rules_priority() -> Result<(), Box<dyn Err
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             let read_options = ItemReadOptions::default().with_operation_options(
                 OperationOptionsBuilder::new()
@@ -599,7 +611,9 @@ pub async fn fault_injection_first_rule_inactive_due_to_start_time() -> Result<(
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             let result = fault_container_client.read_item(&pk, &item_id, None).await;
 
@@ -679,7 +693,9 @@ pub async fn fault_injection_first_rule_expired_due_to_end_time() -> Result<(),
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Small delay to ensure duration has passed
             tokio::time::sleep(Duration::from_millis(100)).await;
@@ -754,7 +770,9 @@ pub async fn fault_injection_hit_limit_behavior() -> Result<(), Box<dyn Error>>
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // First 2 requests should fail with one in region retry
             for i in 1..=2 {
@@ -824,7 +842,9 @@ pub async fn fault_injection_empty_rules() -> Result<(), Box<dyn Error>> {
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Read should succeed with no fault rules
             let result = fault_container_client.read_item(&pk, &item_id, None).await;
@@ -894,7 +914,9 @@ pub async fn fault_injection_metadata_fault_item_ops_succeed() -> Result<(), Box
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Cache warmup: read the container with the rule disabled so that
             // ContainerClient::read() populates the internal container cache.
@@ -1011,7 +1033,9 @@ pub async fn fault_injection_enable_disable_rule() -> Result<(), Box<dyn Error>>
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Rule is enabled — read should fail
             let result = fault_container_client.read_item(&pk, &item_id, None).await;
@@ -1114,7 +1138,9 @@ pub async fn gateway_v2_connection_error_fails_fast_after_all_regions_attempted(
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // The rule fires on every Gateway 2.0 attempt across every
             // region. With fail-fast semantics, the read must surface the
@@ -1201,7 +1227,7 @@ pub async fn error_diagnostics_records_retry_history() -> Result<(), Box<dyn Err
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client.container_client(&container_id, None).await?;
 
             let err = fault_container_client
                 .read_item(&pk, &item_id, None)
@@ -1377,7 +1403,9 @@ pub async fn fault_injection_449_retry_with_hit_limit() -> Result<(), Box<dyn Er
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // The driver retries 449 in-region; with hit_limit=2 the rule
             // fires twice and the third attempt succeeds because the rule
@@ -1446,7 +1474,7 @@ pub async fn error_diagnostics_includes_fault_injection_evaluations() -> Result<
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client.container_client(&container_id, None).await?;
 
             let err = fault_container_client
                 .read_item(&pk, &item_id, None)
@@ -1559,7 +1587,7 @@ pub async fn gateway_v2_449_retry_with_hit_limit() -> Result<(), Box<dyn Error>>
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client.container_client(&container_id, None).await?;
 
             // The driver retries 449 in-region; with hit_limit=2 the rule
             // fires twice on Gateway 2.0 traffic and the third attempt
@@ -1625,7 +1653,9 @@ pub async fn cosmos_error_accessors_match_diagnostics_after_fault() -> Result<()
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             let err = fault_container_client
                 .read_item(&pk, &item_id, None)
diff --git a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_items.rs b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_items.rs
index 062a61f4850..675c5644d8d 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_items.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_items.rs
@@ -142,7 +142,7 @@ async fn create_container(
             None,
         )
         .await?;
-    let container_client = db_client.container_client(&container_id).await?;
+    let container_client = db_client.container_client(&container_id, None).await?;
 
     Ok(container_client)
 }
@@ -198,7 +198,7 @@ async fn create_v1_container(
         )
         .into());
     }
-    let container_client = db_client.container_client(&container_id).await?;
+    let container_client = db_client.container_client(&container_id, None).await?;
 
     let body = container_client.read(None).await?.into_body().single()?;
     let raw: serde_json::Value = serde_json::from_slice(&body)?;
diff --git a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_patch.rs b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_patch.rs
index 811aa3d3cee..107f46472d7 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_patch.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_patch.rs
@@ -42,7 +42,7 @@ async fn create_container(
             None,
         )
         .await?;
-    let container_client = db_client.container_client(&container_id).await?;
+    let container_client = db_client.container_client(&container_id, None).await?;
     Ok(container_client)
 }
 
@@ -291,7 +291,7 @@ async fn setup_fault_injected_container(
         )
         .await?;
 
-    let regular = db_client.container_client(&container_id).await?;
+    let regular = db_client.container_client(&container_id, None).await?;
     regular
         .create_item(&initial.partition_key, &initial.id, initial, None)
         .await?;
@@ -300,7 +300,9 @@ async fn setup_fault_injected_container(
         .fault_client()
         .expect("fault client should be configured");
     let fault_db_client = fault_client.database_client(db_client.id());
-    let fault_container = fault_db_client.container_client(&container_id).await?;
+    let fault_container = fault_db_client
+        .container_client(&container_id, None)
+        .await?;
 
     Ok((
         regular,
diff --git a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_query_features.rs b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_query_features.rs
index 07645d93d9b..9580da4fdae 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_query_features.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_query_features.rs
@@ -90,7 +90,7 @@ async fn seed_container(db: &DatabaseClient) -> azure_data_cosmos::Result<Contai
         }
     }
 
-    let container = db.container_client("QueryFeaturesContainer").await?;
+    let container = db.container_client("QueryFeaturesContainer", None).await?;
     for record in sales_records() {
         container
             .create_item(record.partition_key.clone(), &record.id, &record, None)
diff --git a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_response_metadata.rs b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_response_metadata.rs
index 784d274d4da..46838999df3 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_response_metadata.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/emulator_tests/cosmos_response_metadata.rs
@@ -33,7 +33,7 @@ async fn create_container(
             None,
         )
         .await?;
-    db_client.container_client(&container_id).await
+    db_client.container_client(&container_id, None).await
 }
 
 fn cosmos_headers_from_error(error: &azure_data_cosmos::CosmosError) -> ResponseHeaders {
diff --git a/sdk/cosmos/azure_data_cosmos/tests/framework/test_client.rs b/sdk/cosmos/azure_data_cosmos/tests/framework/test_client.rs
index 6236ad17040..a75ce1bc6ab 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/framework/test_client.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/framework/test_client.rs
@@ -870,7 +870,7 @@ impl TestRunContext {
     ) -> azure_data_cosmos::Result<ContainerClient> {
         self.management_client()
             .database_client(db_client.id())
-            .container_client(container_id)
+            .container_client(container_id, None)
             .await
     }
 
@@ -1052,6 +1052,7 @@ impl TestRunContext {
             {
                 Ok(response) => {
                     let created = response.into_model()?;
+                    return db_client.container_client(&created.id, None).await;
                     return db_client.container_client(created.id.as_ref()).await;
                 }
                 Err(e) if e.status().status_code() == StatusCode::TooManyRequests => {
@@ -1064,6 +1065,7 @@ impl TestRunContext {
                 }
                 Err(e) if e.status().status_code() == StatusCode::Conflict => {
                     // Container already exists, delete and recreate it, then return a client
+                    let container_client = db_client.container_client(&properties.id, None).await?;
                     let container_client =
                         db_client.container_client(properties.id.as_ref()).await?;
                     container_client.delete(None).await?;
@@ -1073,6 +1075,7 @@ impl TestRunContext {
                         .create_container(properties.clone(), options.clone())
                         .await?;
                     let created = response.into_model()?;
+                    return db_client.container_client(&created.id, None).await;
                     return db_client.container_client(created.id.as_ref()).await;
                 }
                 Err(e) => return Err(e),
@@ -1116,6 +1119,7 @@ impl TestRunContext {
                     let db_client = original_db_client;
                     let container_id = original_container_id.clone();
                     async move {
+                        let container = db_client.container_client(&container_id, None).await?;
                         let container = db_client.container_client(&*container_id).await?;
                         container.read(None).await?;
                         Ok::<_, azure_data_cosmos::CosmosError>(container)
@@ -1139,6 +1143,7 @@ impl TestRunContext {
                     async move {
                         let container = fault_client
                             .database_client(&db_id)
+                            .container_client(&container_id, None)
                             .container_client(&*container_id)
                             .await?;
                         container.read(None).await?;
@@ -1203,6 +1208,7 @@ impl TestRunContext {
                     async move {
                         let container = client
                             .database_client(&db_id)
+                            .container_client(&container_id, None)
                             .container_client(&*container_id)
                             .await?;
                         container.read(None).await?;
@@ -1229,6 +1235,7 @@ impl TestRunContext {
                     async move {
                         let container = client
                             .database_client(&db_id)
+                            .container_client(&container_id, None)
                             .container_client(&*container_id)
                             .await?;
                         container.read(None).await?;
@@ -1251,6 +1258,7 @@ impl TestRunContext {
                     let db_client = original_db_client;
                     let container_id = original_container_id.clone();
                     async move {
+                        let container = db_client.container_client(&container_id, None).await?;
                         let container = db_client.container_client(&*container_id).await?;
                         container.read(None).await?;
                         Ok::<_, azure_data_cosmos::CosmosError>(container)
diff --git a/sdk/cosmos/azure_data_cosmos/tests/framework/test_data.rs b/sdk/cosmos/azure_data_cosmos/tests/framework/test_data.rs
index 13b41da1ef4..32a881adfa0 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/framework/test_data.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/framework/test_data.rs
@@ -62,7 +62,7 @@ pub async fn create_container_with_items(
         }
     }
 
-    let container_client = db.container_client("TestContainer").await?;
+    let container_client = db.container_client("TestContainer", None).await?;
 
     for item in items {
         let item_id = item.id.clone();
diff --git a/sdk/cosmos/azure_data_cosmos/tests/gateway_v2_tests/gateway_v2_e2e.rs b/sdk/cosmos/azure_data_cosmos/tests/gateway_v2_tests/gateway_v2_e2e.rs
index 0e11dab3b7e..04e041c7865 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/gateway_v2_tests/gateway_v2_e2e.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/gateway_v2_tests/gateway_v2_e2e.rs
@@ -193,7 +193,7 @@ async fn wait_for_container_ready(
 
     for attempt in 0..MAX_ATTEMPTS {
         let last_err: Box<dyn std::error::Error> =
-            match db_client.container_client(container_name).await {
+            match db_client.container_client(container_name, None).await {
                 Ok(container_client) => match container_client.read(None).await {
                     Ok(_) => return Ok(container_client),
                     Err(e)
@@ -354,7 +354,7 @@ async fn assert_item_readable_from_region(
     let db_client = client.database_client(db_name);
 
     for attempt in 0..MAX_ATTEMPTS {
-        let container = match db_client.container_client(container_name).await {
+        let container = match db_client.container_client(container_name, None).await {
             Ok(container) => container,
             Err(e)
                 if (e.status().status_code() == StatusCode::NotFound
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/binary_round_trip.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/binary_round_trip.rs
index 8db61fc8dac..9265c7e016c 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/binary_round_trip.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/binary_round_trip.rs
@@ -94,7 +94,7 @@ async fn build_container(db_name: &str, binary: bool) -> ContainerClient {
 
     client
         .database_client(db_name)
-        .container_client("items")
+        .container_client("items", None)
         .await
         .unwrap()
 }
@@ -303,7 +303,7 @@ async fn request_text_response_keeps_wire_binary_and_returns_data() {
         .unwrap();
     let container = client
         .database_client("bin-transcode")
-        .container_client("items")
+        .container_client("items", None)
         .await
         .unwrap();
 
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/change_feed.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/change_feed.rs
index 2dc02fbfa31..7a6d4c27e14 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/change_feed.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/change_feed.rs
@@ -107,7 +107,7 @@ async fn setup() -> Result<ContainerClient, Box<dyn Error>> {
 
     let container = client
         .database_client(DB_NAME)
-        .container_client(CONTAINER_NAME)
+        .container_client(CONTAINER_NAME, None)
         .await?;
 
     Ok(container)
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/cosmos_hpk_split.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/cosmos_hpk_split.rs
index 67ab5e01990..5a760b2822e 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/cosmos_hpk_split.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/cosmos_hpk_split.rs
@@ -147,7 +147,10 @@ fn create_geo_container(store: &Arc<EmulatorStore>, partition_count: u32) {
 }
 
 async fn container_client(client: &CosmosClient) -> Result<ContainerClient, Box<dyn Error>> {
-    Ok(client.database_client(DB).container_client(COLL).await?)
+    Ok(client
+        .database_client(DB)
+        .container_client(COLL, None)
+        .await?)
 }
 
 async fn seed(container: &ContainerClient, items: &[GeoItem]) -> Result<(), Box<dyn Error>> {
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/driver_end_to_end.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/driver_end_to_end.rs
index d45d7aa9694..6273a3f3f87 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/driver_end_to_end.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/driver_end_to_end.rs
@@ -87,14 +87,14 @@ async fn setup_with_container() -> (
     // Resolve containers
     let emu_container = backend
         .emulator_driver
-        .resolve_container(&db_name, container_name)
+        .resolve_container(&db_name, container_name, OperationOptions::default())
         .await
         .unwrap();
 
     let real_container = if let Some(ref real_driver) = backend.real_driver {
         Some(
             real_driver
-                .resolve_container(&db_name, container_name)
+                .resolve_container(&db_name, container_name, OperationOptions::default())
                 .await
                 .unwrap(),
         )
@@ -296,7 +296,7 @@ async fn create_database_and_container_through_driver() {
     // Verify container is resolvable on emulator
     let _emu_coll = backend
         .emulator_driver
-        .resolve_container(&db_name, container_name)
+        .resolve_container(&db_name, container_name, OperationOptions::default())
         .await
         .unwrap();
 
@@ -882,7 +882,7 @@ async fn paused_satellite_converges_to_latest_hub_write() {
         .unwrap();
 
     let container = driver
-        .resolve_container(&db_name, "hub-testcoll")
+        .resolve_container(&db_name, "hub-testcoll", OperationOptions::default())
         .await
         .unwrap();
 
@@ -1029,7 +1029,7 @@ async fn create_retries_after_429_throttling() {
         .await
         .unwrap();
     let container = driver
-        .resolve_container(&db_name, "throttle_coll")
+        .resolve_container(&db_name, "throttle_coll", OperationOptions::default())
         .await
         .unwrap();
 
@@ -1210,7 +1210,7 @@ async fn read_failover_on_503_via_fault_injection() {
         .unwrap();
 
     let emu_container = emu_driver
-        .resolve_container("fi-testdb", "fi-testcoll")
+        .resolve_container("fi-testdb", "fi-testcoll", OperationOptions::default())
         .await
         .unwrap();
 
@@ -1424,7 +1424,7 @@ async fn try_real_failover_comparison(
         .ok()?;
 
     let container = driver
-        .resolve_container(&db_name, "fi-testcoll")
+        .resolve_container(&db_name, "fi-testcoll", OperationOptions::default())
         .await
         .ok()?;
 
@@ -1498,13 +1498,13 @@ async fn setup_with_v1_container() -> (
 
     let emu_container = backend
         .emulator_driver
-        .resolve_container(&db_name, container_name)
+        .resolve_container(&db_name, container_name, OperationOptions::default())
         .await
         .unwrap();
     let real_container = if let Some(ref real_driver) = backend.real_driver {
         Some(
             real_driver
-                .resolve_container(&db_name, container_name)
+                .resolve_container(&db_name, container_name, OperationOptions::default())
                 .await
                 .unwrap(),
         )
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/dtx_live_comparison.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/dtx_live_comparison.rs
index 19eb59840d8..1be9b1929a7 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/dtx_live_comparison.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/dtx_live_comparison.rs
@@ -136,7 +136,10 @@ async fn resolve_container_with_retry(
 ) -> Result<ContainerReference, Box<dyn Error>> {
     let mut last_error = None;
     for _ in 0..10 {
-        match driver.resolve_container(db_name, container_name).await {
+        match driver
+            .resolve_container(db_name, container_name, OperationOptions::default())
+            .await
+        {
             Ok(container) => return Ok(container),
             Err(error) => {
                 last_error = Some(error);
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/dtx_sdk_validation.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/dtx_sdk_validation.rs
index 1b370fa4c0d..ccdc0473238 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/dtx_sdk_validation.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/dtx_sdk_validation.rs
@@ -117,7 +117,7 @@ async fn write_transaction_rejects_container_from_different_account() -> Result<
     );
     let foreign_container = container_client_owner
         .database_client("db")
-        .container_client("coll")
+        .container_client("coll", None)
         .await?;
 
     let transaction = azure_data_cosmos::DistributedWriteTransaction::new().delete_item(
@@ -162,7 +162,7 @@ async fn read_transaction_rejects_container_from_different_account() -> Result<(
     );
     let foreign_container = container_client_owner
         .database_client("db")
-        .container_client("coll")
+        .container_client("coll", None)
         .await?;
 
     let transaction = azure_data_cosmos::DistributedReadTransaction::new().read_item(
@@ -276,7 +276,13 @@ async fn emulator_point_writes_wait_for_dtx_write_guard() -> Result<(), Box<dyn
             .build(),
         )
         .await?;
-    let container = driver.resolve_container("db", "coll").await?;
+    let container = driver
+        .resolve_container(
+            "db",
+            "coll",
+            azure_data_cosmos_driver::options::OperationOptions::default(),
+        )
+        .await?;
     let mut write_task = tokio::spawn(async move {
         let body = serde_json::to_vec(&json!({
             "id": "blocked-item",
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/dual_backend.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/dual_backend.rs
index 20788d04e79..ab0d58413b3 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/dual_backend.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/dual_backend.rs
@@ -350,7 +350,10 @@ impl DualBackend {
             let deadline = Instant::now() + setup_timeout;
 
             while Instant::now() < deadline {
-                match driver.resolve_container(db, container).await {
+                match driver
+                    .resolve_container(db, container, OperationOptions::default())
+                    .await
+                {
                     Ok(region_container) => {
                         let probe = driver
                             .execute_singleton_operation(
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/end_to_end.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/end_to_end.rs
index 7379c26ea51..fcc75b4765b 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/end_to_end.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/end_to_end.rs
@@ -345,7 +345,7 @@ impl SdkDualBackend {
         let emu = self
             .emulator_client
             .database_client(db_name)
-            .container_client(container_name)
+            .container_client(container_name, None)
             .await?;
 
         let real = if let Some(ref client) = self.real_client {
@@ -528,7 +528,7 @@ async fn sdk_create_database_and_container_through_driver() {
     assert_eq!(emu_container_props.id, container_name);
 
     let _emu_container = emu_db_client
-        .container_client(container_name)
+        .container_client(container_name, None)
         .await
         .unwrap();
 
@@ -643,7 +643,7 @@ async fn sdk_container_throughput_read_and_replace() {
     let emu_container = backend
         .emulator_client
         .database_client(&db_name)
-        .container_client(container_name)
+        .container_client(container_name, None)
         .await
         .unwrap();
     let emu_throughput = emu_container.read_throughput(None).await.unwrap().unwrap();
@@ -664,7 +664,7 @@ async fn sdk_container_throughput_read_and_replace() {
     if let Some(ref real_client) = backend.real_client {
         let real_container = real_client
             .database_client(&db_name)
-            .container_client(container_name)
+            .container_client(container_name, None)
             .await
             .unwrap();
         let real_throughput = real_container.read_throughput(None).await.unwrap().unwrap();
@@ -1420,7 +1420,7 @@ async fn sdk_create_retries_after_429_throttling() {
 
     let emu_container = emulator_client
         .database_client(&db_name)
-        .container_client("throttle_coll")
+        .container_client("throttle_coll", None)
         .await
         .unwrap();
 
@@ -1538,7 +1538,7 @@ async fn sdk_throttling_retry_options_disables_retry() {
 
     let emu_container = emulator_client
         .database_client(&db_name)
-        .container_client("throttle_coll")
+        .container_client("throttle_coll", None)
         .await
         .unwrap();
 
@@ -1684,7 +1684,7 @@ async fn sdk_read_failover_on_503_via_fault_injection() {
 
     let emu_container = emu_client
         .database_client(&db_name)
-        .container_client("testcoll")
+        .container_client("testcoll", None)
         .await
         .unwrap();
 
@@ -1950,7 +1950,7 @@ async fn resolve_container_when_ready(
     let container = loop {
         match client
             .database_client(db_name)
-            .container_client(container_name)
+            .container_client(container_name, None)
             .await
         {
             Ok(container) => break container,
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/handler_propagation.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/handler_propagation.rs
index b6dc56af179..993902b5d70 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/handler_propagation.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/handler_propagation.rs
@@ -142,7 +142,7 @@ async fn handler_receives_singleton_success() {
     let (client, handler, db, container) = setup().await;
     let c = client
         .database_client(&db)
-        .container_client(&container)
+        .container_client(&container, None)
         .await
         .unwrap();
 
@@ -181,7 +181,7 @@ async fn handler_receives_singleton_failure() {
     let (client, handler, db, container) = setup().await;
     let c = client
         .database_client(&db)
-        .container_client(&container)
+        .container_client(&container, None)
         .await
         .unwrap();
 
@@ -213,7 +213,7 @@ async fn handler_receives_paginated_success() {
     let (client, handler, db, container) = setup().await;
     let c = client
         .database_client(&db)
-        .container_client(&container)
+        .container_client(&container, None)
         .await
         .unwrap();
 
@@ -271,7 +271,7 @@ async fn handler_receives_paginated_failure() {
     let (client, handler, db, container) = setup().await;
     let c = client
         .database_client(&db)
-        .container_client(&container)
+        .container_client(&container, None)
         .await
         .unwrap();
 
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/hpk.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/hpk.rs
index a9f2f1bf309..46751f01075 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/hpk.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/hpk.rs
@@ -122,7 +122,7 @@ async fn setup_hpk_container() -> ContainerClient {
 
     let container = client
         .database_client(&db_name)
-        .container_client("geo")
+        .container_client("geo", None)
         .await
         .unwrap();
 
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/partition_key_equality.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/partition_key_equality.rs
index bcc612341f9..804f751ac8f 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/partition_key_equality.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/partition_key_equality.rs
@@ -100,7 +100,7 @@ async fn setup_container() -> ContainerClient {
 
     let container = client
         .database_client(&db_name)
-        .container_client("docs")
+        .container_client("docs", None)
         .await
         .unwrap();
 
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/partition_range_drain.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/partition_range_drain.rs
index 2d6a8df6b06..80c08aa2671 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/partition_range_drain.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/partition_range_drain.rs
@@ -97,7 +97,7 @@ async fn read_feed_ranges_drains_25k_partition_container() {
         .unwrap();
     let container = client
         .database_client("large-db")
-        .container_client("large-container")
+        .container_client("large-container", None)
         .await
         .unwrap();
 
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/query_comparison.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/query_comparison.rs
index c4b8036df9a..ef68f63dda8 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/query_comparison.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/query_comparison.rs
@@ -350,7 +350,7 @@ async fn provision_fixture_with_topology(
     let emulator_driver_container = harness
         .emulator
         .driver
-        .resolve_container(db_name, container_name)
+        .resolve_container(db_name, container_name, OperationOptions::default())
         .await?;
     split_physical_partitions_at_points(harness, db_name, container_name, split_points).await?;
 
@@ -369,7 +369,7 @@ async fn provision_fixture_with_topology(
         .emulator
         .client
         .database_client(db_name)
-        .container_client(container_name)
+        .container_client(container_name, None)
         .await?;
     let external_container = if let Some(external) = &harness.external {
         Some(resolve_container_when_ready(&external.client, db_name, container_name).await?)
@@ -387,7 +387,7 @@ async fn provision_fixture_with_topology(
         Some(
             external
                 .driver
-                .resolve_container(db_name, container_name)
+                .resolve_container(db_name, container_name, OperationOptions::default())
                 .await?,
         )
     } else {
@@ -528,7 +528,7 @@ async fn resolve_container_when_ready(
     loop {
         match client
             .database_client(db_name)
-            .container_client(container_name)
+            .container_client(container_name, None)
             .await
         {
             Ok(container) => return Ok(container),
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/session_token.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/session_token.rs
index 674b52d3379..a89bd2e9bac 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/session_token.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/session_token.rs
@@ -208,7 +208,11 @@ impl Harness {
             .unwrap();
 
         let container = driver
-            .resolve_container(db_name, container_name)
+            .resolve_container(
+                db_name,
+                container_name,
+                azure_data_cosmos_driver::options::OperationOptions::default(),
+            )
             .await
             .unwrap();
 
diff --git a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/user_agent.rs b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/user_agent.rs
index 8b9b540869d..d137e1c2009 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/user_agent.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/in_memory_emulator_tests/user_agent.rs
@@ -167,7 +167,7 @@ async fn perform_create_and_read(
 
     let container = client
         .database_client(db_name)
-        .container_client(container_name)
+        .container_client(container_name, None)
         .await
         .expect("container client");
 
@@ -200,7 +200,7 @@ async fn perform_metadata_reads(
 
     let database = client.database_client(db_name);
     let container = database
-        .container_client(container_name)
+        .container_client(container_name, None)
         .await
         .expect("container client");
 
diff --git a/sdk/cosmos/azure_data_cosmos/tests/multi_write_tests/cosmos_multi_write_fault_injection.rs b/sdk/cosmos/azure_data_cosmos/tests/multi_write_tests/cosmos_multi_write_fault_injection.rs
index 221e49bdbe3..a74c9551ea2 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/multi_write_tests/cosmos_multi_write_fault_injection.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/multi_write_tests/cosmos_multi_write_fault_injection.rs
@@ -103,7 +103,9 @@ async fn verify_read_fails_with_injected_error(
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
             let options = read_options_for_expected_status(expected_status);
 
             let result = run_context
@@ -270,7 +272,9 @@ pub async fn item_read_succeeds_when_fault_targets_create_item() -> Result<(), B
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Read the item using the fault client - this should succeed because the fault only targets CreateItem
             let result = run_context
@@ -355,7 +359,9 @@ pub async fn fault_injection_read_region_retry_503() -> Result<(), Box<dyn Error
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Read should succeed on satellite region after primary returns 503
             let result = run_context
@@ -425,7 +431,9 @@ pub async fn fault_injection_transport_generated_503_write_retries_via_failover(
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             let unique_id = Uuid::new_v4().to_string();
             let item = TestItem {
@@ -522,7 +530,9 @@ pub async fn fault_injection_read_region_retry_404_1002() -> Result<(), Box<dyn
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Make sure the write has been replicated on both regions
             let _ = run_context
@@ -600,7 +610,9 @@ pub async fn fault_injection_write_connection_error_failover() -> Result<(), Box
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             let unique_id = Uuid::new_v4().to_string();
             let item = TestItem {
@@ -694,7 +706,9 @@ pub async fn fault_injection_read_connection_error_failover() -> Result<(), Box<
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Ensure replication to satellite before reading with fault client
             let mut operation = OperationOptions::default();
@@ -763,7 +777,9 @@ pub async fn fault_injection_write_response_timeout_does_not_retry() -> Result<(
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             let unique_id = Uuid::new_v4().to_string();
             let item = TestItem {
@@ -859,7 +875,9 @@ pub async fn fault_injection_read_response_timeout_retries_to_satellite(
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Ensure replication to satellite
             let mut operation = OperationOptions::default();
@@ -934,7 +952,9 @@ pub async fn fault_injection_connection_error_reverse_failover() -> Result<(), B
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             let unique_id = Uuid::new_v4().to_string();
             let item = TestItem {
@@ -1029,7 +1049,9 @@ pub async fn fault_injection_connection_error_local_retry_succeeds() -> Result<(
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             let _response = run_context
                 .read_item(&fault_container_client, &pk, &item_id, None)
@@ -1111,7 +1133,9 @@ pub async fn fault_injection_excluded_region_not_used_when_hub_fails() -> Result
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Caller-supplied exclusion: the satellite is off-limits for
             // this operation even if the hub is unhealthy.
diff --git a/sdk/cosmos/azure_data_cosmos/tests/multi_write_tests/cosmos_multi_write_retry_policies.rs b/sdk/cosmos/azure_data_cosmos/tests/multi_write_tests/cosmos_multi_write_retry_policies.rs
index f137ff5dca8..5a6a97b0072 100644
--- a/sdk/cosmos/azure_data_cosmos/tests/multi_write_tests/cosmos_multi_write_retry_policies.rs
+++ b/sdk/cosmos/azure_data_cosmos/tests/multi_write_tests/cosmos_multi_write_retry_policies.rs
@@ -100,7 +100,9 @@ pub async fn read_cross_region_retry_on_408() -> Result<(), Box<dyn Error>> {
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Read should succeed via cross-region retry after hub returns 408
             let result = run_context
@@ -169,7 +171,9 @@ pub async fn write_no_cross_region_retry_on_408() -> Result<(), Box<dyn Error>>
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             let unique_id = Uuid::new_v4().to_string();
             let item = TestItem {
@@ -247,7 +251,9 @@ pub async fn upsert_no_cross_region_retry_on_408() -> Result<(), Box<dyn Error>>
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             let unique_id = Uuid::new_v4().to_string();
             let item = TestItem {
@@ -345,7 +351,9 @@ pub async fn query_cross_region_retry_on_408() -> Result<(), Box<dyn Error>> {
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             let query = Query::from(format!("SELECT * FROM c WHERE c.partition_key = '{}'", pk));
 
@@ -430,7 +438,9 @@ pub async fn read_cross_region_retry_on_500() -> Result<(), Box<dyn Error>> {
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Read should succeed via cross-region retry after hub returns 500
             let result = run_context
@@ -517,7 +527,9 @@ pub async fn replace_no_cross_region_retry_on_408() -> Result<(), Box<dyn Error>
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             let updated_item = TestItem {
                 id: item_id.clone().into(),
@@ -611,7 +623,9 @@ pub async fn delete_no_cross_region_retry_on_408() -> Result<(), Box<dyn Error>>
                 .fault_client()
                 .expect("fault client should be available");
             let fault_db_client = fault_client.database_client(db_client.id());
-            let fault_container_client = fault_db_client.container_client(&container_id).await?;
+            let fault_container_client = fault_db_client
+                .container_client(&container_id, None)
+                .await?;
 
             // Delete should fail with 408 — no cross-region retry for writes
             let result = fault_container_client
diff --git a/sdk/cosmos/azure_data_cosmos_benchmarks/src/lib.rs b/sdk/cosmos/azure_data_cosmos_benchmarks/src/lib.rs
index 2c333f20fc5..9b6e4502153 100644
--- a/sdk/cosmos/azure_data_cosmos_benchmarks/src/lib.rs
+++ b/sdk/cosmos/azure_data_cosmos_benchmarks/src/lib.rs
@@ -297,7 +297,11 @@ pub async fn setup_live() -> (Arc<CosmosDriver>, ItemReference) {
 
     // Resolve the container (primes the container cache).
     let container_ref = driver
-        .resolve_container(database.as_str(), container.as_str())
+        .resolve_container(
+            database.as_str(),
+            container.as_str(),
+            OperationOptions::default(),
+        )
         .await
         .expect("failed to resolve container");
 
@@ -370,7 +374,7 @@ pub async fn setup() -> (Arc<CosmosDriver>, ItemReference) {
         .expect("failed to create driver");
 
     let container = driver
-        .resolve_container("benchdb", "benchcontainer")
+        .resolve_container("benchdb", "benchcontainer", OperationOptions::default())
         .await
         .expect("failed to resolve container");
 
diff --git a/sdk/cosmos/azure_data_cosmos_driver/src/driver/cosmos_driver.rs b/sdk/cosmos/azure_data_cosmos_driver/src/driver/cosmos_driver.rs
index 4a1ddc4694a..2f070bbe926 100644
--- a/sdk/cosmos/azure_data_cosmos_driver/src/driver/cosmos_driver.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver/src/driver/cosmos_driver.rs
@@ -1342,9 +1342,9 @@ impl CosmosDriver {
         &self,
         db_name: &str,
         container_name: &str,
+        options: OperationOptions,
     ) -> crate::error::Result<ContainerReference> {
         let db_ref = DatabaseReference::from_name(self.account().clone(), db_name.to_owned());
-        let options = OperationOptions::default();
 
         let container_result = self
             .execute_singleton_operation(
@@ -2050,7 +2050,7 @@ impl CosmosDriver {
         db_name: &str,
         container_name: &str,
     ) -> crate::error::Result<()> {
-        self.resolve_container_by_name(db_name, container_name)
+        self.resolve_container_by_name(db_name, container_name, OperationOptions::default())
             .await?;
         Ok(())
     }
@@ -3112,7 +3112,7 @@ impl CosmosDriver {
     ///     .await?;
     ///
     /// // Resolve the container (fetched from service on each call)
-    /// let container = driver.resolve_container("mydb", "mycontainer").await?;
+    /// let container = driver.resolve_container("mydb", "mycontainer", OperationOptions::default()).await?;
     ///
     /// // Use the resolved container for item operations
     /// let item = ItemReference::from_name(&container, PartitionKey::from("pk1"), "doc1");
@@ -3126,8 +3126,9 @@ impl CosmosDriver {
         &self,
         db_name: &str,
         container_name: &str,
+        operation_options: OperationOptions,
     ) -> crate::error::Result<ContainerReference> {
-        self.resolve_container_by_name(db_name, container_name)
+        self.resolve_container_by_name(db_name, container_name, operation_options)
             .await
     }
 
@@ -3139,6 +3140,7 @@ impl CosmosDriver {
         &self,
         db_name: &str,
         container_name: &str,
+        operation_options: OperationOptions,
     ) -> crate::error::Result<ContainerReference> {
         let endpoint = self.account().endpoint().as_str().to_owned();
         let db_name_owned = db_name.to_owned();
@@ -3148,7 +3150,11 @@ impl CosmosDriver {
             .runtime
             .container_cache()
             .get_or_fetch_by_name(&endpoint, db_name, container_name, || async move {
-                self.fetch_container_by_name(&db_name_owned, &container_name_owned)
+                self.fetch_container_by_name(
+                    &db_name_owned,
+                    &container_name_owned,
+                    operation_options,
+                )
                     .await
                     .map_err(|err| {
                         crate::error::CosmosErrorBuilder::from_error(err)
diff --git a/sdk/cosmos/azure_data_cosmos_driver/src/models/cosmos_operation.rs b/sdk/cosmos/azure_data_cosmos_driver/src/models/cosmos_operation.rs
index 930dfbb3070..c0246bf19f8 100644
--- a/sdk/cosmos/azure_data_cosmos_driver/src/models/cosmos_operation.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver/src/models/cosmos_operation.rs
@@ -115,7 +115,7 @@ fn format_rfc1123(timestamp: &OffsetDateTime) -> String {
 /// let driver = runtime.create_driver(DriverOptions::builder(account).build()).await?;
 ///
 /// // 2. Resolve the container (reads database + container from service, caches result)
-/// let container = driver.resolve_container("mydb", "mycontainer").await?;
+/// let container = driver.resolve_container("mydb", "mycontainer", OperationOptions::default()).await?;
 ///
 /// // 3. Build and execute item operations
 /// let item = ItemReference::from_name(&container, PartitionKey::from("pk1"), "doc1");
@@ -689,7 +689,7 @@ impl CosmosOperation {
     ///     "my-key",
     /// );
     /// let driver = runtime.create_driver(DriverOptions::builder(account).build()).await?;
-    /// let container = driver.resolve_container("my-database", "my-container").await?;
+    /// let container = driver.resolve_container("my-database", "my-container", OperationOptions::default()).await?;
     ///
     /// let result = driver
     ///     .execute_singleton_operation(
@@ -782,7 +782,7 @@ impl CosmosOperation {
     ///     "my-key",
     /// );
     /// let driver = runtime.create_driver(DriverOptions::builder(account).build()).await?;
-    /// let container = driver.resolve_container("my-database", "my-container").await?;
+    /// let container = driver.resolve_container("my-database", "my-container", OperationOptions::default()).await?;
     ///
     /// let item = ItemReference::from_name(&container, PartitionKey::from("pk-value"), "doc1");
     /// let result = driver
@@ -822,7 +822,7 @@ impl CosmosOperation {
     ///     "my-key",
     /// );
     /// let driver = runtime.create_driver(DriverOptions::builder(account).build()).await?;
-    /// let container = driver.resolve_container("my-database", "my-container").await?;
+    /// let container = driver.resolve_container("my-database", "my-container", OperationOptions::default()).await?;
     ///
     /// let item = ItemReference::from_name(&container, PartitionKey::from("pk-value"), "doc1");
     /// let result = driver
diff --git a/sdk/cosmos/azure_data_cosmos_driver/tests/framework/test_client.rs b/sdk/cosmos/azure_data_cosmos_driver/tests/framework/test_client.rs
index 1aa660f5449..d5565facea2 100644
--- a/sdk/cosmos/azure_data_cosmos_driver/tests/framework/test_client.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver/tests/framework/test_client.rs
@@ -796,7 +796,7 @@ impl DriverTestRunContext {
         let mut last_err_msg: Option<String> = None;
         for _ in 0..12 {
             match driver
-                .resolve_container_by_name(db_name, container_name)
+                .resolve_container_by_name(db_name, container_name, OperationOptions::default())
                 .await
             {
                 Ok(c) => return Ok(c),
diff --git a/sdk/cosmos/azure_data_cosmos_driver/tests/gateway_query_plan_comparison.rs b/sdk/cosmos/azure_data_cosmos_driver/tests/gateway_query_plan_comparison.rs
index d218f9bbaaf..252dcfd7cb5 100644
--- a/sdk/cosmos/azure_data_cosmos_driver/tests/gateway_query_plan_comparison.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver/tests/gateway_query_plan_comparison.rs
@@ -107,7 +107,7 @@ async fn ensure_container(
     }
 
     driver
-        .resolve_container(DB_NAME, container_name)
+        .resolve_container(DB_NAME, container_name, OperationOptions::default())
         .await
         .expect("failed to resolve container")
 }
diff --git a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/excluded_regions_fallback.rs b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/excluded_regions_fallback.rs
index ee707fa37d4..de0b545d942 100644
--- a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/excluded_regions_fallback.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/excluded_regions_fallback.rs
@@ -124,7 +124,7 @@ async fn dataplane_excluded_all_preferred_multi_master_falls_back_to_hub() {
         .expect("driver should initialize");
 
     let container = driver
-        .resolve_container("testdb", "testcoll")
+        .resolve_container("testdb", "testcoll", OperationOptions::default())
         .await
         .expect("container should resolve");
 
@@ -196,7 +196,7 @@ async fn dataplane_excluded_all_preferred_single_master_falls_back_to_hub() {
         .expect("driver should initialize");
 
     let container = driver
-        .resolve_container("testdb", "testcoll")
+        .resolve_container("testdb", "testcoll", OperationOptions::default())
         .await
         .expect("container should resolve");
 
diff --git a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/hedging.rs b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/hedging.rs
index eae8e6fce9b..4be6ee3880d 100644
--- a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/hedging.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/hedging.rs
@@ -256,7 +256,7 @@ async fn read_item_hedge_diagnostics(
     pk: &str,
 ) -> Option<HedgeDiagnostics> {
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves");
 
@@ -290,7 +290,7 @@ async fn read_item_result(
     azure_data_cosmos_driver::error::CosmosError,
 > {
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves");
 
@@ -562,7 +562,7 @@ async fn hedging_write_not_hedged() {
     let (driver, op_options) = make_hedging_driver(&ctx, Duration::from_millis(100), rules).await;
 
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves");
     let item_ref = ItemReference::from_name(&container, PartitionKey::from("pk1"), "wpk-1");
diff --git a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/metadata_hedging.rs b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/metadata_hedging.rs
index 1335ba88583..4561aef9f17 100644
--- a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/metadata_hedging.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/metadata_hedging.rs
@@ -392,7 +392,7 @@ async fn metadata_pk_range_read_hedges_cold_then_pins_to_the_winner() {
     let driver = make_driver(&ctx, vec![Arc::clone(&east_pk), Arc::clone(&west_pk)]).await;
 
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves");
 
diff --git a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/metadata_hedging_stress.rs b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/metadata_hedging_stress.rs
index cb16e3bcc6e..991d4012b04 100644
--- a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/metadata_hedging_stress.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/metadata_hedging_stress.rs
@@ -566,7 +566,7 @@ async fn scenario_cold_start(ctx: &MultiRegionTestContext, cfg: &StressConfig) -
 
             let started = Instant::now();
             let container = driver
-                .resolve_container_by_name(DB_NAME, COLL_NAME)
+                .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
                 .await
                 .expect("container resolves");
             let _ = driver
@@ -652,7 +652,7 @@ async fn scenario_pk_range_cold_chain(
                 .await
                 .expect("driver initializes");
             let container = driver
-                .resolve_container_by_name(DB_NAME, COLL_NAME)
+                .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
                 .await
                 .expect("container resolves");
             recorder.record(timed_pk_range_read(&driver, &container).await);
@@ -777,7 +777,7 @@ async fn scenario_mixed_workload(ctx: &MultiRegionTestContext, cfg: &StressConfi
             .await
             .expect("driver initializes");
         let container = driver
-            .resolve_container_by_name(DB_NAME, COLL_NAME)
+            .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
             .await
             .expect("container resolves");
 
diff --git a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/regional_gateway_unreachable.rs b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/regional_gateway_unreachable.rs
index 3f20e71d881..e7f1fb0b41b 100644
--- a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/regional_gateway_unreachable.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/regional_gateway_unreachable.rs
@@ -152,7 +152,7 @@ async fn build_fixture_with_failover(
         .expect("driver initializes against emulator metadata");
 
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves");
 
diff --git a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/throttling.rs b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/throttling.rs
index 637ba1a6462..9599f822a53 100644
--- a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/throttling.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/throttling.rs
@@ -533,7 +533,7 @@ async fn fault_injection_429_honors_configurable_throttle_retry_count() {
             .expect("driver should initialize against the in-memory emulator");
 
         let container = driver
-            .resolve_container_by_name("testdb", "testcoll")
+            .resolve_container_by_name("testdb", "testcoll", OperationOptions::default())
             .await
             .expect("container should resolve");
 
diff --git a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/topology_refresh_on_substatus.rs b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/topology_refresh_on_substatus.rs
index 86158ce84f3..a60bc1259b6 100644
--- a/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/topology_refresh_on_substatus.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver/tests/in_memory_emulator_tests/topology_refresh_on_substatus.rs
@@ -90,7 +90,7 @@ async fn build_driver_with_faults(
 /// Seeds a known item via the driver under default options.
 async fn seed_item_via_driver(driver: &CosmosDriver, item_id: &str) {
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves for seeding");
     let item_ref = ItemReference::from_name(
@@ -142,7 +142,7 @@ async fn read_item(
     azure_data_cosmos_driver::error::CosmosError,
 > {
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves");
     let item_ref = ItemReference::from_name(
@@ -167,7 +167,7 @@ async fn create_item(
     azure_data_cosmos_driver::error::CosmosError,
 > {
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves");
     let item_ref = ItemReference::from_name(
@@ -195,7 +195,7 @@ async fn upsert_item(
     azure_data_cosmos_driver::error::CosmosError,
 > {
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves");
     let item_ref = ItemReference::from_name(
@@ -727,7 +727,7 @@ async fn write_403_3_retry_honors_excluded_region() {
     recorder.clear();
 
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves");
     let item_ref = ItemReference::from_name(
@@ -787,7 +787,7 @@ async fn create_item_403_1008_retry_honors_excluded_region() {
     recorder.clear();
 
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves");
     let item_ref = ItemReference::from_name(
@@ -850,7 +850,7 @@ async fn metadata_refresh_ignores_excluded_regions() {
     recorder.clear();
 
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves");
     let item_ref = ItemReference::from_name(
@@ -936,7 +936,7 @@ async fn metadata_refresh_regional_fallback_ignores_excluded_regions() {
     metadata_rule.enable();
 
     let container = driver
-        .resolve_container_by_name(DB_NAME, COLL_NAME)
+        .resolve_container_by_name(DB_NAME, COLL_NAME, OperationOptions::default())
         .await
         .expect("container resolves");
     let item_ref = ItemReference::from_name(
diff --git a/sdk/cosmos/azure_data_cosmos_driver/tests/multi_region_failover.rs b/sdk/cosmos/azure_data_cosmos_driver/tests/multi_region_failover.rs
index 98784aed0e3..95b3d0c09c8 100644
--- a/sdk/cosmos/azure_data_cosmos_driver/tests/multi_region_failover.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver/tests/multi_region_failover.rs
@@ -288,7 +288,7 @@ async fn create_unique_db_and_container(
         return Err(format!("create container failed, status: {container_status:?}").into());
     }
     let container_ref = driver
-        .resolve_container_by_name(&db_name, &container_name)
+        .resolve_container_by_name(&db_name, &container_name, OperationOptions::default())
         .await?;
     Ok((db_ref, container_ref))
 }
diff --git a/sdk/cosmos/azure_data_cosmos_driver_native/src/container_ref.rs b/sdk/cosmos/azure_data_cosmos_driver_native/src/container_ref.rs
index 1d53246bbda..d9963cd89fb 100644
--- a/sdk/cosmos/azure_data_cosmos_driver_native/src/container_ref.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver_native/src/container_ref.rs
@@ -32,7 +32,9 @@
 use std::ffi::{c_char, CStr};
 use std::sync::Arc;
 
-use azure_data_cosmos_driver::models::ContainerReference as DriverContainerReference;
+use azure_data_cosmos_driver::{
+    models::ContainerReference as DriverContainerReference, options::OperationOptions,
+};
 
 use crate::driver::DriverHandle;
 use crate::error::{CosmosError, CosmosErrorCode, CosmosStatusCode};
@@ -159,7 +161,7 @@ pub extern "C" fn cosmos_driver_resolve_container_blocking(
     let driver_arc = Arc::clone(&driver_inner.inner);
     let result = runtime_inner.tokio.block_on(async move {
         driver_arc
-            .resolve_container_by_name(&db_id, &container_id)
+            .resolve_container_by_name(&db_id, &container_id, OperationOptions::default())
             .await
     });
 
diff --git a/sdk/cosmos/azure_data_cosmos_driver_native/src/submit.rs b/sdk/cosmos/azure_data_cosmos_driver_native/src/submit.rs
index a9849e319f1..b1ca13ce2d6 100644
--- a/sdk/cosmos/azure_data_cosmos_driver_native/src/submit.rs
+++ b/sdk/cosmos/azure_data_cosmos_driver_native/src/submit.rs
@@ -26,9 +26,9 @@ use std::any::Any;
 use std::future::Future;
 use std::sync::Arc;
 
-use azure_data_cosmos_driver::driver::CosmosDriver;
 use azure_data_cosmos_driver::models::{AccountReference, ContainerReference, CosmosResponse};
 use azure_data_cosmos_driver::options::DriverOptions;
+use azure_data_cosmos_driver::{driver::CosmosDriver, options::OperationOptions};
 
 use crate::account_ref::AccountRefHandle;
 use crate::completion::{
@@ -628,7 +628,7 @@ pub extern "C" fn cosmos_driver_resolve_container_submit(
         task_runtime,
         async move {
             driver_arc
-                .resolve_container_by_name(&db_id, &container_id)
+                .resolve_container_by_name(&db_id, &container_id, OperationOptions::default())
                 .await
         },
         |container_ref: azure_data_cosmos_driver::models::ContainerReference| {
diff --git a/sdk/cosmos/azure_data_cosmos_emulator/src/gateway_v2.rs b/sdk/cosmos/azure_data_cosmos_emulator/src/gateway_v2.rs
index 04b72c55bd8..615aed8c83a 100644
--- a/sdk/cosmos/azure_data_cosmos_emulator/src/gateway_v2.rs
+++ b/sdk/cosmos/azure_data_cosmos_emulator/src/gateway_v2.rs
@@ -276,7 +276,10 @@ mod tests {
             .create_driver(DriverOptions::builder(account).build())
             .await
             .unwrap();
-        let container = driver.resolve_container("db", "coll").await.unwrap();
+        let container = driver
+            .resolve_container("db", "coll", OperationOptions::default())
+            .await
+            .unwrap();
         let item =
             ItemReference::from_name(&container, PartitionKey::from("pk1"), "item1".to_owned());
         let response = driver
diff --git a/sdk/cosmos/azure_data_cosmos_observability_harness/src/workload.rs b/sdk/cosmos/azure_data_cosmos_observability_harness/src/workload.rs
index fb9a47a2846..3db3e730c92 100644
--- a/sdk/cosmos/azure_data_cosmos_observability_harness/src/workload.rs
+++ b/sdk/cosmos/azure_data_cosmos_observability_harness/src/workload.rs
@@ -489,7 +489,7 @@ async fn ensure_container(
     container_name: &str,
     throughput: usize,
 ) -> Result<ContainerClient, Box<dyn Error>> {
-    match db_client.container_client(container_name).await {
+    match db_client.container_client(container_name, None).await {
         Ok(container) => match container.read(None).await {
             Ok(_) => {
                 println!("Container '{container_name}' already exists.");
@@ -513,7 +513,7 @@ async fn ensure_container(
 
     let mut backoff = INITIAL_BACKOFF;
     for attempt in 1..=MAX_SETUP_RETRIES {
-        match db_client.container_client(container_name).await {
+        match db_client.container_client(container_name, None).await {
             Ok(container) => match container.read(None).await {
                 Ok(_) => {
                     println!("Container '{container_name}' confirmed readable.");
diff --git a/sdk/cosmos/azure_data_cosmos_perf/src/setup.rs b/sdk/cosmos/azure_data_cosmos_perf/src/setup.rs
index 6b0e2e8c512..5d2904464b8 100644
--- a/sdk/cosmos/azure_data_cosmos_perf/src/setup.rs
+++ b/sdk/cosmos/azure_data_cosmos_perf/src/setup.rs
@@ -35,7 +35,7 @@ pub async fn ensure_container(
     // not a constructor — it surfaces the same 404 that `read` would,
     // so we have to branch on the error here instead of unconditionally
     // `?`-propagating it (which would short-circuit the create path).
-    match db_client.container_client(container_name).await {
+    match db_client.container_client(container_name, None).await {
         Ok(container_client) => match container_client.read(None).await {
             Ok(_) => {
                 println!("Container '{container_name}' already exists.");
@@ -76,7 +76,7 @@ pub async fn ensure_container(
     let mut backoff = INITIAL_BACKOFF;
 
     for attempt in 1..=MAX_RETRIES {
-        match db_client.container_client(container_name).await {
+        match db_client.container_client(container_name, None).await {
             Ok(container_client) => match container_client.read(None).await {
                 Ok(_) => {
                     println!("Container '{container_name}' confirmed readable.");
diff --git a/sdk/cosmos/azure_data_cosmos_perf/tests/binary_sampled_testdata.rs b/sdk/cosmos/azure_data_cosmos_perf/tests/binary_sampled_testdata.rs
index 2ce032819fd..a8b9890acf0 100644
--- a/sdk/cosmos/azure_data_cosmos_perf/tests/binary_sampled_testdata.rs
+++ b/sdk/cosmos/azure_data_cosmos_perf/tests/binary_sampled_testdata.rs
@@ -277,7 +277,7 @@ async fn binary_round_trips_sampled_testdata() -> Result<(), Box<dyn Error>> {
             )
             .await,
     )?;
-    let container = db_client.container_client(&container_name).await?;
+    let container = db_client.container_client(&container_name, None).await?;
 
     let mut rng = rand::rng();
     let sampled: Vec<Map<String, Value>> = (0..SAMPLE_COUNT)