Run cargo +nightly fmt

Choosing module granularity over item granularity is based on a similar
choice made in the standard library to balance readabilty, with easy to
read diffs.

This saves 2098 lines or about 33% of the lines spent writing imports.
This is beneficial to both human readers who have to scroll past large
import blocks when reading a file as well as codex which shouldn't have
to add as many tokens to its context.

Manual changes to rustfmt.toml, rust-ci.yml, justfile, docs/contributing
and docs/install. The actual format commit is intentionally in a second
commit to make it easier to rebase this PR as main moves (drop the
next commit and re-run cargo +nightly fmt).

Added cargo nightly to the ci and justfile. In theory this is unstable,
but in real world use this tends to hit a problems perhaps once every
6 months. The fix is usually fairly easy (pin a version briefly), and
the problems tend to be fixed pretty quickly.

.github/workflows/rust-ci.yml

@@ -57,11 +57,11 @@ jobs:
         working-directory: codex-rs
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.90
+      - uses: dtolnay/rust-toolchain@nightly
         with:
           components: rustfmt
       - name: cargo fmt
-        run: cargo fmt -- --config imports_granularity=Item --check
+        run: cargo +nightly fmt --check # nightly for unstable options in rustfmt.toml
       - name: Verify codegen for mcp-types
         run: ./mcp-types/check_lib_rs.py
 

codex-rs/ansi-escape/src/lib.rs

@@ -1,7 +1,5 @@
-use ansi_to_tui::Error;
-use ansi_to_tui::IntoText;
-use ratatui::text::Line;
-use ratatui::text::Text;
+use ansi_to_tui::{Error, IntoText};
+use ratatui::text::{Line, Text};
 
 // Expand tabs in a best-effort way for transcript rendering.
 // Tabs can interact poorly with left-gutter prefixes in our TUI and CLI

codex-rs/app-server-protocol/src/bin/export.rs

@@ -1,6 +1,7 @@
+use std::path::PathBuf;
+
 use anyhow::Result;
 use clap::Parser;
-use std::path::PathBuf;
 
 #[derive(Parser, Debug)]
 #[command(

codex-rs/app-server-protocol/src/export.rs

@@ -1,38 +1,25 @@
-use crate::ClientNotification;
-use crate::ClientRequest;
-use crate::ServerNotification;
-use crate::ServerRequest;
-use crate::export_client_notification_schemas;
-use crate::export_client_param_schemas;
-use crate::export_client_response_schemas;
-use crate::export_client_responses;
-use crate::export_server_notification_schemas;
-use crate::export_server_param_schemas;
-use crate::export_server_response_schemas;
-use crate::export_server_responses;
-use anyhow::Context;
-use anyhow::Result;
-use anyhow::anyhow;
-use codex_protocol::parse_command::ParsedCommand;
-use codex_protocol::protocol::EventMsg;
-use codex_protocol::protocol::FileChange;
-use codex_protocol::protocol::SandboxPolicy;
-use schemars::JsonSchema;
-use schemars::schema_for;
-use serde::Serialize;
-use serde_json::Map;
-use serde_json::Value;
-use std::collections::HashMap;
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::ffi::OsStr;
 use std::fs;
-use std::io::Read;
-use std::io::Write;
-use std::path::Path;
-use std::path::PathBuf;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
 use std::process::Command;
+
+use anyhow::{Context, Result, anyhow};
+use codex_protocol::parse_command::ParsedCommand;
+use codex_protocol::protocol::{EventMsg, FileChange, SandboxPolicy};
+use schemars::{JsonSchema, schema_for};
+use serde::Serialize;
+use serde_json::{Map, Value};
 use ts_rs::TS;
 
+use crate::{
+    ClientNotification, ClientRequest, ServerNotification, ServerRequest,
+    export_client_notification_schemas, export_client_param_schemas,
+    export_client_response_schemas, export_client_responses, export_server_notification_schemas,
+    export_server_param_schemas, export_server_response_schemas, export_server_responses,
+};
+
 const HEADER: &str = "// GENERATED CODE! DO NOT MODIFY BY HAND!\n\n";
 
 #[derive(Clone)]
@@ -707,13 +694,15 @@ fn generate_index_ts(out_dir: &Path) -> Result<PathBuf> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use anyhow::Result;
     use std::collections::BTreeSet;
     use std::fs;
     use std::path::PathBuf;
+
+    use anyhow::Result;
     use uuid::Uuid;
 
+    use super::*;
+
     #[test]
     fn generated_ts_has_no_optional_nullable_fields() -> Result<()> {
         // Assert that there are no types of the form "?: T | null" in the generated TS files.

codex-rs/app-server-protocol/src/jsonrpc_lite.rs

@@ -2,8 +2,7 @@
 //! "jsonrpc": "2.0" field.
 
 use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 
 pub const JSONRPC_VERSION: &str = "2.0";

codex-rs/app-server-protocol/src/lib.rs

@@ -2,9 +2,7 @@ mod export;
 mod jsonrpc_lite;
 mod protocol;
 
-pub use export::generate_json;
-pub use export::generate_ts;
-pub use export::generate_types;
+pub use export::{generate_json, generate_ts, generate_types};
 pub use jsonrpc_lite::*;
 pub use protocol::common::*;
 pub use protocol::v1::*;

codex-rs/app-server-protocol/src/protocol/common.rs

@@ -1,26 +1,19 @@
 use std::collections::HashMap;
-use std::path::Path;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
-use crate::JSONRPCNotification;
-use crate::JSONRPCRequest;
-use crate::RequestId;
-use crate::export::GeneratedSchema;
-use crate::export::write_json_schema;
-use crate::protocol::v1;
-use crate::protocol::v2;
 use codex_protocol::ConversationId;
 use codex_protocol::parse_command::ParsedCommand;
-use codex_protocol::protocol::FileChange;
-use codex_protocol::protocol::ReviewDecision;
-use codex_protocol::protocol::SandboxCommandAssessment;
+use codex_protocol::protocol::{FileChange, ReviewDecision, SandboxCommandAssessment};
 use paste::paste;
 use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use strum_macros::Display;
 use ts_rs::TS;
 
+use crate::export::{GeneratedSchema, write_json_schema};
+use crate::protocol::{v1, v2};
+use crate::{JSONRPCNotification, JSONRPCRequest, RequestId};
+
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema, TS)]
 #[ts(type = "string")]
 pub struct GitSha(pub String);
@@ -541,13 +534,14 @@ client_notification_definitions! {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use anyhow::Result;
     use codex_protocol::account::PlanType;
     use codex_protocol::protocol::AskForApproval;
     use pretty_assertions::assert_eq;
     use serde_json::json;
 
+    use super::*;
+
     #[test]
     fn serialize_new_conversation() -> Result<()> {
         let request = ClientRequest::NewConversation {

codex-rs/app-server-protocol/src/protocol/v1.rs

@@ -2,19 +2,13 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 
 use codex_protocol::ConversationId;
-use codex_protocol::config_types::ForcedLoginMethod;
-use codex_protocol::config_types::ReasoningEffort;
-use codex_protocol::config_types::ReasoningSummary;
-use codex_protocol::config_types::SandboxMode;
-use codex_protocol::config_types::Verbosity;
+use codex_protocol::config_types::{
+    ForcedLoginMethod, ReasoningEffort, ReasoningSummary, SandboxMode, Verbosity,
+};
 use codex_protocol::models::ResponseItem;
-use codex_protocol::protocol::AskForApproval;
-use codex_protocol::protocol::EventMsg;
-use codex_protocol::protocol::SandboxPolicy;
-use codex_protocol::protocol::TurnAbortReason;
+use codex_protocol::protocol::{AskForApproval, EventMsg, SandboxPolicy, TurnAbortReason};
 use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 use uuid::Uuid;
 

codex-rs/app-server-protocol/src/protocol/v2.rs

@@ -1,19 +1,20 @@
 use std::collections::HashMap;
 use std::path::PathBuf;
 
-use crate::protocol::common::AuthMode;
 use codex_protocol::ConversationId;
 use codex_protocol::account::PlanType;
 use codex_protocol::config_types::ReasoningEffort;
-use codex_protocol::protocol::RateLimitSnapshot as CoreRateLimitSnapshot;
-use codex_protocol::protocol::RateLimitWindow as CoreRateLimitWindow;
+use codex_protocol::protocol::{
+    RateLimitSnapshot as CoreRateLimitSnapshot, RateLimitWindow as CoreRateLimitWindow,
+};
 use mcp_types::ContentBlock as McpContentBlock;
 use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
 use ts_rs::TS;
 
+use crate::protocol::common::AuthMode;
+
 // Macro to declare a camelCased API v2 enum mirroring a core enum which
 // tends to use kebab-case.
 macro_rules! v2_enum_from_core {

codex-rs/app-server/src/codex_message_processor.rs

@@ -1,141 +1,72 @@
-use crate::error_code::INTERNAL_ERROR_CODE;
-use crate::error_code::INVALID_REQUEST_ERROR_CODE;
-use crate::fuzzy_file_search::run_fuzzy_file_search;
-use crate::models::supported_models;
-use crate::outgoing_message::OutgoingMessageSender;
-use crate::outgoing_message::OutgoingNotification;
-use codex_app_server_protocol::AccountLoginCompletedNotification;
-use codex_app_server_protocol::AccountRateLimitsUpdatedNotification;
-use codex_app_server_protocol::AccountUpdatedNotification;
-use codex_app_server_protocol::AddConversationListenerParams;
-use codex_app_server_protocol::AddConversationSubscriptionResponse;
-use codex_app_server_protocol::ApplyPatchApprovalParams;
-use codex_app_server_protocol::ApplyPatchApprovalResponse;
-use codex_app_server_protocol::ArchiveConversationParams;
-use codex_app_server_protocol::ArchiveConversationResponse;
-use codex_app_server_protocol::AuthMode;
-use codex_app_server_protocol::AuthStatusChangeNotification;
-use codex_app_server_protocol::CancelLoginAccountParams;
-use codex_app_server_protocol::CancelLoginAccountResponse;
-use codex_app_server_protocol::CancelLoginChatGptResponse;
-use codex_app_server_protocol::ClientRequest;
-use codex_app_server_protocol::ConversationSummary;
-use codex_app_server_protocol::ExecCommandApprovalParams;
-use codex_app_server_protocol::ExecCommandApprovalResponse;
-use codex_app_server_protocol::ExecOneOffCommandParams;
-use codex_app_server_protocol::ExecOneOffCommandResponse;
-use codex_app_server_protocol::FeedbackUploadParams;
-use codex_app_server_protocol::FeedbackUploadResponse;
-use codex_app_server_protocol::FuzzyFileSearchParams;
-use codex_app_server_protocol::FuzzyFileSearchResponse;
-use codex_app_server_protocol::GetAccountRateLimitsResponse;
-use codex_app_server_protocol::GetConversationSummaryParams;
-use codex_app_server_protocol::GetConversationSummaryResponse;
-use codex_app_server_protocol::GetUserAgentResponse;
-use codex_app_server_protocol::GetUserSavedConfigResponse;
-use codex_app_server_protocol::GitDiffToRemoteResponse;
-use codex_app_server_protocol::InputItem as WireInputItem;
-use codex_app_server_protocol::InterruptConversationParams;
-use codex_app_server_protocol::InterruptConversationResponse;
-use codex_app_server_protocol::JSONRPCErrorError;
-use codex_app_server_protocol::ListConversationsParams;
-use codex_app_server_protocol::ListConversationsResponse;
-use codex_app_server_protocol::LoginAccountParams;
-use codex_app_server_protocol::LoginApiKeyParams;
-use codex_app_server_protocol::LoginApiKeyResponse;
-use codex_app_server_protocol::LoginChatGptCompleteNotification;
-use codex_app_server_protocol::LoginChatGptResponse;
-use codex_app_server_protocol::ModelListParams;
-use codex_app_server_protocol::ModelListResponse;
-use codex_app_server_protocol::NewConversationParams;
-use codex_app_server_protocol::NewConversationResponse;
-use codex_app_server_protocol::RemoveConversationListenerParams;
-use codex_app_server_protocol::RemoveConversationSubscriptionResponse;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::Result as JsonRpcResult;
-use codex_app_server_protocol::ResumeConversationParams;
-use codex_app_server_protocol::SendUserMessageParams;
-use codex_app_server_protocol::SendUserMessageResponse;
-use codex_app_server_protocol::SendUserTurnParams;
-use codex_app_server_protocol::SendUserTurnResponse;
-use codex_app_server_protocol::ServerNotification;
-use codex_app_server_protocol::ServerRequestPayload;
-use codex_app_server_protocol::SessionConfiguredNotification;
-use codex_app_server_protocol::SetDefaultModelParams;
-use codex_app_server_protocol::SetDefaultModelResponse;
-use codex_app_server_protocol::Thread;
-use codex_app_server_protocol::ThreadArchiveParams;
-use codex_app_server_protocol::ThreadArchiveResponse;
-use codex_app_server_protocol::ThreadListParams;
-use codex_app_server_protocol::ThreadListResponse;
-use codex_app_server_protocol::ThreadResumeParams;
-use codex_app_server_protocol::ThreadResumeResponse;
-use codex_app_server_protocol::ThreadStartParams;
-use codex_app_server_protocol::ThreadStartResponse;
-use codex_app_server_protocol::ThreadStartedNotification;
-use codex_app_server_protocol::UserInfoResponse;
-use codex_app_server_protocol::UserSavedConfig;
+use std::collections::HashMap;
+use std::ffi::OsStr;
+use std::io::Error as IoError;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::Duration;
+
+use codex_app_server_protocol::{
+    AccountLoginCompletedNotification, AccountRateLimitsUpdatedNotification,
+    AccountUpdatedNotification, AddConversationListenerParams, AddConversationSubscriptionResponse,
+    ApplyPatchApprovalParams, ApplyPatchApprovalResponse, ArchiveConversationParams,
+    ArchiveConversationResponse, AuthMode, AuthStatusChangeNotification, CancelLoginAccountParams,
+    CancelLoginAccountResponse, CancelLoginChatGptResponse, ClientRequest, ConversationSummary,
+    ExecCommandApprovalParams, ExecCommandApprovalResponse, ExecOneOffCommandParams,
+    ExecOneOffCommandResponse, FeedbackUploadParams, FeedbackUploadResponse, FuzzyFileSearchParams,
+    FuzzyFileSearchResponse, GetAccountRateLimitsResponse, GetConversationSummaryParams,
+    GetConversationSummaryResponse, GetUserAgentResponse, GetUserSavedConfigResponse,
+    GitDiffToRemoteResponse, InputItem as WireInputItem, InterruptConversationParams,
+    InterruptConversationResponse, JSONRPCErrorError, ListConversationsParams,
+    ListConversationsResponse, LoginAccountParams, LoginApiKeyParams, LoginApiKeyResponse,
+    LoginChatGptCompleteNotification, LoginChatGptResponse, ModelListParams, ModelListResponse,
+    NewConversationParams, NewConversationResponse, RemoveConversationListenerParams,
+    RemoveConversationSubscriptionResponse, RequestId, Result as JsonRpcResult,
+    ResumeConversationParams, SendUserMessageParams, SendUserMessageResponse, SendUserTurnParams,
+    SendUserTurnResponse, ServerNotification, ServerRequestPayload, SessionConfiguredNotification,
+    SetDefaultModelParams, SetDefaultModelResponse, Thread, ThreadArchiveParams,
+    ThreadArchiveResponse, ThreadListParams, ThreadListResponse, ThreadResumeParams,
+    ThreadResumeResponse, ThreadStartParams, ThreadStartResponse, ThreadStartedNotification,
+    UserInfoResponse, UserSavedConfig,
+};
 use codex_backend_client::Client as BackendClient;
-use codex_core::AuthManager;
-use codex_core::CodexConversation;
-use codex_core::ConversationManager;
-use codex_core::Cursor as RolloutCursor;
-use codex_core::INTERACTIVE_SESSION_SOURCES;
-use codex_core::InitialHistory;
-use codex_core::NewConversation;
-use codex_core::RolloutRecorder;
-use codex_core::SessionMeta;
-use codex_core::auth::CLIENT_ID;
-use codex_core::auth::login_with_api_key;
-use codex_core::config::Config;
-use codex_core::config::ConfigOverrides;
-use codex_core::config::ConfigToml;
+use codex_core::auth::{CLIENT_ID, login_with_api_key};
 use codex_core::config::edit::ConfigEditsBuilder;
+use codex_core::config::{Config, ConfigOverrides, ConfigToml};
 use codex_core::config_loader::load_config_as_toml;
 use codex_core::default_client::get_codex_user_agent;
 use codex_core::exec::ExecParams;
 use codex_core::exec_env::create_env;
-use codex_core::find_conversation_path_by_id_str;
-use codex_core::get_platform_sandbox;
 use codex_core::git_info::git_diff_to_remote;
-use codex_core::parse_cursor;
-use codex_core::protocol::ApplyPatchApprovalRequestEvent;
-use codex_core::protocol::Event;
-use codex_core::protocol::EventMsg;
-use codex_core::protocol::ExecApprovalRequestEvent;
-use codex_core::protocol::Op;
-use codex_core::protocol::ReviewDecision;
-use codex_core::read_head_for_summary;
+use codex_core::protocol::{
+    ApplyPatchApprovalRequestEvent, Event, EventMsg, ExecApprovalRequestEvent, Op, ReviewDecision,
+};
+use codex_core::{
+    AuthManager, CodexConversation, ConversationManager, Cursor as RolloutCursor,
+    INTERACTIVE_SESSION_SOURCES, InitialHistory, NewConversation, RolloutRecorder, SessionMeta,
+    find_conversation_path_by_id_str, get_platform_sandbox, parse_cursor, read_head_for_summary,
+};
 use codex_feedback::CodexFeedback;
-use codex_login::ServerOptions as LoginServerOptions;
-use codex_login::ShutdownHandle;
-use codex_login::run_login_server;
+use codex_login::{ServerOptions as LoginServerOptions, ShutdownHandle, run_login_server};
 use codex_protocol::ConversationId;
 use codex_protocol::config_types::ForcedLoginMethod;
 use codex_protocol::items::TurnItem;
 use codex_protocol::models::ResponseItem;
-use codex_protocol::protocol::RateLimitSnapshot as CoreRateLimitSnapshot;
-use codex_protocol::protocol::RolloutItem;
-use codex_protocol::protocol::USER_MESSAGE_BEGIN;
+use codex_protocol::protocol::{
+    RateLimitSnapshot as CoreRateLimitSnapshot, RolloutItem, USER_MESSAGE_BEGIN,
+};
 use codex_protocol::user_input::UserInput as CoreInputItem;
 use codex_utils_json_to_toml::json_to_toml;
-use std::collections::HashMap;
-use std::ffi::OsStr;
-use std::io::Error as IoError;
-use std::path::Path;
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering;
-use std::time::Duration;
 use tokio::select;
-use tokio::sync::Mutex;
-use tokio::sync::oneshot;
-use tracing::error;
-use tracing::info;
-use tracing::warn;
+use tokio::sync::{Mutex, oneshot};
+use tracing::{error, info, warn};
 use uuid::Uuid;
 
+use crate::error_code::{INTERNAL_ERROR_CODE, INVALID_REQUEST_ERROR_CODE};
+use crate::fuzzy_file_search::run_fuzzy_file_search;
+use crate::models::supported_models;
+use crate::outgoing_message::{OutgoingMessageSender, OutgoingNotification};
+
 // Duration before a ChatGPT login attempt is abandoned.
 const LOGIN_CHATGPT_TIMEOUT: Duration = Duration::from_secs(10 * 60);
 struct ActiveLogin {
@@ -2615,12 +2546,13 @@ fn extract_conversation_summary(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use anyhow::Result;
     use pretty_assertions::assert_eq;
     use serde_json::json;
     use tempfile::TempDir;
 
+    use super::*;
+
     #[test]
     fn extract_conversation_summary_prefers_plain_user_messages() -> Result<()> {
         let conversation_id = ConversationId::from_string("3f941c35-29b3-493b-b0a4-e25800d9aeb0")?;
@@ -2672,11 +2604,10 @@ mod tests {
 
     #[tokio::test]
     async fn read_summary_from_rollout_returns_empty_preview_when_no_user_message() -> Result<()> {
-        use codex_protocol::protocol::RolloutItem;
-        use codex_protocol::protocol::RolloutLine;
-        use codex_protocol::protocol::SessionMetaLine;
         use std::fs;
 
+        use codex_protocol::protocol::{RolloutItem, RolloutLine, SessionMetaLine};
+
         let temp_dir = TempDir::new()?;
         let path = temp_dir.path().join("rollout.jsonl");
 

codex-rs/app-server/src/fuzzy_file_search.rs

@@ -1,7 +1,5 @@
-use std::num::NonZero;
-use std::num::NonZeroUsize;
-use std::path::Path;
-use std::path::PathBuf;
+use std::num::{NonZero, NonZeroUsize};
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 

codex-rs/app-server/src/lib.rs

@@ -1,32 +1,25 @@
 #![deny(clippy::print_stdout, clippy::print_stderr)]
 
-use codex_common::CliConfigOverrides;
-use codex_core::config::Config;
-use codex_core::config::ConfigOverrides;
-use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
-use std::io::ErrorKind;
-use std::io::Result as IoResult;
+use std::io::{ErrorKind, Result as IoResult};
 use std::path::PathBuf;
 
-use crate::message_processor::MessageProcessor;
-use crate::outgoing_message::OutgoingMessage;
-use crate::outgoing_message::OutgoingMessageSender;
 use codex_app_server_protocol::JSONRPCMessage;
+use codex_common::CliConfigOverrides;
+use codex_core::config::{Config, ConfigOverrides};
 use codex_feedback::CodexFeedback;
-use tokio::io::AsyncBufReadExt;
-use tokio::io::AsyncWriteExt;
-use tokio::io::BufReader;
-use tokio::io::{self};
+use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
+use tokio::io::{
+    AsyncBufReadExt, AsyncWriteExt, BufReader, {self},
+};
 use tokio::sync::mpsc;
-use tracing::Level;
-use tracing::debug;
-use tracing::error;
-use tracing::info;
-use tracing_subscriber::EnvFilter;
-use tracing_subscriber::Layer;
+use tracing::{Level, debug, error, info};
 use tracing_subscriber::filter::Targets;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
+use tracing_subscriber::{EnvFilter, Layer};
+
+use crate::message_processor::MessageProcessor;
+use crate::outgoing_message::{OutgoingMessage, OutgoingMessageSender};
 
 mod codex_message_processor;
 mod error_code;

codex-rs/app-server/src/message_processor.rs

@@ -1,25 +1,19 @@
 use std::path::PathBuf;
+use std::sync::Arc;
+
+use codex_app_server_protocol::{
+    ClientInfo, ClientRequest, InitializeResponse, JSONRPCError, JSONRPCErrorError,
+    JSONRPCNotification, JSONRPCRequest, JSONRPCResponse,
+};
+use codex_core::config::Config;
+use codex_core::default_client::{USER_AGENT_SUFFIX, get_codex_user_agent};
+use codex_core::{AuthManager, ConversationManager};
+use codex_feedback::CodexFeedback;
+use codex_protocol::protocol::SessionSource;
 
 use crate::codex_message_processor::CodexMessageProcessor;
 use crate::error_code::INVALID_REQUEST_ERROR_CODE;
 use crate::outgoing_message::OutgoingMessageSender;
-use codex_app_server_protocol::ClientInfo;
-use codex_app_server_protocol::ClientRequest;
-use codex_app_server_protocol::InitializeResponse;
-
-use codex_app_server_protocol::JSONRPCError;
-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_core::AuthManager;
-use codex_core::ConversationManager;
-use codex_core::config::Config;
-use codex_core::default_client::USER_AGENT_SUFFIX;
-use codex_core::default_client::get_codex_user_agent;
-use codex_feedback::CodexFeedback;
-use codex_protocol::protocol::SessionSource;
-use std::sync::Arc;
 
 pub(crate) struct MessageProcessor {
     outgoing: Arc<OutgoingMessageSender>,

codex-rs/app-server/src/models.rs

@@ -1,8 +1,5 @@
-use codex_app_server_protocol::Model;
-use codex_app_server_protocol::ReasoningEffortOption;
-use codex_common::model_presets::ModelPreset;
-use codex_common::model_presets::ReasoningEffortPreset;
-use codex_common::model_presets::builtin_model_presets;
+use codex_app_server_protocol::{Model, ReasoningEffortOption};
+use codex_common::model_presets::{ModelPreset, ReasoningEffortPreset, builtin_model_presets};
 
 pub fn supported_models() -> Vec<Model> {
     builtin_model_presets(None)

codex-rs/app-server/src/outgoing_message.rs

@@ -1,17 +1,11 @@
 use std::collections::HashMap;
-use std::sync::atomic::AtomicI64;
-use std::sync::atomic::Ordering;
+use std::sync::atomic::{AtomicI64, Ordering};
 
-use codex_app_server_protocol::JSONRPCErrorError;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::Result;
-use codex_app_server_protocol::ServerNotification;
-use codex_app_server_protocol::ServerRequest;
-use codex_app_server_protocol::ServerRequestPayload;
+use codex_app_server_protocol::{
+    JSONRPCErrorError, RequestId, Result, ServerNotification, ServerRequest, ServerRequestPayload,
+};
 use serde::Serialize;
-use tokio::sync::Mutex;
-use tokio::sync::mpsc;
-use tokio::sync::oneshot;
+use tokio::sync::{Mutex, mpsc, oneshot};
 use tracing::warn;
 
 use crate::error_code::INTERNAL_ERROR_CODE;
@@ -141,13 +135,11 @@ pub(crate) struct OutgoingError {
 
 #[cfg(test)]
 mod tests {
-    use codex_app_server_protocol::AccountLoginCompletedNotification;
-    use codex_app_server_protocol::AccountRateLimitsUpdatedNotification;
-    use codex_app_server_protocol::AccountUpdatedNotification;
-    use codex_app_server_protocol::AuthMode;
-    use codex_app_server_protocol::LoginChatGptCompleteNotification;
-    use codex_app_server_protocol::RateLimitSnapshot;
-    use codex_app_server_protocol::RateLimitWindow;
+    use codex_app_server_protocol::{
+        AccountLoginCompletedNotification, AccountRateLimitsUpdatedNotification,
+        AccountUpdatedNotification, AuthMode, LoginChatGptCompleteNotification, RateLimitSnapshot,
+        RateLimitWindow,
+    };
     use pretty_assertions::assert_eq;
     use serde_json::json;
     use uuid::Uuid;

codex-rs/app-server/tests/common/auth_fixtures.rs

@@ -1,16 +1,11 @@
 use std::path::Path;
 
-use anyhow::Context;
-use anyhow::Result;
+use anyhow::{Context, Result};
 use base64::Engine;
 use base64::engine::general_purpose::URL_SAFE_NO_PAD;
-use chrono::DateTime;
-use chrono::Utc;
-use codex_core::auth::AuthCredentialsStoreMode;
-use codex_core::auth::AuthDotJson;
-use codex_core::auth::save_auth;
-use codex_core::token_data::TokenData;
-use codex_core::token_data::parse_id_token;
+use chrono::{DateTime, Utc};
+use codex_core::auth::{AuthCredentialsStoreMode, AuthDotJson, save_auth};
+use codex_core::token_data::{TokenData, parse_id_token};
 use serde_json::json;
 
 /// Builder for writing a fake ChatGPT auth.json in tests.

codex-rs/app-server/tests/common/lib.rs

@@ -4,17 +4,18 @@ mod mock_model_server;
 mod responses;
 mod rollout;
 
-pub use auth_fixtures::ChatGptAuthFixture;
-pub use auth_fixtures::ChatGptIdTokenClaims;
-pub use auth_fixtures::encode_id_token;
-pub use auth_fixtures::write_chatgpt_auth;
+pub use auth_fixtures::{
+    ChatGptAuthFixture, ChatGptIdTokenClaims, encode_id_token, write_chatgpt_auth,
+};
 use codex_app_server_protocol::JSONRPCResponse;
 pub use mcp_process::McpProcess;
-pub use mock_model_server::create_mock_chat_completions_server;
-pub use mock_model_server::create_mock_chat_completions_server_unchecked;
-pub use responses::create_apply_patch_sse_response;
-pub use responses::create_final_assistant_message_sse_response;
-pub use responses::create_shell_sse_response;
+pub use mock_model_server::{
+    create_mock_chat_completions_server, create_mock_chat_completions_server_unchecked,
+};
+pub use responses::{
+    create_apply_patch_sse_response, create_final_assistant_message_sse_response,
+    create_shell_sse_response,
+};
 pub use rollout::create_fake_rollout;
 use serde::de::DeserializeOwned;
 

codex-rs/app-server/tests/common/mcp_process.rs

@@ -1,50 +1,22 @@
 use std::collections::VecDeque;
 use std::path::Path;
-use std::process::Stdio;
-use std::sync::atomic::AtomicI64;
-use std::sync::atomic::Ordering;
-use tokio::io::AsyncBufReadExt;
-use tokio::io::AsyncWriteExt;
-use tokio::io::BufReader;
-use tokio::process::Child;
-use tokio::process::ChildStdin;
-use tokio::process::ChildStdout;
+use std::process::{Command as StdCommand, Stdio};
+use std::sync::atomic::{AtomicI64, Ordering};
 
 use anyhow::Context;
 use assert_cmd::prelude::*;
-use codex_app_server_protocol::AddConversationListenerParams;
-use codex_app_server_protocol::ArchiveConversationParams;
-use codex_app_server_protocol::CancelLoginAccountParams;
-use codex_app_server_protocol::CancelLoginChatGptParams;
-use codex_app_server_protocol::ClientInfo;
-use codex_app_server_protocol::ClientNotification;
-use codex_app_server_protocol::FeedbackUploadParams;
-use codex_app_server_protocol::GetAuthStatusParams;
-use codex_app_server_protocol::InitializeParams;
-use codex_app_server_protocol::InterruptConversationParams;
-use codex_app_server_protocol::ListConversationsParams;
-use codex_app_server_protocol::LoginApiKeyParams;
-use codex_app_server_protocol::ModelListParams;
-use codex_app_server_protocol::NewConversationParams;
-use codex_app_server_protocol::RemoveConversationListenerParams;
-use codex_app_server_protocol::ResumeConversationParams;
-use codex_app_server_protocol::SendUserMessageParams;
-use codex_app_server_protocol::SendUserTurnParams;
-use codex_app_server_protocol::ServerRequest;
-use codex_app_server_protocol::SetDefaultModelParams;
-use codex_app_server_protocol::ThreadArchiveParams;
-use codex_app_server_protocol::ThreadListParams;
-use codex_app_server_protocol::ThreadResumeParams;
-use codex_app_server_protocol::ThreadStartParams;
-
-use codex_app_server_protocol::JSONRPCError;
-use codex_app_server_protocol::JSONRPCMessage;
-use codex_app_server_protocol::JSONRPCNotification;
-use codex_app_server_protocol::JSONRPCRequest;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::RequestId;
-use std::process::Command as StdCommand;
-use tokio::process::Command;
+use codex_app_server_protocol::{
+    AddConversationListenerParams, ArchiveConversationParams, CancelLoginAccountParams,
+    CancelLoginChatGptParams, ClientInfo, ClientNotification, FeedbackUploadParams,
+    GetAuthStatusParams, InitializeParams, InterruptConversationParams, JSONRPCError,
+    JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, ListConversationsParams,
+    LoginApiKeyParams, ModelListParams, NewConversationParams, RemoveConversationListenerParams,
+    RequestId, ResumeConversationParams, SendUserMessageParams, SendUserTurnParams, ServerRequest,
+    SetDefaultModelParams, ThreadArchiveParams, ThreadListParams, ThreadResumeParams,
+    ThreadStartParams,
+};
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::process::{Child, ChildStdin, ChildStdout, Command};
 
 pub struct McpProcess {
     next_request_id: AtomicI64,

codex-rs/app-server/tests/common/mock_model_server.rs

@@ -1,12 +1,7 @@
-use std::sync::atomic::AtomicUsize;
-use std::sync::atomic::Ordering;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
-use wiremock::Mock;
-use wiremock::MockServer;
-use wiremock::Respond;
-use wiremock::ResponseTemplate;
-use wiremock::matchers::method;
-use wiremock::matchers::path;
+use wiremock::matchers::{method, path};
+use wiremock::{Mock, MockServer, Respond, ResponseTemplate};
 
 /// Create a mock server that will provide the responses, in order, for
 /// requests to the `/v1/chat/completions` endpoint.

codex-rs/app-server/tests/common/responses.rs

@@ -1,6 +1,7 @@
-use serde_json::json;
 use std::path::Path;
 
+use serde_json::json;
+
 pub fn create_shell_sse_response(
     command: Vec<String>,
     workdir: Option<&Path>,

codex-rs/app-server/tests/common/rollout.rs

@@ -1,11 +1,10 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
 use anyhow::Result;
 use codex_protocol::ConversationId;
-use codex_protocol::protocol::SessionMeta;
-use codex_protocol::protocol::SessionSource;
+use codex_protocol::protocol::{SessionMeta, SessionSource};
 use serde_json::json;
-use std::fs;
-use std::path::Path;
-use std::path::PathBuf;
 use uuid::Uuid;
 
 /// Create a minimal rollout file under `CODEX_HOME/sessions/YYYY/MM/DD/`.

codex-rs/app-server/tests/suite/archive_conversation.rs

@@ -1,14 +1,12 @@
-use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::to_response;
-use codex_app_server_protocol::ArchiveConversationParams;
-use codex_app_server_protocol::ArchiveConversationResponse;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::NewConversationParams;
-use codex_app_server_protocol::NewConversationResponse;
-use codex_app_server_protocol::RequestId;
-use codex_core::ARCHIVED_SESSIONS_SUBDIR;
 use std::path::Path;
+
+use anyhow::Result;
+use app_test_support::{McpProcess, to_response};
+use codex_app_server_protocol::{
+    ArchiveConversationParams, ArchiveConversationResponse, JSONRPCResponse, NewConversationParams,
+    NewConversationResponse, RequestId,
+};
+use codex_core::ARCHIVED_SESSIONS_SUBDIR;
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/app-server/tests/suite/auth.rs

@@ -1,16 +1,12 @@
-use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::to_response;
-use codex_app_server_protocol::AuthMode;
-use codex_app_server_protocol::GetAuthStatusParams;
-use codex_app_server_protocol::GetAuthStatusResponse;
-use codex_app_server_protocol::JSONRPCError;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::LoginApiKeyParams;
-use codex_app_server_protocol::LoginApiKeyResponse;
-use codex_app_server_protocol::RequestId;
-use pretty_assertions::assert_eq;
 use std::path::Path;
+
+use anyhow::Result;
+use app_test_support::{McpProcess, to_response};
+use codex_app_server_protocol::{
+    AuthMode, GetAuthStatusParams, GetAuthStatusResponse, JSONRPCError, JSONRPCResponse,
+    LoginApiKeyParams, LoginApiKeyResponse, RequestId,
+};
+use pretty_assertions::assert_eq;
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/app-server/tests/suite/codex_message_processor_flow.rs

@@ -1,37 +1,25 @@
+use std::env;
+use std::path::Path;
+
 use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::create_final_assistant_message_sse_response;
-use app_test_support::create_mock_chat_completions_server;
-use app_test_support::create_shell_sse_response;
-use app_test_support::to_response;
-use codex_app_server_protocol::AddConversationListenerParams;
-use codex_app_server_protocol::AddConversationSubscriptionResponse;
-use codex_app_server_protocol::ExecCommandApprovalParams;
-use codex_app_server_protocol::InputItem;
-use codex_app_server_protocol::JSONRPCNotification;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::NewConversationParams;
-use codex_app_server_protocol::NewConversationResponse;
-use codex_app_server_protocol::RemoveConversationListenerParams;
-use codex_app_server_protocol::RemoveConversationSubscriptionResponse;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::SendUserMessageParams;
-use codex_app_server_protocol::SendUserMessageResponse;
-use codex_app_server_protocol::SendUserTurnParams;
-use codex_app_server_protocol::SendUserTurnResponse;
-use codex_app_server_protocol::ServerRequest;
-use codex_core::protocol::AskForApproval;
-use codex_core::protocol::SandboxPolicy;
-use codex_core::protocol_config_types::ReasoningEffort;
-use codex_core::protocol_config_types::ReasoningSummary;
+use app_test_support::{
+    McpProcess, create_final_assistant_message_sse_response, create_mock_chat_completions_server,
+    create_shell_sse_response, to_response,
+};
+use codex_app_server_protocol::{
+    AddConversationListenerParams, AddConversationSubscriptionResponse, ExecCommandApprovalParams,
+    InputItem, JSONRPCNotification, JSONRPCResponse, NewConversationParams,
+    NewConversationResponse, RemoveConversationListenerParams,
+    RemoveConversationSubscriptionResponse, RequestId, SendUserMessageParams,
+    SendUserMessageResponse, SendUserTurnParams, SendUserTurnResponse, ServerRequest,
+};
+use codex_core::protocol::{AskForApproval, SandboxPolicy};
+use codex_core::protocol_config_types::{ReasoningEffort, ReasoningSummary};
 use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
 use codex_protocol::config_types::SandboxMode;
 use codex_protocol::parse_command::ParsedCommand;
-use codex_protocol::protocol::Event;
-use codex_protocol::protocol::EventMsg;
+use codex_protocol::protocol::{Event, EventMsg};
 use pretty_assertions::assert_eq;
-use std::env;
-use std::path::Path;
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/app-server/tests/suite/config.rs

@@ -1,22 +1,17 @@
-use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::to_response;
-use codex_app_server_protocol::GetUserSavedConfigResponse;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::Profile;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::SandboxSettings;
-use codex_app_server_protocol::Tools;
-use codex_app_server_protocol::UserSavedConfig;
-use codex_core::protocol::AskForApproval;
-use codex_protocol::config_types::ForcedLoginMethod;
-use codex_protocol::config_types::ReasoningEffort;
-use codex_protocol::config_types::ReasoningSummary;
-use codex_protocol::config_types::SandboxMode;
-use codex_protocol::config_types::Verbosity;
-use pretty_assertions::assert_eq;
 use std::collections::HashMap;
 use std::path::Path;
+
+use anyhow::Result;
+use app_test_support::{McpProcess, to_response};
+use codex_app_server_protocol::{
+    GetUserSavedConfigResponse, JSONRPCResponse, Profile, RequestId, SandboxSettings, Tools,
+    UserSavedConfig,
+};
+use codex_core::protocol::AskForApproval;
+use codex_protocol::config_types::{
+    ForcedLoginMethod, ReasoningEffort, ReasoningSummary, SandboxMode, Verbosity,
+};
+use pretty_assertions::assert_eq;
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/app-server/tests/suite/create_conversation.rs

@@ -1,20 +1,17 @@
+use std::path::Path;
+
 use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::create_final_assistant_message_sse_response;
-use app_test_support::create_mock_chat_completions_server;
-use app_test_support::to_response;
-use codex_app_server_protocol::AddConversationListenerParams;
-use codex_app_server_protocol::AddConversationSubscriptionResponse;
-use codex_app_server_protocol::InputItem;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::NewConversationParams;
-use codex_app_server_protocol::NewConversationResponse;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::SendUserMessageParams;
-use codex_app_server_protocol::SendUserMessageResponse;
+use app_test_support::{
+    McpProcess, create_final_assistant_message_sse_response, create_mock_chat_completions_server,
+    to_response,
+};
+use codex_app_server_protocol::{
+    AddConversationListenerParams, AddConversationSubscriptionResponse, InputItem, JSONRPCResponse,
+    NewConversationParams, NewConversationResponse, RequestId, SendUserMessageParams,
+    SendUserMessageResponse,
+};
 use pretty_assertions::assert_eq;
 use serde_json::json;
-use std::path::Path;
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/app-server/tests/suite/fuzzy_file_search.rs

@@ -1,8 +1,6 @@
-use anyhow::Result;
-use anyhow::anyhow;
+use anyhow::{Result, anyhow};
 use app_test_support::McpProcess;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::RequestId;
+use codex_app_server_protocol::{JSONRPCResponse, RequestId};
 use pretty_assertions::assert_eq;
 use serde_json::json;
 use tempfile::TempDir;

codex-rs/app-server/tests/suite/interrupt.rs

@@ -3,25 +3,19 @@
 
 use std::path::Path;
 
-use codex_app_server_protocol::AddConversationListenerParams;
-use codex_app_server_protocol::InterruptConversationParams;
-use codex_app_server_protocol::InterruptConversationResponse;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::NewConversationParams;
-use codex_app_server_protocol::NewConversationResponse;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::SendUserMessageParams;
-use codex_app_server_protocol::SendUserMessageResponse;
+use app_test_support::{
+    McpProcess, create_mock_chat_completions_server, create_shell_sse_response, to_response,
+};
+use codex_app_server_protocol::{
+    AddConversationListenerParams, InterruptConversationParams, InterruptConversationResponse,
+    JSONRPCResponse, NewConversationParams, NewConversationResponse, RequestId,
+    SendUserMessageParams, SendUserMessageResponse,
+};
 use codex_core::protocol::TurnAbortReason;
 use core_test_support::skip_if_no_network;
 use tempfile::TempDir;
 use tokio::time::timeout;
 
-use app_test_support::McpProcess;
-use app_test_support::create_mock_chat_completions_server;
-use app_test_support::create_shell_sse_response;
-use app_test_support::to_response;
-
 const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]

codex-rs/app-server/tests/suite/list_resume.rs

@@ -1,20 +1,13 @@
 use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::create_fake_rollout;
-use app_test_support::to_response;
-use codex_app_server_protocol::JSONRPCNotification;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::ListConversationsParams;
-use codex_app_server_protocol::ListConversationsResponse;
+use app_test_support::{McpProcess, create_fake_rollout, to_response};
 use codex_app_server_protocol::NewConversationParams; // reused for overrides shape
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::ResumeConversationParams;
-use codex_app_server_protocol::ResumeConversationResponse;
-use codex_app_server_protocol::ServerNotification;
-use codex_app_server_protocol::SessionConfiguredNotification;
+use codex_app_server_protocol::{
+    JSONRPCNotification, JSONRPCResponse, ListConversationsParams, ListConversationsResponse,
+    RequestId, ResumeConversationParams, ResumeConversationResponse, ServerNotification,
+    SessionConfiguredNotification,
+};
 use codex_core::protocol::EventMsg;
-use codex_protocol::models::ContentItem;
-use codex_protocol::models::ResponseItem;
+use codex_protocol::models::{ContentItem, ResponseItem};
 use pretty_assertions::assert_eq;
 use tempfile::TempDir;
 use tokio::time::timeout;

codex-rs/app-server/tests/suite/login.rs

@@ -1,20 +1,16 @@
+use std::path::Path;
+use std::time::Duration;
+
 use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::to_response;
-use codex_app_server_protocol::CancelLoginChatGptParams;
-use codex_app_server_protocol::CancelLoginChatGptResponse;
-use codex_app_server_protocol::GetAuthStatusParams;
-use codex_app_server_protocol::GetAuthStatusResponse;
-use codex_app_server_protocol::JSONRPCError;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::LoginChatGptResponse;
-use codex_app_server_protocol::LogoutChatGptResponse;
-use codex_app_server_protocol::RequestId;
+use app_test_support::{McpProcess, to_response};
+use codex_app_server_protocol::{
+    CancelLoginChatGptParams, CancelLoginChatGptResponse, GetAuthStatusParams,
+    GetAuthStatusResponse, JSONRPCError, JSONRPCResponse, LoginChatGptResponse,
+    LogoutChatGptResponse, RequestId,
+};
 use codex_core::auth::AuthCredentialsStoreMode;
 use codex_login::login_with_api_key;
 use serial_test::serial;
-use std::path::Path;
-use std::time::Duration;
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/app-server/tests/suite/model_list.rs

@@ -1,16 +1,11 @@
 use std::time::Duration;
 
-use anyhow::Result;
-use anyhow::anyhow;
-use app_test_support::McpProcess;
-use app_test_support::to_response;
-use codex_app_server_protocol::JSONRPCError;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::Model;
-use codex_app_server_protocol::ModelListParams;
-use codex_app_server_protocol::ModelListResponse;
-use codex_app_server_protocol::ReasoningEffortOption;
-use codex_app_server_protocol::RequestId;
+use anyhow::{Result, anyhow};
+use app_test_support::{McpProcess, to_response};
+use codex_app_server_protocol::{
+    JSONRPCError, JSONRPCResponse, Model, ModelListParams, ModelListResponse,
+    ReasoningEffortOption, RequestId,
+};
 use codex_protocol::config_types::ReasoningEffort;
 use pretty_assertions::assert_eq;
 use tempfile::TempDir;

codex-rs/app-server/tests/suite/rate_limits.rs

@@ -1,27 +1,18 @@
+use std::path::Path;
+
 use anyhow::Result;
-use app_test_support::ChatGptAuthFixture;
-use app_test_support::McpProcess;
-use app_test_support::to_response;
-use app_test_support::write_chatgpt_auth;
-use codex_app_server_protocol::GetAccountRateLimitsResponse;
-use codex_app_server_protocol::JSONRPCError;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::LoginApiKeyParams;
-use codex_app_server_protocol::RateLimitSnapshot;
-use codex_app_server_protocol::RateLimitWindow;
-use codex_app_server_protocol::RequestId;
+use app_test_support::{ChatGptAuthFixture, McpProcess, to_response, write_chatgpt_auth};
+use codex_app_server_protocol::{
+    GetAccountRateLimitsResponse, JSONRPCError, JSONRPCResponse, LoginApiKeyParams,
+    RateLimitSnapshot, RateLimitWindow, RequestId,
+};
 use codex_core::auth::AuthCredentialsStoreMode;
 use pretty_assertions::assert_eq;
 use serde_json::json;
-use std::path::Path;
 use tempfile::TempDir;
 use tokio::time::timeout;
-use wiremock::Mock;
-use wiremock::MockServer;
-use wiremock::ResponseTemplate;
-use wiremock::matchers::header;
-use wiremock::matchers::method;
-use wiremock::matchers::path;
+use wiremock::matchers::{header, method, path};
+use wiremock::{Mock, MockServer, ResponseTemplate};
 
 const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
 const INVALID_REQUEST_ERROR_CODE: i64 = -32600;

codex-rs/app-server/tests/suite/send_message.rs

@@ -1,24 +1,19 @@
+use std::path::Path;
+
 use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::create_final_assistant_message_sse_response;
-use app_test_support::create_mock_chat_completions_server;
-use app_test_support::to_response;
-use codex_app_server_protocol::AddConversationListenerParams;
-use codex_app_server_protocol::AddConversationSubscriptionResponse;
-use codex_app_server_protocol::InputItem;
-use codex_app_server_protocol::JSONRPCNotification;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::NewConversationParams;
-use codex_app_server_protocol::NewConversationResponse;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::SendUserMessageParams;
-use codex_app_server_protocol::SendUserMessageResponse;
+use app_test_support::{
+    McpProcess, create_final_assistant_message_sse_response, create_mock_chat_completions_server,
+    to_response,
+};
+use codex_app_server_protocol::{
+    AddConversationListenerParams, AddConversationSubscriptionResponse, InputItem,
+    JSONRPCNotification, JSONRPCResponse, NewConversationParams, NewConversationResponse,
+    RequestId, SendUserMessageParams, SendUserMessageResponse,
+};
 use codex_protocol::ConversationId;
-use codex_protocol::models::ContentItem;
-use codex_protocol::models::ResponseItem;
+use codex_protocol::models::{ContentItem, ResponseItem};
 use codex_protocol::protocol::RawResponseItemEvent;
 use pretty_assertions::assert_eq;
-use std::path::Path;
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/app-server/tests/suite/set_default_model.rs

@@ -1,13 +1,12 @@
+use std::path::Path;
+
 use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::to_response;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::SetDefaultModelParams;
-use codex_app_server_protocol::SetDefaultModelResponse;
+use app_test_support::{McpProcess, to_response};
+use codex_app_server_protocol::{
+    JSONRPCResponse, RequestId, SetDefaultModelParams, SetDefaultModelResponse,
+};
 use codex_core::config::ConfigToml;
 use pretty_assertions::assert_eq;
-use std::path::Path;
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/app-server/tests/suite/user_agent.rs

@@ -1,9 +1,6 @@
 use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::to_response;
-use codex_app_server_protocol::GetUserAgentResponse;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::RequestId;
+use app_test_support::{McpProcess, to_response};
+use codex_app_server_protocol::{GetUserAgentResponse, JSONRPCResponse, RequestId};
 use pretty_assertions::assert_eq;
 use tempfile::TempDir;
 use tokio::time::timeout;

codex-rs/app-server/tests/suite/user_info.rs

@@ -1,14 +1,10 @@
+use std::time::Duration;
+
 use anyhow::Result;
-use app_test_support::ChatGptAuthFixture;
-use app_test_support::McpProcess;
-use app_test_support::to_response;
-use app_test_support::write_chatgpt_auth;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::UserInfoResponse;
+use app_test_support::{ChatGptAuthFixture, McpProcess, to_response, write_chatgpt_auth};
+use codex_app_server_protocol::{JSONRPCResponse, RequestId, UserInfoResponse};
 use codex_core::auth::AuthCredentialsStoreMode;
 use pretty_assertions::assert_eq;
-use std::time::Duration;
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/app-server/tests/suite/v2/account.rs

@@ -1,24 +1,17 @@
-use anyhow::Result;
-use anyhow::bail;
-use app_test_support::McpProcess;
-use app_test_support::to_response;
-use codex_app_server_protocol::AuthMode;
-use codex_app_server_protocol::CancelLoginAccountParams;
-use codex_app_server_protocol::CancelLoginAccountResponse;
-use codex_app_server_protocol::GetAuthStatusParams;
-use codex_app_server_protocol::GetAuthStatusResponse;
-use codex_app_server_protocol::JSONRPCError;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::LoginAccountResponse;
-use codex_app_server_protocol::LogoutAccountResponse;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::ServerNotification;
+use std::path::Path;
+use std::time::Duration;
+
+use anyhow::{Result, bail};
+use app_test_support::{McpProcess, to_response};
+use codex_app_server_protocol::{
+    AuthMode, CancelLoginAccountParams, CancelLoginAccountResponse, GetAuthStatusParams,
+    GetAuthStatusResponse, JSONRPCError, JSONRPCResponse, LoginAccountResponse,
+    LogoutAccountResponse, RequestId, ServerNotification,
+};
 use codex_core::auth::AuthCredentialsStoreMode;
 use codex_login::login_with_api_key;
 use pretty_assertions::assert_eq;
 use serial_test::serial;
-use std::path::Path;
-use std::time::Duration;
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/app-server/tests/suite/v2/thread_archive.rs

@@ -1,15 +1,12 @@
-use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::to_response;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::ThreadArchiveParams;
-use codex_app_server_protocol::ThreadArchiveResponse;
-use codex_app_server_protocol::ThreadStartParams;
-use codex_app_server_protocol::ThreadStartResponse;
-use codex_core::ARCHIVED_SESSIONS_SUBDIR;
-use codex_core::find_conversation_path_by_id_str;
 use std::path::Path;
+
+use anyhow::Result;
+use app_test_support::{McpProcess, to_response};
+use codex_app_server_protocol::{
+    JSONRPCResponse, RequestId, ThreadArchiveParams, ThreadArchiveResponse, ThreadStartParams,
+    ThreadStartResponse,
+};
+use codex_core::{ARCHIVED_SESSIONS_SUBDIR, find_conversation_path_by_id_str};
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/app-server/tests/suite/v2/thread_list.rs

@@ -1,11 +1,6 @@
 use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::create_fake_rollout;
-use app_test_support::to_response;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::ThreadListParams;
-use codex_app_server_protocol::ThreadListResponse;
+use app_test_support::{McpProcess, create_fake_rollout, to_response};
+use codex_app_server_protocol::{JSONRPCResponse, RequestId, ThreadListParams, ThreadListResponse};
 use serde_json::json;
 use tempfile::TempDir;
 use tokio::time::timeout;

codex-rs/app-server/tests/suite/v2/thread_resume.rs

@@ -1,13 +1,9 @@
 use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::create_mock_chat_completions_server;
-use app_test_support::to_response;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::ThreadResumeParams;
-use codex_app_server_protocol::ThreadResumeResponse;
-use codex_app_server_protocol::ThreadStartParams;
-use codex_app_server_protocol::ThreadStartResponse;
+use app_test_support::{McpProcess, create_mock_chat_completions_server, to_response};
+use codex_app_server_protocol::{
+    JSONRPCResponse, RequestId, ThreadResumeParams, ThreadResumeResponse, ThreadStartParams,
+    ThreadStartResponse,
+};
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/app-server/tests/suite/v2/thread_start.rs

@@ -1,14 +1,11 @@
-use anyhow::Result;
-use app_test_support::McpProcess;
-use app_test_support::create_mock_chat_completions_server;
-use app_test_support::to_response;
-use codex_app_server_protocol::JSONRPCNotification;
-use codex_app_server_protocol::JSONRPCResponse;
-use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::ThreadStartParams;
-use codex_app_server_protocol::ThreadStartResponse;
-use codex_app_server_protocol::ThreadStartedNotification;
 use std::path::Path;
+
+use anyhow::Result;
+use app_test_support::{McpProcess, create_mock_chat_completions_server, to_response};
+use codex_app_server_protocol::{
+    JSONRPCNotification, JSONRPCResponse, RequestId, ThreadStartParams, ThreadStartResponse,
+    ThreadStartedNotification,
+};
 use tempfile::TempDir;
 use tokio::time::timeout;
 

codex-rs/apply-patch/src/lib.rs

@@ -3,28 +3,19 @@ mod seek_sequence;
 mod standalone_executable;
 
 use std::collections::HashMap;
-use std::path::Path;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::str::Utf8Error;
 use std::sync::LazyLock;
 
-use anyhow::Context;
-use anyhow::Result;
-pub use parser::Hunk;
-pub use parser::ParseError;
+use anyhow::{Context, Result};
 use parser::ParseError::*;
 use parser::UpdateFileChunk;
-pub use parser::parse_patch;
+pub use parser::{Hunk, ParseError, parse_patch};
 use similar::TextDiff;
-use thiserror::Error;
-use tree_sitter::LanguageError;
-use tree_sitter::Parser;
-use tree_sitter::Query;
-use tree_sitter::QueryCursor;
-use tree_sitter::StreamingIterator;
-use tree_sitter_bash::LANGUAGE as BASH;
-
 pub use standalone_executable::main;
+use thiserror::Error;
+use tree_sitter::{LanguageError, Parser, Query, QueryCursor, StreamingIterator};
+use tree_sitter_bash::LANGUAGE as BASH;
 
 /// Detailed instructions for gpt-4.1 on how to use the `apply_patch` tool.
 pub const APPLY_PATCH_TOOL_INSTRUCTIONS: &str = include_str!("../apply_patch_tool_instructions.md");
@@ -842,13 +833,15 @@ pub fn print_summary(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use assert_matches::assert_matches;
-    use pretty_assertions::assert_eq;
     use std::fs;
     use std::string::ToString;
+
+    use assert_matches::assert_matches;
+    use pretty_assertions::assert_eq;
     use tempfile::tempdir;
 
+    use super::*;
+
     /// Helper to construct a patch with the given body.
     fn wrap_patch(body: &str) -> String {
         format!("*** Begin Patch\n{body}\n*** End Patch")

codex-rs/apply-patch/src/parser.rs

@@ -22,12 +22,12 @@
 //!
 //! The parser below is a little more lenient than the explicit spec and allows for
 //! leading/trailing whitespace around patch markers.
-use crate::ApplyPatchArgs;
-use std::path::Path;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use thiserror::Error;
 
+use crate::ApplyPatchArgs;
+
 const BEGIN_PATCH_MARKER: &str = "*** Begin Patch";
 const END_PATCH_MARKER: &str = "*** End Patch";
 const ADD_FILE_MARKER: &str = "*** Add File: ";

codex-rs/apply-patch/src/seek_sequence.rs

@@ -111,9 +111,10 @@ pub(crate) fn seek_sequence(
 
 #[cfg(test)]
 mod tests {
-    use super::seek_sequence;
     use std::string::ToString;
 
+    use super::seek_sequence;
+
     fn to_vec(strings: &[&str]) -> Vec<String> {
         strings.iter().map(ToString::to_string).collect()
     }

codex-rs/apply-patch/src/standalone_executable.rs

@@ -1,5 +1,4 @@
-use std::io::Read;
-use std::io::Write;
+use std::io::{Read, Write};
 
 pub fn main() -> ! {
     let exit_code = run_main();

codex-rs/apply-patch/tests/suite/cli.rs

@@ -1,6 +1,7 @@
-use assert_cmd::prelude::*;
 use std::fs;
 use std::process::Command;
+
+use assert_cmd::prelude::*;
 use tempfile::tempdir;
 
 #[test]

codex-rs/apply-patch/tests/suite/tool.rs

@@ -1,7 +1,8 @@
-use assert_cmd::Command;
-use pretty_assertions::assert_eq;
 use std::fs;
 use std::path::Path;
+
+use assert_cmd::Command;
+use pretty_assertions::assert_eq;
 use tempfile::tempdir;
 
 fn run_apply_patch_in_dir(dir: &Path, patch: &str) -> anyhow::Result<assert_cmd::assert::Assert> {

codex-rs/arg0/src/lib.rs

@@ -1,10 +1,9 @@
 use std::future::Future;
-use std::path::Path;
-use std::path::PathBuf;
-
-use codex_core::CODEX_APPLY_PATCH_ARG1;
 #[cfg(unix)]
 use std::os::unix::fs::symlink;
+use std::path::{Path, PathBuf};
+
+use codex_core::CODEX_APPLY_PATCH_ARG1;
 use tempfile::TempDir;
 
 const LINUX_SANDBOX_ARG0: &str = "codex-linux-sandbox";

codex-rs/async-utils/src/lib.rs

@@ -1,5 +1,6 @@
-use async_trait::async_trait;
 use std::future::Future;
+
+use async_trait::async_trait;
 use tokio_util::sync::CancellationToken;
 
 #[derive(Debug, PartialEq, Eq)]
@@ -32,12 +33,14 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use pretty_assertions::assert_eq;
     use std::time::Duration;
+
+    use pretty_assertions::assert_eq;
     use tokio::task;
     use tokio::time::sleep;
 
+    use super::*;
+
     #[tokio::test]
     async fn returns_ok_when_future_completes_first() {
         let token = CancellationToken::new();

codex-rs/backend-client/src/client.rs

@@ -1,21 +1,17 @@
-use crate::types::CodeTaskDetailsResponse;
-use crate::types::PaginatedListTaskListItem;
-use crate::types::RateLimitStatusPayload;
-use crate::types::RateLimitWindowSnapshot;
-use crate::types::TurnAttemptsSiblingTurnsResponse;
 use anyhow::Result;
 use codex_core::auth::CodexAuth;
 use codex_core::default_client::get_codex_user_agent;
-use codex_protocol::protocol::RateLimitSnapshot;
-use codex_protocol::protocol::RateLimitWindow;
-use reqwest::header::AUTHORIZATION;
-use reqwest::header::CONTENT_TYPE;
-use reqwest::header::HeaderMap;
-use reqwest::header::HeaderName;
-use reqwest::header::HeaderValue;
-use reqwest::header::USER_AGENT;
+use codex_protocol::protocol::{RateLimitSnapshot, RateLimitWindow};
+use reqwest::header::{
+    AUTHORIZATION, CONTENT_TYPE, HeaderMap, HeaderName, HeaderValue, USER_AGENT,
+};
 use serde::de::DeserializeOwned;
 
+use crate::types::{
+    CodeTaskDetailsResponse, PaginatedListTaskListItem, RateLimitStatusPayload,
+    RateLimitWindowSnapshot, TurnAttemptsSiblingTurnsResponse,
+};
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum PathStyle {
     /// /api/codex/…

codex-rs/backend-client/src/lib.rs

@@ -2,8 +2,7 @@ mod client;
 pub mod types;
 
 pub use client::Client;
-pub use types::CodeTaskDetailsResponse;
-pub use types::CodeTaskDetailsResponseExt;
-pub use types::PaginatedListTaskListItem;
-pub use types::TaskListItem;
-pub use types::TurnAttemptsSiblingTurnsResponse;
+pub use types::{
+    CodeTaskDetailsResponse, CodeTaskDetailsResponseExt, PaginatedListTaskListItem, TaskListItem,
+    TurnAttemptsSiblingTurnsResponse,
+};

codex-rs/backend-client/src/types.rs

@@ -1,14 +1,12 @@
-pub use codex_backend_openapi_models::models::PaginatedListTaskListItem;
-pub use codex_backend_openapi_models::models::PlanType;
-pub use codex_backend_openapi_models::models::RateLimitStatusDetails;
-pub use codex_backend_openapi_models::models::RateLimitStatusPayload;
-pub use codex_backend_openapi_models::models::RateLimitWindowSnapshot;
-pub use codex_backend_openapi_models::models::TaskListItem;
+use std::collections::HashMap;
 
+pub use codex_backend_openapi_models::models::{
+    PaginatedListTaskListItem, PlanType, RateLimitStatusDetails, RateLimitStatusPayload,
+    RateLimitWindowSnapshot, TaskListItem,
+};
 use serde::Deserialize;
 use serde::de::Deserializer;
 use serde_json::Value;
-use std::collections::HashMap;
 
 /// Hand-rolled models for the Cloud Tasks task-details response.
 /// The generated OpenAPI models are pretty bad. This is a half-step
@@ -317,9 +315,10 @@ pub struct TurnAttemptsSiblingTurnsResponse {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use pretty_assertions::assert_eq;
 
+    use super::*;
+
     fn fixture(name: &str) -> CodeTaskDetailsResponse {
         let json = match name {
             "diff" => include_str!("../tests/fixtures/task_details_with_diff.json"),

codex-rs/chatgpt/src/apply_command.rs

@@ -2,14 +2,10 @@ use std::path::PathBuf;
 
 use clap::Parser;
 use codex_common::CliConfigOverrides;
-use codex_core::config::Config;
-use codex_core::config::ConfigOverrides;
+use codex_core::config::{Config, ConfigOverrides};
 
 use crate::chatgpt_token::init_chatgpt_token_from_auth;
-use crate::get_task::GetTaskResponse;
-use crate::get_task::OutputItem;
-use crate::get_task::PrOutputItem;
-use crate::get_task::get_task;
+use crate::get_task::{GetTaskResponse, OutputItem, PrOutputItem, get_task};
 
 /// Applies the latest diff from a Codex agent task.
 #[derive(Debug, Parser)]

codex-rs/chatgpt/src/chatgpt_client.rs

@@ -1,12 +1,10 @@
+use anyhow::Context;
 use codex_core::config::Config;
 use codex_core::default_client::create_client;
-
-use crate::chatgpt_token::get_chatgpt_token_data;
-use crate::chatgpt_token::init_chatgpt_token_from_auth;
-
-use anyhow::Context;
 use serde::de::DeserializeOwned;
 
+use crate::chatgpt_token::{get_chatgpt_token_data, init_chatgpt_token_from_auth};
+
 /// Make a GET request to the ChatGPT backend API.
 pub(crate) async fn chatgpt_get_request<T: DeserializeOwned>(
     config: &Config,

codex-rs/chatgpt/src/chatgpt_token.rs

@@ -1,8 +1,7 @@
-use codex_core::CodexAuth;
 use std::path::Path;
-use std::sync::LazyLock;
-use std::sync::RwLock;
+use std::sync::{LazyLock, RwLock};
 
+use codex_core::CodexAuth;
 use codex_core::auth::AuthCredentialsStoreMode;
 use codex_core::token_data::TokenData;
 

codex-rs/chatgpt/tests/suite/apply_command_e2e.rs

@@ -1,6 +1,7 @@
+use std::path::Path;
+
 use codex_chatgpt::apply_command::apply_diff_from_task;
 use codex_chatgpt::get_task::GetTaskResponse;
-use std::path::Path;
 use tempfile::TempDir;
 use tokio::process::Command;
 

codex-rs/cli/src/debug_sandbox.rs

@@ -1,18 +1,15 @@
 use std::path::PathBuf;
 
 use codex_common::CliConfigOverrides;
-use codex_core::config::Config;
-use codex_core::config::ConfigOverrides;
+use codex_core::config::{Config, ConfigOverrides};
 use codex_core::exec_env::create_env;
 use codex_core::landlock::spawn_command_under_linux_sandbox;
 use codex_core::seatbelt::spawn_command_under_seatbelt;
 use codex_core::spawn::StdioPolicy;
 use codex_protocol::config_types::SandboxMode;
 
-use crate::LandlockCommand;
-use crate::SeatbeltCommand;
-use crate::WindowsCommand;
 use crate::exit_status::handle_exit_status;
+use crate::{LandlockCommand, SeatbeltCommand, WindowsCommand};
 
 pub async fn run_command_under_seatbelt(
     command: SeatbeltCommand,

codex-rs/cli/src/login.rs

@@ -1,19 +1,13 @@
+use std::io::{IsTerminal, Read};
+use std::path::PathBuf;
+
 use codex_app_server_protocol::AuthMode;
 use codex_common::CliConfigOverrides;
 use codex_core::CodexAuth;
-use codex_core::auth::AuthCredentialsStoreMode;
-use codex_core::auth::CLIENT_ID;
-use codex_core::auth::login_with_api_key;
-use codex_core::auth::logout;
-use codex_core::config::Config;
-use codex_core::config::ConfigOverrides;
-use codex_login::ServerOptions;
-use codex_login::run_device_code_login;
-use codex_login::run_login_server;
+use codex_core::auth::{AuthCredentialsStoreMode, CLIENT_ID, login_with_api_key, logout};
+use codex_core::config::{Config, ConfigOverrides};
+use codex_login::{ServerOptions, run_device_code_login, run_login_server};
 use codex_protocol::config_types::ForcedLoginMethod;
-use std::io::IsTerminal;
-use std::io::Read;
-use std::path::PathBuf;
 
 pub async fn login_with_chatgpt(
     codex_home: PathBuf,

codex-rs/cli/src/main.rs

@@ -1,37 +1,30 @@
-use clap::CommandFactory;
-use clap::Parser;
-use clap_complete::Shell;
-use clap_complete::generate;
+use std::path::PathBuf;
+
+use clap::{CommandFactory, Parser};
+use clap_complete::{Shell, generate};
 use codex_arg0::arg0_dispatch_or_else;
-use codex_chatgpt::apply_command::ApplyCommand;
-use codex_chatgpt::apply_command::run_apply_command;
-use codex_cli::LandlockCommand;
-use codex_cli::SeatbeltCommand;
-use codex_cli::WindowsCommand;
-use codex_cli::login::read_api_key_from_stdin;
-use codex_cli::login::run_login_status;
-use codex_cli::login::run_login_with_api_key;
-use codex_cli::login::run_login_with_chatgpt;
-use codex_cli::login::run_login_with_device_code;
-use codex_cli::login::run_logout;
+use codex_chatgpt::apply_command::{ApplyCommand, run_apply_command};
+use codex_cli::login::{
+    read_api_key_from_stdin, run_login_status, run_login_with_api_key, run_login_with_chatgpt,
+    run_login_with_device_code, run_logout,
+};
+use codex_cli::{LandlockCommand, SeatbeltCommand, WindowsCommand};
 use codex_cloud_tasks::Cli as CloudTasksCli;
 use codex_common::CliConfigOverrides;
 use codex_exec::Cli as ExecCli;
 use codex_responses_api_proxy::Args as ResponsesApiProxyArgs;
-use codex_tui::AppExitInfo;
-use codex_tui::Cli as TuiCli;
 use codex_tui::updates::UpdateAction;
+use codex_tui::{AppExitInfo, Cli as TuiCli};
 use owo_colors::OwoColorize;
-use std::path::PathBuf;
 use supports_color::Stream;
 
 mod mcp_cmd;
 
-use crate::mcp_cmd::McpCli;
-use codex_core::config::Config;
-use codex_core::config::ConfigOverrides;
+use codex_core::config::{Config, ConfigOverrides};
 use codex_core::features::is_known_feature_key;
 
+use crate::mcp_cmd::McpCli;
+
 /// Codex CLI
 ///
 /// If no subcommand is specified, options will be forwarded to the interactive CLI.
@@ -632,12 +625,13 @@ fn print_completion(cmd: CompletionCommand) {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use assert_matches::assert_matches;
     use codex_core::protocol::TokenUsage;
     use codex_protocol::ConversationId;
     use pretty_assertions::assert_eq;
 
+    use super::*;
+
     fn finalize_from_args(args: &[&str]) -> TuiCli {
         let cli = MultitoolCli::try_parse_from(args).expect("parse");
         let MultitoolCli {

codex-rs/cli/src/mcp_cmd.rs

@@ -1,25 +1,16 @@
 use std::collections::HashMap;
 
-use anyhow::Context;
-use anyhow::Result;
-use anyhow::anyhow;
-use anyhow::bail;
+use anyhow::{Context, Result, anyhow, bail};
 use clap::ArgGroup;
 use codex_common::CliConfigOverrides;
 use codex_common::format_env_display::format_env_display;
-use codex_core::config::Config;
-use codex_core::config::ConfigOverrides;
 use codex_core::config::edit::ConfigEditsBuilder;
-use codex_core::config::find_codex_home;
-use codex_core::config::load_global_mcp_servers;
-use codex_core::config::types::McpServerConfig;
-use codex_core::config::types::McpServerTransportConfig;
+use codex_core::config::types::{McpServerConfig, McpServerTransportConfig};
+use codex_core::config::{Config, ConfigOverrides, find_codex_home, load_global_mcp_servers};
 use codex_core::features::Feature;
 use codex_core::mcp::auth::compute_auth_statuses;
 use codex_core::protocol::McpAuthStatus;
-use codex_rmcp_client::delete_oauth_tokens;
-use codex_rmcp_client::perform_oauth_login;
-use codex_rmcp_client::supports_oauth_login;
+use codex_rmcp_client::{delete_oauth_tokens, perform_oauth_login, supports_oauth_login};
 
 /// [experimental] Launch Codex as an MCP server or manage configured MCP servers.
 ///

codex-rs/cli/tests/mcp_list.rs

@@ -7,8 +7,7 @@ use codex_core::config::types::McpServerTransportConfig;
 use predicates::prelude::PredicateBooleanExt;
 use predicates::str::contains;
 use pretty_assertions::assert_eq;
-use serde_json::Value as JsonValue;
-use serde_json::json;
+use serde_json::{Value as JsonValue, json};
 use tempfile::TempDir;
 
 fn codex_command(codex_home: &Path) -> Result<assert_cmd::Command> {

codex-rs/cloud-tasks-client/src/api.rs

@@ -1,7 +1,5 @@
-use chrono::DateTime;
-use chrono::Utc;
-use serde::Deserialize;
-use serde::Serialize;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
 
 pub type Result<T> = std::result::Result<T, CloudTaskError>;
 

codex-rs/cloud-tasks-client/src/http.rs

@@ -1,21 +1,13 @@
-use crate::ApplyOutcome;
-use crate::ApplyStatus;
-use crate::AttemptStatus;
-use crate::CloudBackend;
-use crate::CloudTaskError;
-use crate::DiffSummary;
-use crate::Result;
-use crate::TaskId;
-use crate::TaskStatus;
-use crate::TaskSummary;
-use crate::TurnAttempt;
-use crate::api::TaskText;
-use chrono::DateTime;
-use chrono::Utc;
-
+use chrono::{DateTime, Utc};
 use codex_backend_client as backend;
 use codex_backend_client::CodeTaskDetailsResponseExt;
 
+use crate::api::TaskText;
+use crate::{
+    ApplyOutcome, ApplyStatus, AttemptStatus, CloudBackend, CloudTaskError, DiffSummary, Result,
+    TaskId, TaskStatus, TaskSummary, TurnAttempt,
+};
+
 #[derive(Clone)]
 pub struct HttpClient {
     pub base_url: String,
@@ -110,11 +102,13 @@ impl CloudBackend for HttpClient {
 }
 
 mod api {
-    use super::*;
-    use serde_json::Value;
     use std::cmp::Ordering;
     use std::collections::HashMap;
 
+    use serde_json::Value;
+
+    use super::*;
+
     pub(crate) struct Tasks<'a> {
         base_url: &'a str,
         backend: &'a backend::Client,

codex-rs/cloud-tasks-client/src/lib.rs

@@ -1,18 +1,9 @@
 mod api;
 
-pub use api::ApplyOutcome;
-pub use api::ApplyStatus;
-pub use api::AttemptStatus;
-pub use api::CloudBackend;
-pub use api::CloudTaskError;
-pub use api::CreatedTask;
-pub use api::DiffSummary;
-pub use api::Result;
-pub use api::TaskId;
-pub use api::TaskStatus;
-pub use api::TaskSummary;
-pub use api::TaskText;
-pub use api::TurnAttempt;
+pub use api::{
+    ApplyOutcome, ApplyStatus, AttemptStatus, CloudBackend, CloudTaskError, CreatedTask,
+    DiffSummary, Result, TaskId, TaskStatus, TaskSummary, TaskText, TurnAttempt,
+};
 
 #[cfg(feature = "mock")]
 mod mock;
@@ -20,10 +11,9 @@ mod mock;
 #[cfg(feature = "online")]
 mod http;
 
+#[cfg(feature = "online")]
+pub use http::HttpClient;
 #[cfg(feature = "mock")]
 pub use mock::MockClient;
 
-#[cfg(feature = "online")]
-pub use http::HttpClient;
-
 // Reusable apply engine now lives in the shared crate `codex-git`.

codex-rs/cloud-tasks-client/src/mock.rs

@@ -1,15 +1,11 @@
-use crate::ApplyOutcome;
-use crate::AttemptStatus;
-use crate::CloudBackend;
-use crate::DiffSummary;
-use crate::Result;
-use crate::TaskId;
-use crate::TaskStatus;
-use crate::TaskSummary;
-use crate::TurnAttempt;
-use crate::api::TaskText;
 use chrono::Utc;
 
+use crate::api::TaskText;
+use crate::{
+    ApplyOutcome, AttemptStatus, CloudBackend, DiffSummary, Result, TaskId, TaskStatus,
+    TaskSummary, TurnAttempt,
+};
+
 #[derive(Clone, Default)]
 pub struct MockClient;
 

codex-rs/cloud-tasks/src/app.rs

@@ -1,5 +1,4 @@
-use std::time::Duration;
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 // Environment filter data models for the TUI
 #[derive(Clone, Debug, Default)]
@@ -39,10 +38,9 @@ pub struct ApplyModalState {
     pub diff_override: Option<String>,
 }
 
+use codex_cloud_tasks_client::{CloudBackend, TaskId, TaskSummary};
+
 use crate::scrollable_diff::ScrollableDiff;
-use codex_cloud_tasks_client::CloudBackend;
-use codex_cloud_tasks_client::TaskId;
-use codex_cloud_tasks_client::TaskSummary;
 #[derive(Default)]
 pub struct App {
     pub tasks: Vec<TaskSummary>,
@@ -348,9 +346,10 @@ pub enum AppEvent {
 // Convenience aliases; currently unused.
 #[cfg(test)]
 mod tests {
-    use super::*;
     use chrono::Utc;
 
+    use super::*;
+
     struct FakeBackend {
         // maps env key to titles
         by_env: std::collections::HashMap<Option<String>, Vec<&'static str>>,

codex-rs/cloud-tasks/src/cli.rs

@@ -1,5 +1,4 @@
-use clap::Args;
-use clap::Parser;
+use clap::{Args, Parser};
 use codex_common::CliConfigOverrides;
 
 #[derive(Parser, Debug, Default)]

codex-rs/cloud-tasks/src/env_detect.rs

@@ -1,8 +1,7 @@
-use reqwest::header::CONTENT_TYPE;
-use reqwest::header::HeaderMap;
 use std::collections::HashMap;
-use tracing::info;
-use tracing::warn;
+
+use reqwest::header::{CONTENT_TYPE, HeaderMap};
+use tracing::{info, warn};
 
 #[derive(Debug, Clone, serde::Deserialize)]
 struct CodeEnvironment {

codex-rs/cloud-tasks/src/lib.rs

@@ -5,20 +5,17 @@ mod new_task;
 pub mod scrollable_diff;
 mod ui;
 pub mod util;
-pub use cli::Cli;
-
-use anyhow::anyhow;
-use std::io::IsTerminal;
-use std::io::Read;
+use std::io::{IsTerminal, Read};
 use std::path::PathBuf;
 use std::sync::Arc;
-use std::time::Duration;
-use std::time::Instant;
+use std::time::{Duration, Instant};
+
+use anyhow::anyhow;
+pub use cli::Cli;
 use tokio::sync::mpsc::UnboundedSender;
 use tracing::info;
 use tracing_subscriber::EnvFilter;
-use util::append_error_log;
-use util::set_user_agent_suffix;
+use util::{append_error_log, set_user_agent_suffix};
 
 struct ApplyJob {
     task_id: codex_cloud_tasks_client::TaskId,
@@ -354,15 +351,13 @@ pub async fn run_main(cli: Cli, _codex_linux_sandbox_exe: Option<PathBuf>) -> an
 
     // Terminal setup
     use crossterm::ExecutableCommand;
-    use crossterm::event::DisableBracketedPaste;
-    use crossterm::event::EnableBracketedPaste;
-    use crossterm::event::KeyboardEnhancementFlags;
-    use crossterm::event::PopKeyboardEnhancementFlags;
-    use crossterm::event::PushKeyboardEnhancementFlags;
-    use crossterm::terminal::EnterAlternateScreen;
-    use crossterm::terminal::LeaveAlternateScreen;
-    use crossterm::terminal::disable_raw_mode;
-    use crossterm::terminal::enable_raw_mode;
+    use crossterm::event::{
+        DisableBracketedPaste, EnableBracketedPaste, KeyboardEnhancementFlags,
+        PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
+    };
+    use crossterm::terminal::{
+        EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
+    };
     use ratatui::Terminal;
     use ratatui::backend::CrosstermBackend;
     let mut stdout = std::io::stdout();
@@ -406,11 +401,7 @@ pub async fn run_main(cli: Cli, _codex_linux_sandbox_exe: Option<PathBuf>) -> an
     // reset any in-flight enrichment state
 
     // Event stream
-    use crossterm::event::Event;
-    use crossterm::event::EventStream;
-    use crossterm::event::KeyCode;
-    use crossterm::event::KeyEventKind;
-    use crossterm::event::KeyModifiers;
+    use crossterm::event::{Event, EventStream, KeyCode, KeyEventKind, KeyModifiers};
     use tokio_stream::StreamExt;
     let mut events = EventStream::new();
 
@@ -464,8 +455,8 @@ pub async fn run_main(cli: Cli, _codex_linux_sandbox_exe: Option<PathBuf>) -> an
     // Event-driven redraws with a tiny coalescing scheduler (snappy UI, no fixed 250ms tick).
     let mut needs_redraw = true;
     use std::time::Instant;
-    use tokio::time::Instant as TokioInstant;
-    use tokio::time::sleep_until;
+
+    use tokio::time::{Instant as TokioInstant, sleep_until};
     let (frame_tx, mut frame_rx) = tokio::sync::mpsc::unbounded_channel::<Instant>();
     let (redraw_tx, mut redraw_rx) = tokio::sync::mpsc::unbounded_channel::<()>();
 
@@ -1723,11 +1714,8 @@ fn pretty_lines_from_error(raw: &str) -> Vec<String> {
 
 #[cfg(test)]
 mod tests {
-    use codex_tui::ComposerAction;
-    use codex_tui::ComposerInput;
-    use crossterm::event::KeyCode;
-    use crossterm::event::KeyEvent;
-    use crossterm::event::KeyModifiers;
+    use codex_tui::{ComposerAction, ComposerInput};
+    use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
     use ratatui::buffer::Buffer;
     use ratatui::layout::Rect;
 

codex-rs/cloud-tasks/src/scrollable_diff.rs

@@ -1,5 +1,4 @@
-use unicode_width::UnicodeWidthChar;
-use unicode_width::UnicodeWidthStr;
+use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
 
 /// Scroll position and geometry for a vertical scroll view.
 #[derive(Clone, Copy, Debug, Default)]

codex-rs/cloud-tasks/src/ui.rs

@@ -1,30 +1,17 @@
-use ratatui::layout::Constraint;
-use ratatui::layout::Direction;
-use ratatui::layout::Layout;
-use ratatui::prelude::*;
-use ratatui::style::Color;
-use ratatui::style::Modifier;
-use ratatui::style::Style;
-use ratatui::style::Stylize;
-use ratatui::widgets::Block;
-use ratatui::widgets::BorderType;
-use ratatui::widgets::Borders;
-use ratatui::widgets::Clear;
-use ratatui::widgets::List;
-use ratatui::widgets::ListItem;
-use ratatui::widgets::ListState;
-use ratatui::widgets::Padding;
-use ratatui::widgets::Paragraph;
 use std::sync::OnceLock;
 use std::time::Instant;
 
-use crate::app::App;
-use crate::app::AttemptView;
-use chrono::Local;
-use chrono::Utc;
-use codex_cloud_tasks_client::AttemptStatus;
-use codex_cloud_tasks_client::TaskStatus;
+use chrono::{Local, Utc};
+use codex_cloud_tasks_client::{AttemptStatus, TaskStatus};
 use codex_tui::render_markdown_text;
+use ratatui::layout::{Constraint, Direction, Layout};
+use ratatui::prelude::*;
+use ratatui::style::{Color, Modifier, Style, Stylize};
+use ratatui::widgets::{
+    Block, BorderType, Borders, Clear, List, ListItem, ListState, Padding, Paragraph,
+};
+
+use crate::app::{App, AttemptView};
 
 pub fn draw(frame: &mut Frame, app: &mut App) {
     let area = frame.area();
@@ -749,9 +736,7 @@ fn attempt_status_span(status: AttemptStatus) -> Option<ratatui::text::Span<'sta
 }
 
 fn style_diff_line(raw: &str) -> Line<'static> {
-    use ratatui::style::Color;
-    use ratatui::style::Modifier;
-    use ratatui::style::Style;
+    use ratatui::style::{Color, Modifier, Style};
     use ratatui::text::Span;
 
     if raw.starts_with("@@") {

codex-rs/cloud-tasks/src/util.rs

@@ -57,10 +57,7 @@ pub fn extract_chatgpt_account_id(token: &str) -> Option<String> {
 /// Build headers for ChatGPT-backed requests: `User-Agent`, optional `Authorization`,
 /// and optional `ChatGPT-Account-Id`.
 pub async fn build_chatgpt_headers() -> HeaderMap {
-    use reqwest::header::AUTHORIZATION;
-    use reqwest::header::HeaderName;
-    use reqwest::header::HeaderValue;
-    use reqwest::header::USER_AGENT;
+    use reqwest::header::{AUTHORIZATION, HeaderName, HeaderValue, USER_AGENT};
 
     set_user_agent_suffix("codex_cloud_tasks_tui");
     let ua = codex_core::default_client::get_codex_user_agent();

codex-rs/cloud-tasks/tests/env_filter.rs

@@ -1,5 +1,4 @@
-use codex_cloud_tasks_client::CloudBackend;
-use codex_cloud_tasks_client::MockClient;
+use codex_cloud_tasks_client::{CloudBackend, MockClient};
 
 #[tokio::test]
 async fn mock_backend_varies_by_env() {

codex-rs/codex-backend-openapi-models/src/models/code_task_details_response.rs

@@ -8,9 +8,9 @@
  * Generated by: https://openapi-generator.tech
  */
 
+use serde::{Deserialize, Serialize};
+
 use crate::models;
-use serde::Deserialize;
-use serde::Serialize;
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct CodeTaskDetailsResponse {

codex-rs/codex-backend-openapi-models/src/models/external_pull_request_response.rs

@@ -8,9 +8,9 @@
  * Generated by: https://openapi-generator.tech
  */
 
+use serde::{Deserialize, Serialize};
+
 use crate::models;
-use serde::Deserialize;
-use serde::Serialize;
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct ExternalPullRequestResponse {

codex-rs/codex-backend-openapi-models/src/models/git_pull_request.rs

@@ -8,8 +8,7 @@
  * Generated by: https://openapi-generator.tech
  */
 
-use serde::Deserialize;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct GitPullRequest {

codex-rs/codex-backend-openapi-models/src/models/mod.rs

@@ -24,8 +24,7 @@ pub use self::paginated_list_task_list_item_::PaginatedListTaskListItem;
 
 // Rate Limits
 pub mod rate_limit_status_payload;
-pub use self::rate_limit_status_payload::PlanType;
-pub use self::rate_limit_status_payload::RateLimitStatusPayload;
+pub use self::rate_limit_status_payload::{PlanType, RateLimitStatusPayload};
 
 pub mod rate_limit_status_details;
 pub use self::rate_limit_status_details::RateLimitStatusDetails;

codex-rs/codex-backend-openapi-models/src/models/paginated_list_task_list_item_.rs

@@ -8,9 +8,9 @@
  * Generated by: https://openapi-generator.tech
  */
 
+use serde::{Deserialize, Serialize};
+
 use crate::models;
-use serde::Deserialize;
-use serde::Serialize;
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct PaginatedListTaskListItem {

codex-rs/codex-backend-openapi-models/src/models/rate_limit_status_details.rs

@@ -8,9 +8,9 @@
  * Generated by: https://openapi-generator.tech
  */
 
+use serde::{Deserialize, Serialize};
+
 use crate::models;
-use serde::Deserialize;
-use serde::Serialize;
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct RateLimitStatusDetails {

codex-rs/codex-backend-openapi-models/src/models/rate_limit_status_payload.rs

@@ -8,9 +8,9 @@
  * Generated by: https://openapi-generator.tech
  */
 
+use serde::{Deserialize, Serialize};
+
 use crate::models;
-use serde::Deserialize;
-use serde::Serialize;
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct RateLimitStatusPayload {

codex-rs/codex-backend-openapi-models/src/models/rate_limit_window_snapshot.rs

@@ -8,8 +8,7 @@
  * Generated by: https://openapi-generator.tech
  */
 
-use serde::Deserialize;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct RateLimitWindowSnapshot {

codex-rs/codex-backend-openapi-models/src/models/task_list_item.rs

@@ -8,9 +8,9 @@
  * Generated by: https://openapi-generator.tech
  */
 
+use serde::{Deserialize, Serialize};
+
 use crate::models;
-use serde::Deserialize;
-use serde::Serialize;
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct TaskListItem {

codex-rs/codex-backend-openapi-models/src/models/task_response.rs

@@ -8,9 +8,9 @@
  * Generated by: https://openapi-generator.tech
  */
 
+use serde::{Deserialize, Serialize};
+
 use crate::models;
-use serde::Deserialize;
-use serde::Serialize;
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct TaskResponse {

codex-rs/common/src/approval_mode_cli_arg.rs

@@ -2,7 +2,6 @@
 //! Available when the `cli` feature is enabled for the crate.
 
 use clap::ValueEnum;
-
 use codex_core::protocol::AskForApproval;
 
 #[derive(Clone, Copy, Debug, ValueEnum)]

codex-rs/common/src/approval_presets.rs

@@ -1,5 +1,4 @@
-use codex_core::protocol::AskForApproval;
-use codex_core::protocol::SandboxPolicy;
+use codex_core::protocol::{AskForApproval, SandboxPolicy};
 
 /// A simple preset pairing an approval policy with a sandbox policy.
 #[derive(Debug, Clone)]

codex-rs/common/src/config_override.rs

@@ -7,8 +7,7 @@
 //! key/value pairs as well as to apply them onto a mutable
 //! `serde_json::Value` representing the configuration tree.
 
-use clap::ArgAction;
-use clap::Parser;
+use clap::{ArgAction, Parser};
 use serde::de::Error as SerdeError;
 use toml::Value;
 

codex-rs/common/src/elapsed.rs

@@ -1,5 +1,4 @@
-use std::time::Duration;
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 /// Returns a string representing the elapsed time since `start_time` like
 /// "1m 15s" or "1.50s".

codex-rs/core/src/apply_patch.rs

@@ -1,15 +1,13 @@
-use crate::codex::Session;
-use crate::codex::TurnContext;
-use crate::function_tool::FunctionCallError;
-use crate::protocol::FileChange;
-use crate::protocol::ReviewDecision;
-use crate::safety::SafetyCheck;
-use crate::safety::assess_patch_safety;
-use codex_apply_patch::ApplyPatchAction;
-use codex_apply_patch::ApplyPatchFileChange;
 use std::collections::HashMap;
 use std::path::PathBuf;
 
+use codex_apply_patch::{ApplyPatchAction, ApplyPatchFileChange};
+
+use crate::codex::{Session, TurnContext};
+use crate::function_tool::FunctionCallError;
+use crate::protocol::{FileChange, ReviewDecision};
+use crate::safety::{SafetyCheck, assess_patch_safety};
+
 pub const CODEX_APPLY_PATCH_ARG1: &str = "--codex-run-as-apply-patch";
 
 pub(crate) enum InternalApplyPatchInvocation {
@@ -118,11 +116,11 @@ pub(crate) fn convert_apply_patch_to_protocol(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use pretty_assertions::assert_eq;
-
     use tempfile::tempdir;
 
+    use super::*;
+
     #[test]
     fn convert_apply_patch_maps_add_variant() {
         let tmp = tempdir().expect("tmp");

codex-rs/core/src/auth.rs

@@ -1,37 +1,29 @@
 mod storage;
 
-use chrono::Utc;
-use reqwest::StatusCode;
-use serde::Deserialize;
-use serde::Serialize;
-#[cfg(test)]
-use serial_test::serial;
 use std::env;
 use std::fmt::Debug;
 use std::io::ErrorKind;
-use std::path::Path;
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::sync::Mutex;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
+use chrono::Utc;
 use codex_app_server_protocol::AuthMode;
 use codex_protocol::config_types::ForcedLoginMethod;
+use reqwest::StatusCode;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+#[cfg(test)]
+use serial_test::serial;
+use thiserror::Error;
 
-pub use crate::auth::storage::AuthCredentialsStoreMode;
-pub use crate::auth::storage::AuthDotJson;
-use crate::auth::storage::AuthStorageBackend;
-use crate::auth::storage::create_auth_storage;
+pub use crate::auth::storage::{AuthCredentialsStoreMode, AuthDotJson};
+use crate::auth::storage::{AuthStorageBackend, create_auth_storage};
 use crate::config::Config;
 use crate::default_client::CodexHttpClient;
-use crate::error::RefreshTokenFailedError;
-use crate::error::RefreshTokenFailedReason;
-use crate::token_data::PlanType;
-use crate::token_data::TokenData;
-use crate::token_data::parse_id_token;
+use crate::error::{RefreshTokenFailedError, RefreshTokenFailedReason};
+use crate::token_data::{PlanType, TokenData, parse_id_token};
 use crate::util::try_parse_error_message;
-use serde_json::Value;
-use thiserror::Error;
 
 #[derive(Debug, Clone)]
 pub struct CodexAuth {
@@ -602,16 +594,6 @@ struct CachedAuth {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::auth::storage::FileAuthStorage;
-    use crate::auth::storage::get_auth_file;
-    use crate::config::Config;
-    use crate::config::ConfigOverrides;
-    use crate::config::ConfigToml;
-    use crate::token_data::IdTokenInfo;
-    use crate::token_data::KnownPlan;
-    use crate::token_data::PlanType;
-
     use base64::Engine;
     use codex_protocol::config_types::ForcedLoginMethod;
     use pretty_assertions::assert_eq;
@@ -619,6 +601,11 @@ mod tests {
     use serde_json::json;
     use tempfile::tempdir;
 
+    use super::*;
+    use crate::auth::storage::{FileAuthStorage, get_auth_file};
+    use crate::config::{Config, ConfigOverrides, ConfigToml};
+    use crate::token_data::{IdTokenInfo, KnownPlan, PlanType};
+
     #[tokio::test]
     async fn refresh_without_id_token() {
         let codex_home = tempdir().unwrap();

codex-rs/core/src/auth/storage.rs

@@ -1,24 +1,18 @@
-use chrono::DateTime;
-use chrono::Utc;
-use serde::Deserialize;
-use serde::Serialize;
-use sha2::Digest;
-use sha2::Sha256;
 use std::fmt::Debug;
-use std::fs::File;
-use std::fs::OpenOptions;
-use std::io::Read;
-use std::io::Write;
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Write};
 #[cfg(unix)]
 use std::os::unix::fs::OpenOptionsExt;
-use std::path::Path;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
+
+use chrono::{DateTime, Utc};
+use codex_keyring_store::{DefaultKeyringStore, KeyringStore};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
 use tracing::warn;
 
 use crate::token_data::TokenData;
-use codex_keyring_store::DefaultKeyringStore;
-use codex_keyring_store::KeyringStore;
 
 /// Determine where Codex should store CLI auth credentials.
 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -279,16 +273,16 @@ fn create_auth_storage_with_keyring_store(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::token_data::IdTokenInfo;
     use anyhow::Context;
     use base64::Engine;
+    use codex_keyring_store::tests::MockKeyringStore;
+    use keyring::Error as KeyringError;
     use pretty_assertions::assert_eq;
     use serde_json::json;
     use tempfile::tempdir;
 
-    use codex_keyring_store::tests::MockKeyringStore;
-    use keyring::Error as KeyringError;
+    use super::*;
+    use crate::token_data::IdTokenInfo;
 
     #[tokio::test]
     async fn file_storage_load_returns_auth_dot_json() -> anyhow::Result<()> {

codex-rs/core/src/bash.rs

@@ -1,6 +1,4 @@
-use tree_sitter::Node;
-use tree_sitter::Parser;
-use tree_sitter::Tree;
+use tree_sitter::{Node, Parser, Tree};
 use tree_sitter_bash::LANGUAGE as BASH;
 
 /// Parse the provided bash source using tree-sitter-bash, returning a Tree on

codex-rs/core/src/chat_completions.rs

@@ -1,40 +1,31 @@
+use std::pin::Pin;
+use std::task::{Context, Poll};
 use std::time::Duration;
 
+use bytes::Bytes;
+use codex_otel::otel_event_manager::OtelEventManager;
+use codex_protocol::models::{
+    ContentItem, FunctionCallOutputContentItem, ReasoningItemContent, ResponseItem,
+};
+use codex_protocol::protocol::{SessionSource, SubAgentSource};
+use eventsource_stream::Eventsource;
+use futures::{Stream, StreamExt, TryStreamExt};
+use reqwest::StatusCode;
+use serde_json::json;
+use tokio::sync::mpsc;
+use tokio::time::timeout;
+use tracing::{debug, trace};
+
 use crate::ModelProviderInfo;
-use crate::client_common::Prompt;
-use crate::client_common::ResponseEvent;
-use crate::client_common::ResponseStream;
+use crate::client_common::{Prompt, ResponseEvent, ResponseStream};
 use crate::default_client::CodexHttpClient;
-use crate::error::CodexErr;
-use crate::error::ConnectionFailedError;
-use crate::error::ResponseStreamFailed;
-use crate::error::Result;
-use crate::error::RetryLimitReachedError;
-use crate::error::UnexpectedResponseError;
+use crate::error::{
+    CodexErr, ConnectionFailedError, ResponseStreamFailed, Result, RetryLimitReachedError,
+    UnexpectedResponseError,
+};
 use crate::model_family::ModelFamily;
 use crate::tools::spec::create_tools_json_for_chat_completions_api;
 use crate::util::backoff;
-use bytes::Bytes;
-use codex_otel::otel_event_manager::OtelEventManager;
-use codex_protocol::models::ContentItem;
-use codex_protocol::models::FunctionCallOutputContentItem;
-use codex_protocol::models::ReasoningItemContent;
-use codex_protocol::models::ResponseItem;
-use codex_protocol::protocol::SessionSource;
-use codex_protocol::protocol::SubAgentSource;
-use eventsource_stream::Eventsource;
-use futures::Stream;
-use futures::StreamExt;
-use futures::TryStreamExt;
-use reqwest::StatusCode;
-use serde_json::json;
-use std::pin::Pin;
-use std::task::Context;
-use std::task::Poll;
-use tokio::sync::mpsc;
-use tokio::time::timeout;
-use tracing::debug;
-use tracing::trace;
 
 /// Implementation for the classic Chat Completions API.
 pub(crate) async fn stream_chat_completions(

codex-rs/core/src/client.rs

@@ -1,17 +1,16 @@
 use std::io::BufRead;
 use std::path::Path;
-use std::sync::Arc;
-use std::sync::OnceLock;
+use std::sync::{Arc, OnceLock};
 use std::time::Duration;
 
 use bytes::Bytes;
-use chrono::DateTime;
-use chrono::Utc;
+use chrono::{DateTime, Utc};
 use codex_app_server_protocol::AuthMode;
 use codex_otel::otel_event_manager::OtelEventManager;
 use codex_protocol::ConversationId;
-use codex_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
-use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
+use codex_protocol::config_types::{
+    ReasoningEffort as ReasoningEffortConfig, ReasoningSummary as ReasoningSummaryConfig,
+};
 use codex_protocol::models::ResponseItem;
 use codex_protocol::protocol::SessionSource;
 use eventsource_stream::Eventsource;
@@ -19,45 +18,31 @@ use futures::prelude::*;
 use regex_lite::Regex;
 use reqwest::StatusCode;
 use reqwest::header::HeaderMap;
-use serde::Deserialize;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use tokio::sync::mpsc;
 use tokio::time::timeout;
 use tokio_util::io::ReaderStream;
-use tracing::debug;
-use tracing::trace;
-use tracing::warn;
+use tracing::{debug, trace, warn};
 
 use crate::AuthManager;
-use crate::auth::CodexAuth;
-use crate::auth::RefreshTokenError;
-use crate::chat_completions::AggregateStreamExt;
-use crate::chat_completions::stream_chat_completions;
-use crate::client_common::Prompt;
-use crate::client_common::ResponseEvent;
-use crate::client_common::ResponseStream;
-use crate::client_common::ResponsesApiRequest;
-use crate::client_common::create_reasoning_param_for_request;
-use crate::client_common::create_text_param_for_request;
+use crate::auth::{CodexAuth, RefreshTokenError};
+use crate::chat_completions::{AggregateStreamExt, stream_chat_completions};
+use crate::client_common::{
+    Prompt, ResponseEvent, ResponseStream, ResponsesApiRequest, create_reasoning_param_for_request,
+    create_text_param_for_request,
+};
 use crate::config::Config;
-use crate::default_client::CodexHttpClient;
-use crate::default_client::create_client;
-use crate::error::CodexErr;
-use crate::error::ConnectionFailedError;
-use crate::error::ResponseStreamFailed;
-use crate::error::Result;
-use crate::error::RetryLimitReachedError;
-use crate::error::UnexpectedResponseError;
-use crate::error::UsageLimitReachedError;
+use crate::default_client::{CodexHttpClient, create_client};
+use crate::error::{
+    CodexErr, ConnectionFailedError, ResponseStreamFailed, Result, RetryLimitReachedError,
+    UnexpectedResponseError, UsageLimitReachedError,
+};
 use crate::flags::CODEX_RS_SSE_FIXTURE;
 use crate::model_family::ModelFamily;
-use crate::model_provider_info::ModelProviderInfo;
-use crate::model_provider_info::WireApi;
+use crate::model_provider_info::{ModelProviderInfo, WireApi};
 use crate::openai_model_info::get_model_info;
-use crate::protocol::RateLimitSnapshot;
-use crate::protocol::RateLimitWindow;
-use crate::protocol::TokenUsage;
+use crate::protocol::{RateLimitSnapshot, RateLimitWindow, TokenUsage};
 use crate::token_data::PlanType;
 use crate::tools::spec::create_tools_json_for_responses_api;
 use crate::util::backoff;
@@ -977,13 +962,14 @@ fn is_context_window_error(error: &Error) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use assert_matches::assert_matches;
     use serde_json::json;
     use tokio::sync::mpsc;
     use tokio_test::io::Builder as IoBuilder;
     use tokio_util::io::ReaderStream;
 
+    use super::*;
+
     // ────────────────────────────
     // Helpers
     // ────────────────────────────
@@ -1451,8 +1437,7 @@ mod tests {
 
     #[test]
     fn error_response_deserializes_schema_known_plan_type_and_serializes_back() {
-        use crate::token_data::KnownPlan;
-        use crate::token_data::PlanType;
+        use crate::token_data::{KnownPlan, PlanType};
 
         let json =
             r#"{"error":{"type":"usage_limit_reached","plan_type":"pro","resets_at":1704067200}}"#;

codex-rs/core/src/client_common.rs

@@ -1,25 +1,25 @@
-use crate::client_common::tools::ToolSpec;
-use crate::error::Result;
-use crate::model_family::ModelFamily;
-use crate::protocol::RateLimitSnapshot;
-use crate::protocol::TokenUsage;
-use codex_apply_patch::APPLY_PATCH_TOOL_INSTRUCTIONS;
-use codex_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
-use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
-use codex_protocol::config_types::Verbosity as VerbosityConfig;
-use codex_protocol::models::ResponseItem;
-use futures::Stream;
-use serde::Deserialize;
-use serde::Serialize;
-use serde_json::Value;
 use std::borrow::Cow;
 use std::collections::HashSet;
 use std::ops::Deref;
 use std::pin::Pin;
-use std::task::Context;
-use std::task::Poll;
+use std::task::{Context, Poll};
+
+use codex_apply_patch::APPLY_PATCH_TOOL_INSTRUCTIONS;
+use codex_protocol::config_types::{
+    ReasoningEffort as ReasoningEffortConfig, ReasoningSummary as ReasoningSummaryConfig,
+    Verbosity as VerbosityConfig,
+};
+use codex_protocol::models::ResponseItem;
+use futures::Stream;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use tokio::sync::mpsc;
 
+use crate::client_common::tools::ToolSpec;
+use crate::error::Result;
+use crate::model_family::ModelFamily;
+use crate::protocol::{RateLimitSnapshot, TokenUsage};
+
 /// Review thread system prompt. Edit `core/src/review_prompt.md` to customize.
 pub const REVIEW_PROMPT: &str = include_str!("../review_prompt.md");
 
@@ -284,9 +284,9 @@ pub(crate) struct ResponsesApiRequest<'a> {
 }
 
 pub(crate) mod tools {
+    use serde::{Deserialize, Serialize};
+
     use crate::tools::spec::JsonSchema;
-    use serde::Deserialize;
-    use serde::Serialize;
 
     /// When serialized as JSON, this produces a valid "Tool" in the OpenAI
     /// Responses API.
@@ -390,10 +390,10 @@ impl Stream for ResponseStream {
 
 #[cfg(test)]
 mod tests {
-    use crate::model_family::find_family_for_model;
     use pretty_assertions::assert_eq;
 
     use super::*;
+    use crate::model_family::find_family_for_model;
 
     struct InstructionsTestCase {
         pub slug: &'static str,

codex-rs/core/src/codex.rs

@@ -4,134 +4,83 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::sync::atomic::AtomicU64;
 
-use crate::AuthManager;
-use crate::client_common::REVIEW_PROMPT;
-use crate::features::Feature;
-use crate::function_tool::FunctionCallError;
-use crate::mcp::auth::McpAuthStatusEntry;
-use crate::mcp_connection_manager::DEFAULT_STARTUP_TIMEOUT;
-use crate::parse_command::parse_command;
-use crate::parse_turn_item;
-use crate::response_processing::process_items;
-use crate::terminal;
-use crate::user_notification::UserNotifier;
-use crate::util::error_or_panic;
-use async_channel::Receiver;
-use async_channel::Sender;
+use async_channel::{Receiver, Sender};
+use codex_async_utils::OrCancelExt;
+use codex_otel::otel_event_manager::OtelEventManager;
 use codex_protocol::ConversationId;
+use codex_protocol::config_types::{
+    ReasoningEffort as ReasoningEffortConfig, ReasoningSummary as ReasoningSummaryConfig,
+};
 use codex_protocol::items::TurnItem;
-use codex_protocol::protocol::FileChange;
-use codex_protocol::protocol::HasLegacyEvent;
-use codex_protocol::protocol::ItemCompletedEvent;
-use codex_protocol::protocol::ItemStartedEvent;
-use codex_protocol::protocol::RawResponseItemEvent;
-use codex_protocol::protocol::ReviewRequest;
-use codex_protocol::protocol::RolloutItem;
-use codex_protocol::protocol::SessionSource;
-use codex_protocol::protocol::TaskStartedEvent;
-use codex_protocol::protocol::TurnAbortReason;
-use codex_protocol::protocol::TurnContextItem;
+use codex_protocol::models::{
+    ContentItem, FunctionCallOutputPayload, ResponseInputItem, ResponseItem,
+};
+use codex_protocol::protocol::{
+    FileChange, HasLegacyEvent, InitialHistory, ItemCompletedEvent, ItemStartedEvent,
+    RawResponseItemEvent, ReviewRequest, RolloutItem, SessionSource, TaskStartedEvent,
+    TurnAbortReason, TurnContextItem,
+};
+use codex_protocol::user_input::UserInput;
+use codex_utils_readiness::{Readiness, ReadinessFlag};
 use futures::future::BoxFuture;
 use futures::prelude::*;
 use futures::stream::FuturesOrdered;
-use mcp_types::CallToolResult;
-use mcp_types::ListResourceTemplatesRequestParams;
-use mcp_types::ListResourceTemplatesResult;
-use mcp_types::ListResourcesRequestParams;
-use mcp_types::ListResourcesResult;
-use mcp_types::ReadResourceRequestParams;
-use mcp_types::ReadResourceResult;
+use mcp_types::{
+    CallToolResult, ListResourceTemplatesRequestParams, ListResourceTemplatesResult,
+    ListResourcesRequestParams, ListResourcesResult, ReadResourceRequestParams, ReadResourceResult,
+};
 use serde_json;
 use serde_json::Value;
-use tokio::sync::Mutex;
-use tokio::sync::oneshot;
+use tokio::sync::{Mutex, oneshot};
 use tokio_util::sync::CancellationToken;
-use tracing::debug;
-use tracing::error;
-use tracing::info;
-use tracing::warn;
+use tracing::{debug, error, info, warn};
 
-use crate::ModelProviderInfo;
 use crate::client::ModelClient;
-use crate::client_common::Prompt;
-use crate::client_common::ResponseEvent;
+use crate::client_common::{Prompt, REVIEW_PROMPT, ResponseEvent};
 use crate::config::Config;
-use crate::config::types::McpServerTransportConfig;
-use crate::config::types::ShellEnvironmentPolicy;
+use crate::config::types::{McpServerTransportConfig, ShellEnvironmentPolicy};
 use crate::context_manager::ContextManager;
 use crate::environment_context::EnvironmentContext;
-use crate::error::CodexErr;
-use crate::error::Result as CodexResult;
+use crate::error::{CodexErr, Result as CodexResult};
 #[cfg(test)]
 use crate::exec::StreamOutput;
+use crate::features::Feature;
+use crate::function_tool::FunctionCallError;
+use crate::mcp::auth::McpAuthStatusEntry;
 // Removed: legacy executor wiring replaced by ToolOrchestrator flows.
 // legacy normalize_exec_result no longer used after orchestrator migration
 use crate::mcp::auth::compute_auth_statuses;
-use crate::mcp_connection_manager::McpConnectionManager;
+use crate::mcp_connection_manager::{DEFAULT_STARTUP_TIMEOUT, McpConnectionManager};
 use crate::model_family::find_family_for_model;
 use crate::openai_model_info::get_model_info;
+use crate::parse_command::parse_command;
 use crate::project_doc::get_user_instructions;
-use crate::protocol::AgentMessageContentDeltaEvent;
-use crate::protocol::AgentReasoningSectionBreakEvent;
-use crate::protocol::ApplyPatchApprovalRequestEvent;
-use crate::protocol::AskForApproval;
-use crate::protocol::BackgroundEventEvent;
-use crate::protocol::DeprecationNoticeEvent;
-use crate::protocol::ErrorEvent;
-use crate::protocol::Event;
-use crate::protocol::EventMsg;
-use crate::protocol::ExecApprovalRequestEvent;
-use crate::protocol::Op;
-use crate::protocol::RateLimitSnapshot;
-use crate::protocol::ReasoningContentDeltaEvent;
-use crate::protocol::ReasoningRawContentDeltaEvent;
-use crate::protocol::ReviewDecision;
-use crate::protocol::SandboxCommandAssessment;
-use crate::protocol::SandboxPolicy;
-use crate::protocol::SessionConfiguredEvent;
-use crate::protocol::StreamErrorEvent;
-use crate::protocol::Submission;
-use crate::protocol::TokenCountEvent;
-use crate::protocol::TokenUsage;
-use crate::protocol::TurnDiffEvent;
-use crate::rollout::RolloutRecorder;
-use crate::rollout::RolloutRecorderParams;
-use crate::shell;
-use crate::state::ActiveTurn;
-use crate::state::SessionServices;
-use crate::state::SessionState;
-use crate::tasks::GhostSnapshotTask;
-use crate::tasks::ReviewTask;
-use crate::tasks::SessionTask;
-use crate::tasks::SessionTaskContext;
+use crate::protocol::{
+    AgentMessageContentDeltaEvent, AgentReasoningSectionBreakEvent, ApplyPatchApprovalRequestEvent,
+    AskForApproval, BackgroundEventEvent, DeprecationNoticeEvent, ErrorEvent, Event, EventMsg,
+    ExecApprovalRequestEvent, Op, RateLimitSnapshot, ReasoningContentDeltaEvent,
+    ReasoningRawContentDeltaEvent, ReviewDecision, SandboxCommandAssessment, SandboxPolicy,
+    SessionConfiguredEvent, StreamErrorEvent, Submission, TokenCountEvent, TokenUsage,
+    TurnDiffEvent,
+};
+use crate::response_processing::process_items;
+use crate::rollout::{RolloutRecorder, RolloutRecorderParams};
+use crate::state::{ActiveTurn, SessionServices, SessionState};
+use crate::tasks::{GhostSnapshotTask, ReviewTask, SessionTask, SessionTaskContext};
 use crate::tools::ToolRouter;
 use crate::tools::context::SharedTurnDiffTracker;
 use crate::tools::parallel::ToolCallRuntime;
 use crate::tools::sandboxing::ApprovalStore;
-use crate::tools::spec::ToolsConfig;
-use crate::tools::spec::ToolsConfigParams;
+use crate::tools::spec::{ToolsConfig, ToolsConfigParams};
 use crate::turn_diff_tracker::TurnDiffTracker;
 use crate::unified_exec::UnifiedExecSessionManager;
-use crate::user_instructions::DeveloperInstructions;
-use crate::user_instructions::UserInstructions;
-use crate::user_notification::UserNotification;
-use crate::util::backoff;
-use codex_async_utils::OrCancelExt;
-use codex_otel::otel_event_manager::OtelEventManager;
-use codex_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
-use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
-use codex_protocol::models::ContentItem;
-use codex_protocol::models::FunctionCallOutputPayload;
-use codex_protocol::models::ResponseInputItem;
-use codex_protocol::models::ResponseItem;
-use codex_protocol::protocol::InitialHistory;
-use codex_protocol::user_input::UserInput;
-use codex_utils_readiness::Readiness;
-use codex_utils_readiness::ReadinessFlag;
+use crate::user_instructions::{DeveloperInstructions, UserInstructions};
+use crate::user_notification::{UserNotification, UserNotifier};
+use crate::util::{backoff, error_or_panic};
+use crate::{AuthManager, ModelProviderInfo, parse_turn_item, shell, terminal};
 
 pub mod compact;
-use self::compact::build_compacted_history;
-use self::compact::collect_user_messages;
+use self::compact::{build_compacted_history, collect_user_messages};
 
 /// The high-level interface to the Codex system.
 /// It operates as a queue pair where you send submissions and receive events.
@@ -1338,30 +1287,20 @@ async fn submission_loop(sess: Arc<Session>, config: Arc<Config>, rx_sub: Receiv
 
 /// Operation handlers
 mod handlers {
-    use crate::codex::Session;
-    use crate::codex::SessionSettingsUpdate;
-    use crate::codex::TurnContext;
+    use std::sync::Arc;
 
-    use crate::codex::spawn_review_thread;
+    use codex_protocol::custom_prompts::CustomPrompt;
+    use codex_protocol::protocol::{
+        ErrorEvent, Event, EventMsg, ListCustomPromptsResponseEvent, Op, ReviewDecision,
+        ReviewRequest, TurnAbortReason,
+    };
+    use codex_protocol::user_input::UserInput;
+    use tracing::{info, warn};
+
+    use crate::codex::{Session, SessionSettingsUpdate, TurnContext, spawn_review_thread};
     use crate::config::Config;
     use crate::mcp::auth::compute_auth_statuses;
-    use crate::tasks::CompactTask;
-    use crate::tasks::RegularTask;
-    use crate::tasks::UndoTask;
-    use crate::tasks::UserShellCommandTask;
-    use codex_protocol::custom_prompts::CustomPrompt;
-    use codex_protocol::protocol::ErrorEvent;
-    use codex_protocol::protocol::Event;
-    use codex_protocol::protocol::EventMsg;
-    use codex_protocol::protocol::ListCustomPromptsResponseEvent;
-    use codex_protocol::protocol::Op;
-    use codex_protocol::protocol::ReviewDecision;
-    use codex_protocol::protocol::ReviewRequest;
-    use codex_protocol::protocol::TurnAbortReason;
-    use codex_protocol::user_input::UserInput;
-    use std::sync::Arc;
-    use tracing::info;
-    use tracing::warn;
+    use crate::tasks::{CompactTask, RegularTask, UndoTask, UserShellCommandTask};
 
     pub async fn interrupt(sess: &Arc<Session>) {
         sess.interrupt_task().await;
@@ -2294,49 +2233,39 @@ fn is_mcp_client_startup_timeout_error(error: &anyhow::Error) -> bool {
         || error_message.contains("timed out handshaking with MCP server")
 }
 
-use crate::features::Features;
 #[cfg(test)]
 pub(crate) use tests::make_session_and_context;
 
+use crate::features::Features;
+
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::config::ConfigOverrides;
-    use crate::config::ConfigToml;
-    use crate::config::types::McpServerConfig;
-    use crate::config::types::McpServerTransportConfig;
-    use crate::exec::ExecToolCallOutput;
-    use crate::mcp::auth::McpAuthStatusEntry;
-    use crate::tools::format_exec_output_str;
+    use std::path::PathBuf;
+    use std::sync::Arc;
+    use std::time::{Duration, Duration as StdDuration};
 
-    use crate::protocol::CompactedItem;
-    use crate::protocol::InitialHistory;
-    use crate::protocol::ResumedHistory;
-    use crate::state::TaskKind;
-    use crate::tasks::SessionTask;
-    use crate::tasks::SessionTaskContext;
-    use crate::tools::ToolRouter;
-    use crate::tools::context::ToolInvocation;
-    use crate::tools::context::ToolOutput;
-    use crate::tools::context::ToolPayload;
-    use crate::tools::handlers::ShellHandler;
-    use crate::tools::registry::ToolHandler;
-    use crate::turn_diff_tracker::TurnDiffTracker;
     use codex_app_server_protocol::AuthMode;
-    use codex_protocol::models::ContentItem;
-    use codex_protocol::models::ResponseItem;
+    use codex_protocol::models::{ContentItem, ResponseItem};
     use codex_protocol::protocol::McpAuthStatus;
-    use std::time::Duration;
-    use tokio::time::sleep;
-
-    use mcp_types::ContentBlock;
-    use mcp_types::TextContent;
+    use mcp_types::{ContentBlock, TextContent};
     use pretty_assertions::assert_eq;
     use serde::Deserialize;
     use serde_json::json;
-    use std::path::PathBuf;
-    use std::sync::Arc;
-    use std::time::Duration as StdDuration;
+    use tokio::time::sleep;
+
+    use super::*;
+    use crate::config::types::{McpServerConfig, McpServerTransportConfig};
+    use crate::config::{ConfigOverrides, ConfigToml};
+    use crate::exec::ExecToolCallOutput;
+    use crate::mcp::auth::McpAuthStatusEntry;
+    use crate::protocol::{CompactedItem, InitialHistory, ResumedHistory};
+    use crate::state::TaskKind;
+    use crate::tasks::{SessionTask, SessionTaskContext};
+    use crate::tools::context::{ToolInvocation, ToolOutput, ToolPayload};
+    use crate::tools::handlers::ShellHandler;
+    use crate::tools::registry::ToolHandler;
+    use crate::tools::{ToolRouter, format_exec_output_str};
+    use crate::turn_diff_tracker::TurnDiffTracker;
 
     #[test]
     fn reconstruct_history_matches_live_compactions() {
@@ -2934,12 +2863,12 @@ mod tests {
 
     #[tokio::test]
     async fn rejects_escalated_permissions_when_policy_not_on_request() {
-        use crate::exec::ExecParams;
-        use crate::protocol::AskForApproval;
-        use crate::protocol::SandboxPolicy;
-        use crate::turn_diff_tracker::TurnDiffTracker;
         use std::collections::HashMap;
 
+        use crate::exec::ExecParams;
+        use crate::protocol::{AskForApproval, SandboxPolicy};
+        use crate::turn_diff_tracker::TurnDiffTracker;
+
         let (session, mut turn_context_raw) = make_session_and_context();
         // Ensure policy is NOT OnRequest so the early rejection path triggers
         turn_context_raw.approval_policy = AskForApproval::OnFailure;

codex-rs/core/src/codex/compact.rs

@@ -1,30 +1,23 @@
 use std::sync::Arc;
 
-use super::Session;
-use super::TurnContext;
-use super::get_last_assistant_message_from_turn;
-use crate::Prompt;
-use crate::client_common::ResponseEvent;
-use crate::error::CodexErr;
-use crate::error::Result as CodexResult;
-use crate::protocol::AgentMessageEvent;
-use crate::protocol::CompactedItem;
-use crate::protocol::ErrorEvent;
-use crate::protocol::EventMsg;
-use crate::protocol::TaskStartedEvent;
-use crate::protocol::TurnContextItem;
-use crate::protocol::WarningEvent;
-use crate::truncate::truncate_middle;
-use crate::util::backoff;
 use codex_protocol::items::TurnItem;
-use codex_protocol::models::ContentItem;
-use codex_protocol::models::ResponseInputItem;
-use codex_protocol::models::ResponseItem;
+use codex_protocol::models::{ContentItem, ResponseInputItem, ResponseItem};
 use codex_protocol::protocol::RolloutItem;
 use codex_protocol::user_input::UserInput;
 use futures::prelude::*;
 use tracing::error;
 
+use super::{Session, TurnContext, get_last_assistant_message_from_turn};
+use crate::Prompt;
+use crate::client_common::ResponseEvent;
+use crate::error::{CodexErr, Result as CodexResult};
+use crate::protocol::{
+    AgentMessageEvent, CompactedItem, ErrorEvent, EventMsg, TaskStartedEvent, TurnContextItem,
+    WarningEvent,
+};
+use crate::truncate::truncate_middle;
+use crate::util::backoff;
+
 pub const SUMMARIZATION_PROMPT: &str = include_str!("../../templates/compact/prompt.md");
 const COMPACT_USER_MESSAGE_MAX_TOKENS: usize = 20_000;
 
@@ -295,9 +288,10 @@ async fn drain_to_completed(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use pretty_assertions::assert_eq;
 
+    use super::*;
+
     #[test]
     fn content_items_to_text_joins_non_empty_segments() {
         let items = vec![

codex-rs/core/src/codex_conversation.rs

@@ -1,9 +1,8 @@
+use std::path::PathBuf;
+
 use crate::codex::Codex;
 use crate::error::Result as CodexResult;
-use crate::protocol::Event;
-use crate::protocol::Op;
-use crate::protocol::Submission;
-use std::path::PathBuf;
+use crate::protocol::{Event, Op, Submission};
 
 pub struct CodexConversation {
     codex: Codex,

codex-rs/core/src/codex_delegate.rs

@@ -1,29 +1,19 @@
 use std::sync::Arc;
 use std::sync::atomic::AtomicU64;
 
-use async_channel::Receiver;
-use async_channel::Sender;
+use async_channel::{Receiver, Sender};
 use codex_async_utils::OrCancelExt;
-use codex_protocol::protocol::ApplyPatchApprovalRequestEvent;
-use codex_protocol::protocol::Event;
-use codex_protocol::protocol::EventMsg;
-use codex_protocol::protocol::ExecApprovalRequestEvent;
-use codex_protocol::protocol::Op;
-use codex_protocol::protocol::SessionSource;
-use codex_protocol::protocol::SubAgentSource;
-use codex_protocol::protocol::Submission;
+use codex_protocol::protocol::{
+    ApplyPatchApprovalRequestEvent, Event, EventMsg, ExecApprovalRequestEvent, InitialHistory, Op,
+    SessionSource, SubAgentSource, Submission,
+};
 use codex_protocol::user_input::UserInput;
 use tokio_util::sync::CancellationToken;
 
 use crate::AuthManager;
-use crate::codex::Codex;
-use crate::codex::CodexSpawnOk;
-use crate::codex::SUBMISSION_CHANNEL_CAPACITY;
-use crate::codex::Session;
-use crate::codex::TurnContext;
+use crate::codex::{Codex, CodexSpawnOk, SUBMISSION_CHANNEL_CAPACITY, Session, TurnContext};
 use crate::config::Config;
 use crate::error::CodexErr;
-use codex_protocol::protocol::InitialHistory;
 
 /// Start an interactive sub-Codex conversation and return IO channels.
 ///

codex-rs/core/src/command_safety/is_safe_command.rs

@@ -175,9 +175,10 @@ fn is_valid_sed_n_arg(arg: Option<&str>) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use std::string::ToString;
 
+    use super::*;
+
     fn vec_str(args: &[&str]) -> Vec<String> {
         args.iter().map(ToString::to_string).collect()
     }

codex-rs/core/src/command_safety/windows_safe_commands.rs

@@ -274,9 +274,10 @@ fn is_safe_git_command(words: &[String]) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use super::is_safe_command_windows;
     use std::string::ToString;
 
+    use super::is_safe_command_windows;
+
     /// Converts a slice of string literals into owned `String`s for the tests.
     fn vec_str(args: &[&str]) -> Vec<String> {
         args.iter().map(ToString::to_string).collect()