keylimectl: Use API v3.0 when --push-model is passed

Use the API version v3.0 for verifier requests when --push-model is
passed.

Signed-off-by: Anderson Toshiyuki Sasaki <[email protected]>

Author: ansasaki

keylimectl/src/client/verifier.rs

@@ -159,12 +159,16 @@ pub struct VerifierClient {
 #[derive(Debug)]
 pub struct VerifierClientBuilder<'a> {
     config: Option<&'a Config>,
+    override_api_version: Option<String>,
 }
 
 impl<'a> VerifierClientBuilder<'a> {
     /// Create a new builder instance
     pub fn new() -> Self {
-        Self { config: None }
+        Self {
+            config: None,
+            override_api_version: None,
+        }
     }
 
     /// Set the configuration for the client
@@ -173,19 +177,40 @@ impl<'a> VerifierClientBuilder<'a> {
         self
     }
 
+    /// Override the API version after detection
+    ///
+    /// This allows you to override the detected API version for specific
+    /// operations while still benefiting from detection for component
+    /// discovery. Useful for push-model where verifier needs v3.0 but
+    /// other components may use different versions.
+    pub fn override_api_version(mut self, version: &str) -> Self {
+        self.override_api_version = Some(version.to_string());
+        self
+    }
+
     /// Build the VerifierClient with automatic API version detection
     ///
     /// This is the recommended way to create a client for production use,
     /// as it will automatically detect the optimal API version supported
     /// by the verifier service.
+    ///
+    /// If `override_api_version()` was called, the detected version will
+    /// be overridden after detection completes.
     pub async fn build(self) -> Result<VerifierClient, KeylimectlError> {
         let config = self.config.ok_or_else(|| {
             KeylimectlError::validation(
                 "Configuration is required for VerifierClient",
             )
         })?;
 
-        VerifierClient::new(config).await
+        let mut client = VerifierClient::new(config).await?;
+
+        // Override API version if specified
+        if let Some(version) = self.override_api_version {
+            client.api_version = version;
+        }
+
+        Ok(client)
     }
 }
 
@@ -1965,6 +1990,32 @@ mod tests {
             assert_eq!(client.api_version, "3.0");
         }
 
+        #[tokio::test]
+        async fn test_builder_override_api_version() {
+            let config = create_test_config();
+            let client = VerifierClient::builder()
+                .config(&config)
+                .override_api_version("3.0")
+                .build()
+                .await;
+
+            assert!(client.is_ok());
+            let client = client.unwrap();
+            // Should use the overridden version
+            assert_eq!(client.api_version, "3.0");
+        }
+
+        #[tokio::test]
+        async fn test_builder_without_override() {
+            let config = create_test_config();
+            let client =
+                VerifierClient::builder().config(&config).build().await;
+
+            // This will fail to connect but we can check the structure
+            // In a real scenario, it would detect the version
+            assert!(client.is_ok() || client.is_err());
+        }
+
         #[test]
         fn test_base_url_construction_with_different_versions() {
             let config = create_test_config();

keylimectl/src/commands/agent.rs

@@ -774,23 +774,36 @@ async fn add_agent(
     // Step 2: Determine API version and enrollment approach
     output.step(2, 4, "Detecting verifier API version");
 
-    let verifier_client = VerifierClient::builder()
-        .config(config)
-        .build()
-        .await
-        .map_err(|e| {
+    // Build verifier client with detection, then override to v3.0 if push_model is set
+    let mut verifier_client_builder =
+        VerifierClient::builder().config(config);
+
+    // For push model, we need to use API v3.0 for verifier requests
+    if params.push_model {
+        verifier_client_builder =
+            verifier_client_builder.override_api_version("3.0");
+    }
+
+    let verifier_client =
+        verifier_client_builder.build().await.map_err(|e| {
             CommandError::resource_error("verifier", e.to_string())
         })?;
 
     let api_version =
         verifier_client.api_version().parse::<f32>().unwrap_or(2.1);
 
     // Use push model if explicitly requested via --push-model flag
-    // This skips direct agent communication but still uses the detected API version
-    // for verifier requests
+    // This skips direct agent communication and uses API v3.0 for verifier requests
     let is_push_model = params.push_model;
 
-    debug!("Detected API version: {api_version}, using push model: {is_push_model}");
+    debug!(
+        "Detected API version: {}, using API version: {api_version}, push model: {is_push_model}",
+        if is_push_model {
+            "auto-detected (overridden to 3.0)"
+        } else {
+            &format!("{api_version}")
+        }
+    );
 
     // Determine agent connection details (needed for pull model)
     let (agent_ip, agent_port) = if !is_push_model {