Fix cargo check lints

Author: brandonskiser

crates/agent/src/api_client/endpoints.rs

@@ -9,21 +9,12 @@ pub struct Endpoint {
 }
 
 impl Endpoint {
-    pub const CODEWHISPERER_ENDPOINTS: [Self; 2] = [Self::DEFAULT_ENDPOINT, Self::FRA_ENDPOINT];
     pub const DEFAULT_ENDPOINT: Self = Self {
         url: Cow::Borrowed("https://q.us-east-1.amazonaws.com"),
         region: Region::from_static("us-east-1"),
     };
-    pub const FRA_ENDPOINT: Self = Self {
-        url: Cow::Borrowed("https://q.eu-central-1.amazonaws.com/"),
-        region: Region::from_static("eu-central-1"),
-    };
 
     pub(crate) fn url(&self) -> &str {
         &self.url
     }
-
-    pub(crate) fn region(&self) -> &Region {
-        &self.region
-    }
 }

crates/agent/src/api_client/error.rs

@@ -8,7 +8,6 @@ use amzn_codewhisperer_streaming_client::types::error::ChatResponseStreamError a
 use amzn_qdeveloper_streaming_client::operation::send_message::SendMessageError as QDeveloperSendMessageError;
 use amzn_qdeveloper_streaming_client::types::error::ChatResponseStreamError as QDeveloperChatResponseStreamError;
 use aws_credential_types::provider::error::CredentialsError;
-use aws_sdk_ssooidc::error::ProvideErrorMetadata;
 use aws_smithy_runtime_api::client::orchestrator::HttpResponse;
 pub use aws_smithy_runtime_api::client::result::SdkError;
 use aws_smithy_runtime_api::http::Response;
@@ -182,12 +181,6 @@ impl ApiClientError {
 //     }
 // }
 
-fn sdk_error_code<T: ProvideErrorMetadata, R>(e: &SdkError<T, R>) -> String {
-    e.as_service_error()
-        .and_then(|se| se.meta().code().map(str::to_string))
-        .unwrap_or_else(|| e.to_string())
-}
-
 fn sdk_status_code<E>(e: &SdkError<E, Response>) -> Option<u16> {
     e.raw_response().map(|res| res.status().as_u16())
 }
@@ -198,18 +191,13 @@ mod tests {
 
     use aws_smithy_runtime_api::http::Response;
     use aws_smithy_types::body::SdkBody;
-    use aws_smithy_types::event_stream::Message;
 
     use super::*;
 
     fn response() -> Response {
         Response::new(500.try_into().unwrap(), SdkBody::empty())
     }
 
-    fn raw_message() -> RawMessage {
-        RawMessage::Decoded(Message::new(b"<payload>".to_vec()))
-    }
-
     fn all_errors() -> Vec<ApiClientError> {
         vec![
             ApiClientError::Credentials(CredentialsError::unhandled("<unhandled>")),

crates/agent/src/api_client/mod.rs

@@ -7,14 +7,8 @@ pub mod request;
 mod retry_classifier;
 pub mod send_message_output;
 
-use std::sync::{
-    Arc,
-    RwLock,
-};
 use std::time::Duration;
 
-use amzn_codewhisperer_client::Client as CodewhispererClient;
-use amzn_codewhisperer_client::types::Model;
 use amzn_codewhisperer_streaming_client::Client as CodewhispererStreamingClient;
 use amzn_qdeveloper_streaming_client::Client as QDeveloperStreamingClient;
 use amzn_qdeveloper_streaming_client::types::Origin;
@@ -46,31 +40,13 @@ use crate::aws_common::{
     behavior_version,
 };
 
-pub const X_AMZN_CODEWHISPERER_OPT_OUT_HEADER: &str = "x-amzn-codewhisperer-optout";
-
 const DEFAULT_TIMEOUT_DURATION: Duration = Duration::from_secs(60 * 5);
 
-#[derive(Clone, Debug)]
-pub struct ModelListResult {
-    pub models: Vec<Model>,
-    pub default_model: Model,
-}
-
-impl From<ModelListResult> for (Vec<Model>, Model) {
-    fn from(v: ModelListResult) -> Self {
-        (v.models, v.default_model)
-    }
-}
-
-type ModelCache = Arc<RwLock<Option<ModelListResult>>>;
-
 #[derive(Clone)]
 pub struct ApiClient {
-    client: CodewhispererClient,
     streaming_client: Option<CodewhispererStreamingClient>,
     sigv4_streaming_client: Option<QDeveloperStreamingClient>,
     profile: Option<AuthProfile>,
-    model_cache: ModelCache,
 }
 
 impl std::fmt::Debug for ApiClient {
@@ -93,7 +69,6 @@ impl std::fmt::Debug for ApiClient {
                 },
             )
             .field("profile", &self.profile)
-            .field("model_cache", &self.model_cache)
             .finish()
     }
 }
@@ -117,17 +92,6 @@ impl ApiClient {
             .load()
             .await;
 
-        let client = CodewhispererClient::from_conf(
-            amzn_codewhisperer_client::config::Builder::from(&bearer_sdk_config)
-                .http_client(crate::aws_common::http_client::client())
-                // .interceptor(OptOutInterceptor::new(database))
-                .interceptor(UserAgentOverrideInterceptor::new())
-                .bearer_token_resolver(BearerResolver)
-                .app_name(app_name())
-                .endpoint_url(endpoint.url())
-                .build(),
-        );
-
         // If SIGV4_AUTH_ENABLED is true, use Q developer client
         let mut streaming_client = None;
         let mut sigv4_streaming_client = None;
@@ -177,20 +141,11 @@ impl ApiClient {
         }
 
         let profile = None;
-        // let profile = match database.get_auth_profile() {
-        //     Ok(profile) => profile,
-        //     Err(err) => {
-        //         error!("Failed to get auth profile: {err}");
-        //         None
-        //     },
-        // };
 
         Ok(Self {
-            client,
             streaming_client,
             sigv4_streaming_client,
             profile,
-            model_cache: Arc::new(RwLock::new(None)),
         })
     }
 
@@ -206,8 +161,6 @@ impl ApiClient {
             history,
         } = conversation;
 
-        let model_id_opt: Option<String> = user_input_message.model_id.clone();
-
         if let Some(client) = &self.streaming_client {
             let conversation_state = amzn_codewhisperer_streaming_client::types::ConversationState::builder()
                 .set_conversation_id(conversation_id)

crates/agent/src/auth/consts.rs

@@ -1,7 +1,5 @@
 use aws_types::region::Region;
 
-pub(crate) const CLIENT_NAME: &str = "Amazon Q Developer for command line";
-
 pub(crate) const OIDC_BUILDER_ID_REGION: Region = Region::from_static("us-east-1");
 
 /// The scopes requested for OIDC
@@ -16,13 +14,10 @@ pub(crate) const SCOPES: &[&str] = &[
     // "codewhisperer:transformations",
 ];
 
-pub(crate) const CLIENT_TYPE: &str = "public";
-
 // The start URL for public builder ID users
 pub const START_URL: &str = "https://view.awsapps.com/start";
 
 // The start URL for internal amzn users
 pub const AMZN_START_URL: &str = "https://amzn.awsapps.com/start";
 
-pub(crate) const DEVICE_GRANT_TYPE: &str = "urn:ietf:params:oauth:grant-type:device_code";
 pub(crate) const REFRESH_GRANT_TYPE: &str = "refresh_token";

crates/agent/src/auth/mod.rs

@@ -1,6 +1,5 @@
 pub mod builder_id;
 mod consts;
-mod scope;
 
 use aws_sdk_ssooidc::error::SdkError;
 use aws_sdk_ssooidc::operation::create_token::CreateTokenError;

crates/agent/src/auth/scope.rs

@@ -1,9 +1,7 @@
-pub mod chat;
 mod run;
 
 use std::process::ExitCode;
 
-use chat::ChatArgs;
 use clap::{
     ArgAction,
     Parser,
@@ -14,7 +12,6 @@ use eyre::{
     Result,
 };
 use run::RunArgs;
-use tracing::Level;
 use tracing_appender::non_blocking::{
     NonBlocking,
     WorkerGuard,
@@ -41,27 +38,14 @@ pub struct CliArgs {
 
 impl CliArgs {
     pub async fn execute(self) -> Result<ExitCode> {
-        let _guard = self.setup_logging().context("failed to initialize logging")?;
+        let _guard = Self::setup_logging().context("failed to initialize logging")?;
 
         let subcommand = self.subcommand.unwrap_or_default();
 
         subcommand.execute().await
     }
 
-    fn setup_logging(&self) -> Result<WorkerGuard> {
-        let log_level = match self.verbose > 0 {
-            true => Some(
-                match self.verbose {
-                    1 => Level::WARN,
-                    2 => Level::INFO,
-                    3 => Level::DEBUG,
-                    _ => Level::TRACE,
-                }
-                .to_string(),
-            ),
-            false => None,
-        };
-
+    fn setup_logging() -> Result<WorkerGuard> {
         let env_filter = EnvFilter::try_from_default_env().unwrap_or_default();
         let (non_blocking, _file_guard) = NonBlocking::new(RollingFileAppender::new(Rotation::NEVER, ".", "chat.log"));
         let file_layer = tracing_subscriber::fmt::layer().with_writer(non_blocking);
@@ -75,23 +59,20 @@ impl CliArgs {
 
 #[derive(Debug, Clone, Subcommand)]
 pub enum RootSubcommand {
-    /// TUI Chat Interface
-    Chat(ChatArgs),
     /// Run a single prompt
     Run(RunArgs),
 }
 
 impl RootSubcommand {
     pub async fn execute(self) -> Result<ExitCode> {
         match self {
-            RootSubcommand::Chat(chat_args) => chat_args.execute().await,
             RootSubcommand::Run(run_args) => run_args.execute().await,
         }
     }
 }
 
 impl Default for RootSubcommand {
     fn default() -> Self {
-        Self::Chat(Default::default())
+        Self::Run(Default::default())
     }
 }

crates/agent/src/cli/chat.rs

@@ -23,23 +23,8 @@ use serde::{
     Deserialize,
     Serialize,
 };
-use tokio::io::AsyncWriteExt;
 use tracing::warn;
 
-// use crate::chat::{
-//     ActiveState,
-//     ApprovalResult,
-//     InputItem,
-//     SendApprovalResultArgs,
-//     SendPromptArgs,
-//     Session,
-//     SessionBuilder,
-//     SessionEvent,
-//     SessionEventKind,
-//     SessionInitWarning,
-//     SessionNotification,
-// };
-
 #[derive(Debug, Clone, Default, Args)]
 pub struct RunArgs {
     /// The name of the agent to run the session with.
@@ -106,7 +91,7 @@ impl RunArgs {
                     }
                 },
                 AgentEvent::RequestError(loop_error) => bail!("agent encountered an error: {:?}", loop_error),
-                AgentEvent::ApprovalRequest { id, tool_use, context } => {
+                AgentEvent::ApprovalRequest { id, tool_use, .. } => {
                     if !self.dangerously_trust_all_tools {
                         bail!("Tool approval is required: {:?}", tool_use);
                     } else {
@@ -137,7 +122,7 @@ impl RunArgs {
                     match &evt.kind {
                         AgentLoopEventKind::AssistantText(text) => {
                             print!("{}", text);
-                            std::io::stdout().flush();
+                            let _ = std::io::stdout().flush();
                         },
                         AgentLoopEventKind::ToolUse(tool_use) => {
                             print!("\n{}\n", serde_json::to_string_pretty(tool_use).expect("does not fail"));