Lightweight coding agent that runs in your terminal
Rust
Add cancellation for native user-verification RPCs (#43925)
riley-oai82d4a989124d
diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zstindex 397ba2f016..400ef070be 100644Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst differdiff --git a/codex-rs/app-server-protocol/src/protocol/common.rs b/codex-rs/app-server-protocol/src/protocol/common.rsindex 005e14a3ca..947f2bfb0b 100644--- a/codex-rs/app-server-protocol/src/protocol/common.rs+++ b/codex-rs/app-server-protocol/src/protocol/common.rs@@ -546,6 +546,13 @@ client_request_definitions! {response: v2::UserVerificationVerifyResponse,},+ #[experimental("userVerification/cancel")]+ UserVerificationCancel => "userVerification/cancel" {+ params: v2::UserVerificationCancelParams,+ serialization: None,+ response: v2::UserVerificationCancelResponse,+ },+/// NEW APIs// Thread lifecycle// Uses `inspect_params` because only some fields are experimental.diff --git a/codex-rs/app-server-protocol/src/protocol/v2/user_verification.rs b/codex-rs/app-server-protocol/src/protocol/v2/user_verification.rsindex 93ad4b8d7c..99321969d4 100644--- a/codex-rs/app-server-protocol/src/protocol/v2/user_verification.rs+++ b/codex-rs/app-server-protocol/src/protocol/v2/user_verification.rs@@ -2,6 +2,7 @@//! Native implementation and registration transport are independent of these contracts.use crate::JsonSchema;+use crate::RequestId;use crate::TS;use serde::Deserialize;use serde::Serialize;@@ -145,6 +146,22 @@ pub struct UserVerificationVerifyResponse {pub proof: UserVerificationProof,}+/// Cancels a native verification RPC issued on this connection, not an elicitation.+/// Use a fresh request ID for each operation and a distinct ID for this cancellation RPC.+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)]+#[serde(rename_all = "camelCase", deny_unknown_fields)]+#[ts(export_to = "v2/")]+pub struct UserVerificationCancelParams {+ pub request_id: RequestId,+}++/// Acknowledges the cancellation signal; native work may still be finishing.+/// Unknown or finished requests are a no-op, and completed effects are not rolled back.+#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq, Eq, JsonSchema, TS)]+#[serde(rename_all = "camelCase")]+#[ts(export_to = "v2/")]+pub struct UserVerificationCancelResponse {}+#[cfg(test)]#[path = "user_verification_tests.rs"]mod tests;diff --git a/codex-rs/app-server/README.md b/codex-rs/app-server/README.mdindex 2b9d476b67..80aede118c 100644--- a/codex-rs/app-server/README.md+++ b/codex-rs/app-server/README.md@@ -1,3 +1,27 @@+# User verification cancellation (experimental)++Local UI clients can cancel a native user-verification RPC by sending+`userVerification/cancel` with `{requestId}` and the `experimentalApi` opt-in.+The result is an empty acknowledgment (`{}`). This API does not enable desktop+verification capability advertisement.++`requestId` is the original status, enroll, delete, or verify RPC's string or+integer ID on the same connection, not the server elicitation ID. Use fresh IDs+for each operation and a distinct ID for the cancel RPC. Unknown, finished,+unrelated, and other-connection requests are no-ops.++The acknowledgment confirms the cancellation signal without waiting for the OS+prompt to close. The original RPC completes independently, with+`cancelled/interrupted` when cancellation prevents completion. Cancellation+cannot roll back completed effects. It remains effective while a proof waits for+outbound queue capacity, but cannot retract a response already enqueued.++Canceling or resolving an elicitation does not itself stop a separate+`userVerification/verify` RPC. Clients must cancel that RPC separately and discard+late proofs after the approval is canceled or resolved. Only one native worker+runs per app-server; if an OS call remains active after cancellation or timeout,+subsequent local operations return `failed/providerError` until that worker exits.+# Thread removal`thread/archive` and `thread/delete` reject attempts to remove a live internaldiff --git a/codex-rs/app-server/src/message_processor.rs b/codex-rs/app-server/src/message_processor.rsindex c462bb738f..aff6d9ad6c 100644--- a/codex-rs/app-server/src/message_processor.rs+++ b/codex-rs/app-server/src/message_processor.rs@@ -70,6 +70,7 @@ use codex_app_server_protocol::JSONRPCErrorError;use codex_app_server_protocol::JSONRPCNotification;use codex_app_server_protocol::JSONRPCRequest;use codex_app_server_protocol::JSONRPCResponse;+use codex_app_server_protocol::UserVerificationCancelResponse;use codex_app_server_protocol::experimental_required_message;use codex_arg0::Arg0DispatchPaths;use codex_code_mode::CodeModeSessionProvider;@@ -631,7 +632,12 @@ impl MessageProcessor {traceparent: trace.traceparent.clone(),tracestate: trace.tracestate.clone(),});- let request_context = RequestContext::new(request_id.clone(), request_span, request_trace);+ let request_context = RequestContext::new(+ request_id.clone(),+ request_method,+ request_span,+ request_trace,+ );Self::run_request_with_context(Arc::clone(&self.outgoing),request_context.clone(),@@ -680,8 +686,12 @@ impl MessageProcessor {};let request_span =crate::app_server_tracing::typed_request_span(&request, connection_id, &session);- let mut request_context =- RequestContext::new(request_id.clone(), request_span, /*parent_trace*/ None);+ let mut request_context = RequestContext::new(+ request_id.clone(),+ request.method_name(),+ request_span,+ /*parent_trace*/ None,+ );request_context.cancellation = cancellation;tracing::trace!(?connection_id,@@ -995,6 +1005,15 @@ impl MessageProcessor {ClientRequest::Initialize { .. } => {panic!("Initialize should be handled before initialized request dispatch");}+ ClientRequest::UserVerificationCancel { params, .. } => {+ self.outgoing+ .cancel_user_verification_request(&ConnectionRequestId {+ connection_id,+ request_id: params.request_id,+ })+ .await;+ Ok(Some(UserVerificationCancelResponse {}.into()))+ }request @ (ClientRequest::UserVerificationStatus { .. }| ClientRequest::UserVerificationEnroll { .. }| ClientRequest::UserVerificationDelete { .. }diff --git a/codex-rs/app-server/src/outgoing_message.rs b/codex-rs/app-server/src/outgoing_message.rsindex 5c20dad5d7..ec84a83262 100644--- a/codex-rs/app-server/src/outgoing_message.rs+++ b/codex-rs/app-server/src/outgoing_message.rs@@ -56,26 +56,40 @@ pub(crate) struct ConnectionRequestId {pub(crate) request_id: RequestId,}-/// Trace data we keep for an incoming request until we send its final-/// response or error.+/// Trace data and cancellation state retained until an incoming request's final response or error.#[derive(Clone)]pub(crate) struct RequestContext {request_id: ConnectionRequestId,pub(crate) cancellation: tokio_util::sync::CancellationToken,+ cancellation_scope: RequestCancellationScope,span: Span,parent_trace: Option<W3cTraceContext>,_diagnostics_guard: Arc<GaugeGuard>,}+#[derive(Clone, Copy, PartialEq, Eq)]+enum RequestCancellationScope {+ Unavailable,+ UserVerification,+}+impl RequestContext {pub(crate) fn new(request_id: ConnectionRequestId,+ method: &str,span: Span,parent_trace: Option<W3cTraceContext>,) -> Self {Self {request_id,cancellation: tokio_util::sync::CancellationToken::new(),+ cancellation_scope: match method {+ "userVerification/status"+ | "userVerification/enroll"+ | "userVerification/delete"+ | "userVerification/verify" => RequestCancellationScope::UserVerification,+ _ => RequestCancellationScope::Unavailable,+ },span,parent_trace,_diagnostics_guard: Arc::new(IN_FLIGHT_REQUESTS.track()),@@ -253,6 +267,15 @@ impl OutgoingMessageSender {}}+ pub(crate) async fn cancel_user_verification_request(&self, request_id: &ConnectionRequestId) {+ let contexts = self.request_contexts.lock().await;+ if let Some(context) = contexts.get(request_id)+ && context.cancellation_scope == RequestCancellationScope::UserVerification+ {+ context.cancellation.cancel();+ }+ }+pub(crate) async fn connection_closed(&self, connection_id: ConnectionId) {self.disconnect_user_verification_connection(connection_id).await;@@ -648,8 +671,10 @@ impl OutgoingMessageSender {response: ClientResponsePayload,check: impl FnOnce() -> std::result::Result<(), JSONRPCErrorError>,) {+ // Remain cancellable while waiting to deliver a proof, including after native work ends.+ let permit = self.sender.reserve().await;let _context = self.take_request_context(&request_id).await;- let Ok(permit) = self.sender.reserve().await else {+ let Ok(permit) = permit else {return;};let message = match check() {@@ -877,6 +902,10 @@ fn timestamped_server_notification(notification: ServerNotification) -> Outgoing#[path = "user_verification_ownership_tests.rs"]mod user_verification_ownership_tests;+#[cfg(test)]+#[path = "user_verification_cancel_context_tests.rs"]+mod user_verification_cancel_context_tests;+#[cfg(test)]mod tests {use std::time::Duration;@@ -1257,6 +1286,7 @@ mod tests {outgoing.register_request_context(RequestContext::new(request_id.clone(),+ "thread/start",tracing::info_span!("app_server.request", rpc.method = "thread/start"),/*parent_trace*/ None,))@@ -1416,6 +1446,7 @@ mod tests {outgoing.register_request_context(RequestContext::new(closed_connection_request,+ "turn/interrupt",tracing::info_span!("app_server.request", rpc.method = "turn/interrupt"),/*parent_trace*/ None,))@@ -1423,6 +1454,7 @@ mod tests {outgoing.register_request_context(RequestContext::new(open_connection_request,+ "turn/start",tracing::info_span!("app_server.request", rpc.method = "turn/start"),/*parent_trace*/ None,))diff --git a/codex-rs/app-server/src/user_verification.rs b/codex-rs/app-server/src/user_verification.rsindex 2345ffe5c4..95c36e96b5 100644--- a/codex-rs/app-server/src/user_verification.rs+++ b/codex-rs/app-server/src/user_verification.rs@@ -253,6 +253,10 @@ mod tests;#[path = "user_verification_rpc_tests.rs"]mod rpc_tests;+#[cfg(test)]+#[path = "user_verification_cancel_tests.rs"]+mod cancel_tests;+#[cfg(test)]#[path = "user_verification_test_support.rs"]mod test_support;diff --git a/codex-rs/app-server/src/user_verification_cancel_context_tests.rs b/codex-rs/app-server/src/user_verification_cancel_context_tests.rsnew file mode 100644index 0000000000..0b571e2f0d--- /dev/null+++ b/codex-rs/app-server/src/user_verification_cancel_context_tests.rs@@ -0,0 +1,126 @@+//! Checks cancellation ownership and the lifetime of proofs waiting for outbound capacity.++use super::*;+use codex_app_server_protocol::UserVerificationDeleteResponse;+use codex_app_server_protocol::UserVerificationProof;+use codex_app_server_protocol::UserVerificationVerifyResponse;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn user_verification_cancel_only_signals_matching_native_request_contexts() {+ let (tx, _rx) = mpsc::channel(/*buffer*/ 1);+ let outgoing = OutgoingMessageSender::new(tx, AnalyticsEventsClient::disabled());+ for method in [+ "userVerification/status",+ "userVerification/enroll",+ "userVerification/delete",+ "userVerification/verify",+ "userVerification/cancel",+ "turn/start",+ ] {+ let target = ConnectionRequestId {+ connection_id: ConnectionId(1),+ request_id: RequestId::Integer(7),+ };+ let context = RequestContext::new(+ target.clone(),+ method,+ Span::none(),+ /*parent_trace*/ None,+ );+ let cancellation = context.cancellation.clone();+ outgoing.register_request_context(context).await;+ for wrong_target in [+ ConnectionRequestId {+ connection_id: ConnectionId(2),+ request_id: RequestId::Integer(7),+ },+ ConnectionRequestId {+ connection_id: ConnectionId(1),+ request_id: RequestId::String("7".into()),+ },+ ConnectionRequestId {+ connection_id: ConnectionId(1),+ request_id: RequestId::Integer(8),+ },+ ] {+ outgoing+ .cancel_user_verification_request(&wrong_target)+ .await;+ assert!(!cancellation.is_cancelled());+ }+ outgoing.cancel_user_verification_request(&target).await;+ outgoing.cancel_user_verification_request(&target).await;+ assert_eq!(+ cancellation.is_cancelled(),+ method != "turn/start" && method != "userVerification/cancel"+ );+ assert_eq!(outgoing.request_context_count().await, 1);+ outgoing.connection_closed(ConnectionId(1)).await;+ assert_eq!(outgoing.request_context_count().await, 0);+ }+}++#[tokio::test]+async fn user_verification_cancel_remains_effective_until_proof_enqueue_and_cleans_up() {+ for close_receiver in [false, true] {+ let (tx, mut rx) = mpsc::channel(/*buffer*/ 1);+ let outgoing = OutgoingMessageSender::new(tx, AnalyticsEventsClient::disabled());+ let target = ConnectionRequestId {+ connection_id: ConnectionId(1),+ request_id: RequestId::String("verify".into()),+ };+ outgoing+ .send_response(target.clone(), UserVerificationDeleteResponse {})+ .await;+ let context = RequestContext::new(+ target.clone(),+ "userVerification/verify",+ Span::none(),+ /*parent_trace*/ None,+ );+ let cancellation = context.cancellation.clone();+ outgoing.register_request_context(context).await;+ let response = UserVerificationVerifyResponse {+ proof: UserVerificationProof {+ credential_id: "AQ".into(),+ signature: "Ag".into(),+ },+ };+ let error = internal_error("canceled proof");+ let expected_error = error.clone();+ let sending =+ outgoing.send_response_as_checked(target.clone(), response.into(), move || {+ if cancellation.is_cancelled() {+ Err(error)+ } else {+ Ok(())+ }+ });+ let mut sending = std::pin::pin!(sending);+ assert!(matches!(+ futures::poll!(&mut sending),+ std::task::Poll::Pending+ ));+ assert_eq!(outgoing.request_context_count().await, 1);+ outgoing.cancel_user_verification_request(&target).await;+ if close_receiver {+ rx.close();+ } else {+ rx.recv().await.unwrap();+ }+ sending.await;+ assert_eq!(outgoing.request_context_count().await, 0);+ if !close_receiver {+ let OutgoingEnvelope::ToConnection {+ message: OutgoingMessage::Error(error),+ ..+ } = rx.recv().await.unwrap()+ else {+ panic!("a proof canceled while queued must not be sent")+ };+ assert_eq!(error.id, target.request_id);+ assert_eq!(error.error, expected_error);+ }+ }+}diff --git a/codex-rs/app-server/src/user_verification_cancel_tests.rs b/codex-rs/app-server/src/user_verification_cancel_tests.rsnew file mode 100644index 0000000000..a284e1a0fb--- /dev/null+++ b/codex-rs/app-server/src/user_verification_cancel_tests.rs@@ -0,0 +1,172 @@+//! Checks that client RPC cancellation reaches native work without owning an elicitation.++use super::test_support::Harness;+use super::*;+use crate::outgoing_message::ConnectionId;+use crate::outgoing_message::ConnectionRequestId;+use crate::outgoing_message::OutgoingEnvelope;+use crate::outgoing_message::OutgoingMessage;+use anyhow::Result;+use pretty_assertions::assert_eq;+use serde_json::json;+use std::sync::atomic::Ordering;++fn assert_cancelled(message: OutgoingMessage) {+ let OutgoingMessage::Error(error) = message else {+ panic!("canceled verification must not return a proof")+ };+ assert_eq!(error.id, rpc::RequestId::Integer(1));+ assert_eq!(+ error.error,+ rpc::JSONRPCErrorError {+ code: -32603,+ message: "User verification was cancelled.".into(),+ data: Some(json!({"type": "cancelled", "reason": "interrupted"})),+ }+ );+}++#[tokio::test]+async fn user_verification_cancel_rpc_stops_native_work_and_allows_another_operation() -> Result<()>+{+ let mut h = Harness::new(ConnectionOrigin::Stdio, || true).await?;+ h.initialize("Codex Desktop", /*opt_in*/ true).await;+ h.start_verify().await?;+ h.send(+ /*id*/ 2,+ "userVerification/cancel",+ json!({"requestId": 1}),+ )+ .await;+ for _ in 0..2 {+ let message = h.response().await;+ if let OutgoingMessage::Response(response) = message {+ assert_eq!(response.id, rpc::RequestId::Integer(2));+ assert_eq!(serde_json::to_value(response.result)?, json!({}));+ } else {+ assert_cancelled(message);+ }+ }+ assert_eq!(h.service.worker.available_permits(), 1);+ // Repeated and already-finished cancellation must not cancel the next operation.+ h.send(+ /*id*/ 3,+ "userVerification/cancel",+ json!({"requestId": 1}),+ )+ .await;+ assert!(matches!(h.response().await, OutgoingMessage::Response(_)));+ h.send(/*id*/ 4, "userVerification/status", json!({})).await;+ let OutgoingMessage::Response(response) = h.response().await else {+ panic!("the next native operation must remain available")+ };+ assert_eq!(response.id, rpc::RequestId::Integer(4));+ h.shutdown().await;+ Ok(())+}++#[tokio::test]+async fn user_verification_cancel_is_registered_before_native_dispatch() -> Result<()> {+ let mut h = Harness::new(ConnectionOrigin::Stdio, || true).await?;+ h.initialize("Codex Desktop", /*opt_in*/ true).await;+ h.send(+ /*id*/ 1,+ "userVerification/verify",+ json!({"challenge": "AQ", "title": "Approve", "description": ""}),+ )+ .await;+ // This current-thread executor has not polled the spawned RPC handler yet.+ h.outgoing+ .cancel_user_verification_request(&ConnectionRequestId {+ connection_id: ConnectionId(1),+ request_id: rpc::RequestId::Integer(1),+ })+ .await;+ assert_cancelled(h.response().await);+ assert_eq!(h.provider.calls.load(Ordering::SeqCst), 0);+ h.shutdown().await;+ Ok(())+}++#[tokio::test]+async fn user_verification_cancel_rpc_cannot_target_another_connection_or_id_type() -> Result<()> {+ let mut h = Harness::new(ConnectionOrigin::Stdio, || true).await?;+ h.initialize("Codex Desktop", /*opt_in*/ true).await;+ h.start_verify().await?;+ h.send(+ /*id*/ 2,+ "userVerification/cancel",+ json!({"requestId": "1"}),+ )+ .await;+ assert!(matches!(h.response().await, OutgoingMessage::Response(_)));+ h.processor+ .process_request(+ ConnectionId(2),+ rpc::JSONRPCRequest {+ id: rpc::RequestId::Integer(3),+ method: "userVerification/cancel".into(),+ params: Some(json!({"requestId": 1})),+ trace: None,+ },+ &crate::transport::AppServerTransport::Stdio,+ Arc::clone(&h.session),+ )+ .await;+ let OutgoingEnvelope::ToConnection {+ connection_id,+ message: OutgoingMessage::Response(response),+ ..+ } = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), h.messages.recv())+ .await?+ .unwrap()+ else {+ panic!("another connection must only receive its own cancel acknowledgment")+ };+ assert_eq!(connection_id, ConnectionId(2));+ assert_eq!(response.id, rpc::RequestId::Integer(3));+ assert_eq!(h.service.worker.available_permits(), 0);+ h.outgoing+ .cancel_user_verification_request(&ConnectionRequestId {+ connection_id: ConnectionId(1),+ request_id: rpc::RequestId::Integer(1),+ })+ .await;+ assert_cancelled(h.response().await);+ h.shutdown().await;+ Ok(())+}++#[tokio::test]+async fn user_verification_cancel_keeps_the_worker_slot_until_native_exit() -> Result<()> {+ let mut h = Harness::new(ConnectionOrigin::Stdio, || true).await?;+ h.initialize("Codex Desktop", /*opt_in*/ true).await;+ h.provider+ .ignore_cancellation+ .store(/*val*/ true, Ordering::Release);+ h.start_verify().await?;+ h.send(+ /*id*/ 2,+ "userVerification/cancel",+ json!({"requestId": 1}),+ )+ .await;+ let OutgoingMessage::Response(response) = h.response().await else {+ panic!("cancel acknowledgment must not wait for the native worker")+ };+ assert_eq!(response.id, rpc::RequestId::Integer(2));+ assert_eq!(h.service.worker.available_permits(), 0);+ h.send(/*id*/ 3, "userVerification/status", json!({})).await;+ let OutgoingMessage::Error(error) = h.response().await else {+ panic!("the native worker must remain bounded")+ };+ assert_eq!(+ error.error.data,+ Some(json!({"type": "failed", "reason": "providerError"}))+ );+ h.provider.released.store(/*val*/ true, Ordering::Release);+ assert_cancelled(h.response().await);+ assert_eq!(h.service.worker.available_permits(), 1);+ h.shutdown().await;+ Ok(())+}diff --git a/codex-rs/app-server/src/user_verification_test_support.rs b/codex-rs/app-server/src/user_verification_test_support.rsindex 413be31d79..d382e9972b 100644--- a/codex-rs/app-server/src/user_verification_test_support.rs+++ b/codex-rs/app-server/src/user_verification_test_support.rs@@ -40,6 +40,7 @@ pub(super) struct BlockingProvider {pub(super) entered: Mutex<Option<oneshot::Sender<()>>>,pub(super) released: AtomicBool,pub(super) calls: AtomicUsize,+ pub(super) ignore_cancellation: AtomicBool,}impl native::UserVerificationProvider for BlockingProvider {@@ -77,7 +78,9 @@ impl native::UserVerificationProvider for BlockingProvider {}let deadline = std::time::Instant::now() + Duration::from_secs(/*secs*/ 10);while !self.released.load(Ordering::Acquire) {- guard.check()?;+ if !self.ignore_cancellation.load(Ordering::Acquire) {+ guard.check()?;+ }assert!(std::time::Instant::now() < deadline,"test failed to release native worker"diff --git a/codex-rs/app-server/tests/suite/v2/user_verification.rs b/codex-rs/app-server/tests/suite/v2/user_verification.rsindex 20a54a7fd8..a388cda5f4 100644--- a/codex-rs/app-server/tests/suite/v2/user_verification.rs+++ b/codex-rs/app-server/tests/suite/v2/user_verification.rs@@ -34,6 +34,7 @@ async fn user_verification_methods_require_experimental_opt_in() -> Result<()> {("userVerification/status", json!({})),("userVerification/enroll", json!({})),("userVerification/delete", json!({})),+ ("userVerification/cancel", json!({"requestId": 1})),("userVerification/verify",json!({"challenge": "AQ", "title": "Approve", "description": ""}),@@ -75,6 +76,49 @@ async fn user_verification_status_without_account_returns_local_readiness() -> ROk(())}+#[tokio::test]+async fn user_verification_cancel_stdio_validates_and_acknowledges_unknown_requests() -> Result<()>+{+ let mut app_server = TestAppServer::builder().build().await?;+ let id = app_server+ .send_raw_request(+ "userVerification/cancel",+ Some(json!({"requestId": "verify"})),+ )+ .await?;+ let error = app_server+ .read_stream_until_error_message(RequestId::Integer(id))+ .await?;+ assert_eq!(error.error.message, "Not initialized");+ app_server.initialize().await?;+ for params in [+ json!({}),+ json!({"requestId": null}),+ json!({"requestId": 1.5}),+ json!({"requestId": 1, "connectionId": 2}),+ ] {+ let id = app_server+ .send_raw_request("userVerification/cancel", Some(params))+ .await?;+ app_server+ .read_stream_until_error_message(RequestId::Integer(id))+ .await?;+ }+ for request_id in [json!(100), json!("100"), json!("100")] {+ let id = app_server+ .send_raw_request(+ "userVerification/cancel",+ Some(json!({"requestId": request_id})),+ )+ .await?;+ let response = app_server+ .read_stream_until_response_message(RequestId::Integer(id))+ .await?;+ assert_eq!(response.result, json!({}));+ }+ Ok(())+}+#[tokio::test]async fn user_verification_without_provider_returns_typed_unavailability() -> Result<()> {let mut app_server = TestAppServer::builder().build_initialized().await?;