refactor: Add clippy no panic lints

Cargo.toml

@@ -10,8 +10,17 @@ exclude = [
 
 [workspace.lints.clippy]
 dbg_macro = "forbid"
+await_holding_lock = "deny"
+await_holding_refcell_ref = "deny"
+expect_used = "deny"
+expect_fun_call = "deny"
+indexing_slicing = "deny"
+panic = "deny"
+panic_in_result_fn = "deny"
 todo = "forbid"
 unimplemented = "forbid"
+unreachable = "deny"
+unwrap_used = "deny"
 
 [profile.release]
 lto = true

rig-integrations/rig-bedrock/examples/agent_with_bedrock.rs

@@ -29,19 +29,18 @@ async fn main() -> Result<(), anyhow::Error> {
     Ok(())
 }
 
-fn client() -> Client {
-    Client::from_env()
+fn client() -> Result<Client, anyhow::Error> {
+    Ok(Client::from_env()?)
 }
 
-async fn partial_agent() -> AgentBuilder<rig_bedrock::completion::CompletionModel> {
-    let client = client();
-    client.agent(AMAZON_NOVA_LITE)
+fn partial_agent() -> Result<AgentBuilder<rig_bedrock::completion::CompletionModel>, anyhow::Error>
+{
+    Ok(client()?.agent(AMAZON_NOVA_LITE))
 }
 
 /// Create an AWS Bedrock agent with a system prompt
 async fn basic() -> Result<(), anyhow::Error> {
-    let agent = partial_agent()
-        .await
+    let agent = partial_agent()?
         .preamble("Answer with json format only")
         .build();
 
@@ -53,8 +52,7 @@ async fn basic() -> Result<(), anyhow::Error> {
 
 /// Create an AWS Bedrock with tools
 async fn tools() -> Result<(), anyhow::Error> {
-    let calculator_agent = partial_agent()
-        .await
+    let calculator_agent = partial_agent()?
         .preamble("You must only do math by using a tool.")
         .max_tokens(1024)
         .tool(common::Adder)
@@ -69,7 +67,7 @@ async fn tools() -> Result<(), anyhow::Error> {
 }
 
 async fn context() -> Result<(), anyhow::Error> {
-    let model = client().completion_model(AMAZON_NOVA_LITE);
+    let model = client()?.completion_model(AMAZON_NOVA_LITE);
 
     // Create an agent with multiple context documents
     let agent = AgentBuilder::new(model)
@@ -92,7 +90,7 @@ async fn context() -> Result<(), anyhow::Error> {
 /// This example loads in all the rust examples from the rig-core crate and uses them as\\
 ///  context for the agent
 async fn loaders() -> Result<(), anyhow::Error> {
-    let model = client().completion_model(AMAZON_NOVA_LITE);
+    let model = client()?.completion_model(AMAZON_NOVA_LITE);
 
     // Load in all the rust examples
     let examples = FileLoader::with_glob("rig-core/examples/*.rs")?

rig-integrations/rig-bedrock/examples/document_with_bedrock.rs

@@ -20,7 +20,7 @@ async fn main() -> Result<(), anyhow::Error> {
         .with_target(false)
         .init();
 
-    let client = Client::from_env();
+    let client = Client::from_env()?;
     let agent = client
         .agent(AMAZON_NOVA_LITE)
         .preamble("Describe this document")

rig-integrations/rig-bedrock/examples/embedding_with_bedrock.rs

@@ -17,7 +17,7 @@ async fn main() -> Result<(), anyhow::Error> {
         .with_target(false)
         .init();
 
-    let client = Client::from_env();
+    let client = Client::from_env()?;
     let embeddings = client
         .embeddings_with_ndims(AMAZON_TITAN_EMBED_TEXT_V2_0, 256)
         .document(Greetings {

rig-integrations/rig-bedrock/examples/extractor_with_bedrock.rs

@@ -19,15 +19,12 @@ async fn main() -> Result<(), anyhow::Error> {
         .with_target(false)
         .init();
 
-    let client = Client::from_env();
+    let client = Client::from_env()?;
     let data_extractor = client.extractor::<Person>(AMAZON_NOVA_LITE).build();
     let person = data_extractor
         .extract("Hello my name is John Doe! I am a software engineer.")
         .await?;
 
-    info!(
-        "AWS Bedrock: {}",
-        serde_json::to_string_pretty(&person).unwrap()
-    );
+    info!("AWS Bedrock: {}", serde_json::to_string_pretty(&person)?);
     Ok(())
 }

rig-integrations/rig-bedrock/examples/image_generator.rs

@@ -10,18 +10,20 @@ use std::path::Path;
 const DEFAULT_PATH: &str = "./output.png";
 
 #[tokio::main]
-async fn main() {
-    let client = Client::from_env();
+async fn main() -> Result<(), anyhow::Error> {
+    let client = Client::from_env()?;
     let image_generation_model = client.image_generation_model(AMAZON_NOVA_CANVAS);
     let response = image_generation_model
         .image_generation_request()
         .prompt("A castle sitting upon a large mountain, overlooking the water.")
         .width(512)
         .height(512)
         .send()
-        .await;
+        .await?;
 
     // save image
-    let mut file = File::create_new(Path::new(&DEFAULT_PATH)).expect("Failed to create file");
-    let _ = file.write(&response.unwrap().image);
+    let mut file = File::create_new(Path::new(DEFAULT_PATH))?;
+    file.write_all(&response.image)?;
+
+    Ok(())
 }

rig-integrations/rig-bedrock/examples/image_with_bedrock.rs

@@ -19,7 +19,7 @@ async fn main() -> Result<(), anyhow::Error> {
         .with_target(false)
         .init();
 
-    let client = rig_bedrock::client::Client::from_env();
+    let client = rig_bedrock::client::Client::from_env()?;
     let agent = client
         .agent(AMAZON_NOVA_LITE)
         .preamble("You are an image describer.")

rig-integrations/rig-bedrock/examples/rag_with_bedrock.rs

@@ -29,7 +29,7 @@ async fn main() -> Result<(), anyhow::Error> {
         .with_target(false)
         .init();
 
-    let client = Client::from_env();
+    let client = Client::from_env()?;
     let embedding_model = client.embedding_model_with_ndims(AMAZON_TITAN_EMBED_TEXT_V2_0, 256);
 
     // Generate embeddings for the definitions of all the documents using the specified embedding model.

rig-integrations/rig-bedrock/examples/streaming_with_bedrock.rs

@@ -6,7 +6,7 @@ use rig_bedrock::{client::Client, completion::AMAZON_NOVA_LITE};
 #[tokio::main]
 async fn main() -> Result<(), anyhow::Error> {
     // Create streaming agent with a single context prompt
-    let agent = Client::from_env()
+    let agent = Client::from_env()?
         .agent(AMAZON_NOVA_LITE)
         .preamble("Be precise and concise.")
         .temperature(0.5)

rig-integrations/rig-bedrock/examples/streaming_with_bedrock_and_tools.rs

@@ -8,7 +8,7 @@ mod common;
 async fn main() -> Result<(), anyhow::Error> {
     tracing_subscriber::fmt().init();
     // Create agent with a single context prompt and two tools
-    let agent = Client::from_env()
+    let agent = Client::from_env()?
         .agent(AMAZON_NOVA_LITE)
         .preamble(
             "You are a calculator here to help the user perform arithmetic

rig-integrations/rig-bedrock/src/client.rs

@@ -96,21 +96,22 @@ impl Client {
 
 impl ProviderClient for Client {
     type Input = Nothing;
+    type Error = rig::client::ProviderClientError;
 
-    fn from_env() -> Self
+    fn from_env() -> Result<Self, Self::Error>
     where
         Self: Sized,
     {
-        Client::new()
+        Ok(Client::new())
     }
 
-    fn from_val(_: Nothing) -> Self
+    fn from_val(_: Nothing) -> Result<Self, Self::Error>
     where
         Self: Sized,
     {
-        panic!(
-            "Please use `Client::from_env` or `Client::with_profile_name(\"aws_profile\")` instead"
-        );
+        Err(rig::client::ProviderClientError::InvalidConfiguration(
+            "use `Client::from_env()` or `Client::with_profile_name(\"aws_profile\")` instead",
+        ))
     }
 }
 

rig-integrations/rig-bedrock/src/completion.rs

@@ -262,7 +262,7 @@ impl completion::CompletionModel for CompletionModel {
             .set_additional_model_request_fields(request.additional_params())
             .set_inference_config(request.inference_config())
             .set_tool_config(tool_config)
-            .set_system(request.system_prompt())
+            .set_system(request.system_prompt()?)
             .set_messages(Some(messages));
 
         async move {

rig-integrations/rig-bedrock/src/lib.rs

@@ -1,3 +1,14 @@
+#![cfg_attr(
+    test,
+    allow(
+        clippy::expect_used,
+        clippy::indexing_slicing,
+        clippy::panic,
+        clippy::unwrap_used,
+        clippy::unreachable
+    )
+)]
+
 pub mod client;
 pub mod completion;
 pub mod embedding;

rig-integrations/rig-bedrock/src/streaming.rs

@@ -80,7 +80,7 @@ impl CompletionModel {
             .set_additional_model_request_fields(request.additional_params())
             .set_inference_config(request.inference_config())
             .set_tool_config(tool_config)
-            .set_system(request.system_prompt())
+            .set_system(request.system_prompt()?)
             .set_messages(Some(prompt_with_history));
 
         let response = converse_builder.send().await.map_err(|sdk_error| {

rig-integrations/rig-bedrock/src/types/completion_request.rs

@@ -14,11 +14,11 @@ pub struct AwsCompletionRequest {
     pub prompt_caching: bool,
 }
 
-fn cache_point_block() -> CachePointBlock {
+fn cache_point_block() -> Result<CachePointBlock, CompletionError> {
     CachePointBlock::builder()
         .r#type(CachePointType::Default)
         .build()
-        .expect("CachePointBlock type is set")
+        .map_err(|e| CompletionError::RequestError(e.into()))
 }
 
 impl AwsCompletionRequest {
@@ -65,31 +65,33 @@ impl AwsCompletionRequest {
         if !tools.is_empty() {
             // Convert rig's ToolChoice to AWS Bedrock ToolChoice
             use aws_sdk_bedrockruntime::types as aws_bedrock;
-            let tool_choice = self.inner.tool_choice.as_ref().and_then(|choice| {
-                match choice {
-                    rig::message::ToolChoice::Auto => Some(aws_bedrock::ToolChoice::Auto(
+            let tool_choice = self
+                .inner
+                .tool_choice
+                .as_ref()
+                .map(|choice| match choice {
+                    rig::message::ToolChoice::Auto => Ok(Some(aws_bedrock::ToolChoice::Auto(
                         aws_bedrock::AutoToolChoice::builder().build(),
-                    )),
-                    rig::message::ToolChoice::Required => Some(aws_bedrock::ToolChoice::Any(
+                    ))),
+                    rig::message::ToolChoice::Required => Ok(Some(aws_bedrock::ToolChoice::Any(
                         aws_bedrock::AnyToolChoice::builder().build(),
-                    )),
-                    rig::message::ToolChoice::None => {
-                        // Bedrock doesn't have a "None" option - just omit tool_choice
-                        None
-                    }
-                    rig::message::ToolChoice::Specific { function_names } => {
-                        // Use the first function name for Bedrock's specific tool choice
-                        function_names.first().map(|name| {
-                            aws_bedrock::ToolChoice::Tool(
-                                aws_bedrock::SpecificToolChoice::builder()
-                                    .name(name.clone())
-                                    .build()
-                                    .expect("Failed to build SpecificToolChoice"),
-                            )
+                    ))),
+                    rig::message::ToolChoice::None => Ok(None),
+                    rig::message::ToolChoice::Specific { function_names } => function_names
+                        .first()
+                        .map(|name| {
+                            aws_bedrock::SpecificToolChoice::builder()
+                                .name(name.clone())
+                                .build()
+                                .map(aws_bedrock::ToolChoice::Tool)
+                                .map(Some)
+                                .map_err(|e| CompletionError::RequestError(e.into()))
                         })
-                    }
-                }
-            });
+                        .transpose()
+                        .map(Option::flatten),
+                })
+                .transpose()?
+                .flatten();
 
             let config = ToolConfiguration::builder()
                 .set_tools(Some(tools))
@@ -103,7 +105,7 @@ impl AwsCompletionRequest {
         }
     }
 
-    pub fn system_prompt(&self) -> Option<Vec<SystemContentBlock>> {
+    pub fn system_prompt(&self) -> Result<Option<Vec<SystemContentBlock>>, CompletionError> {
         let mut system_blocks = Vec::new();
 
         if let Some(system_prompt) = self.inner.preamble.to_owned()
@@ -121,12 +123,12 @@ impl AwsCompletionRequest {
         }
 
         if system_blocks.is_empty() {
-            None
+            Ok(None)
         } else {
             if self.prompt_caching {
-                system_blocks.push(SystemContentBlock::CachePoint(cache_point_block()));
+                system_blocks.push(SystemContentBlock::CachePoint(cache_point_block()?));
             }
-            Some(system_blocks)
+            Ok(Some(system_blocks))
         }
     }
 
@@ -165,7 +167,7 @@ impl AwsCompletionRequest {
             && let Some(last_msg) = messages.last_mut()
         {
             let mut content = last_msg.content.clone();
-            content.push(aws_bedrock::ContentBlock::CachePoint(cache_point_block()));
+            content.push(aws_bedrock::ContentBlock::CachePoint(cache_point_block()?));
             *last_msg = aws_bedrock::Message::builder()
                 .role(last_msg.role.clone())
                 .set_content(Some(content))
@@ -465,14 +467,17 @@ mod tests {
         };
 
         let aws_request = aws_request(request, false);
-        let system_prompt = aws_request.system_prompt();
+        let system_prompt = aws_request
+            .system_prompt()
+            .expect("system prompt should build")
+            .expect("system prompt should exist");
 
-        assert!(system_prompt.is_some());
-        let system_prompt = system_prompt.unwrap();
         assert_eq!(system_prompt.len(), 1);
         assert_eq!(
-            system_prompt[0],
-            aws_bedrock::SystemContentBlock::Text("History system instruction".to_string())
+            system_prompt.first(),
+            Some(&aws_bedrock::SystemContentBlock::Text(
+                "History system instruction".to_string()
+            ))
         );
     }
 
@@ -486,12 +491,15 @@ mod tests {
         let aws_request = aws_request(request, true);
         let system_prompt = aws_request
             .system_prompt()
+            .expect("system prompt should build")
             .expect("system prompt should exist");
 
         assert_eq!(system_prompt.len(), 2);
         assert_eq!(
-            system_prompt[0],
-            aws_bedrock::SystemContentBlock::Text("System prompt".to_string())
+            system_prompt.first(),
+            Some(&aws_bedrock::SystemContentBlock::Text(
+                "System prompt".to_string()
+            ))
         );
         assert!(matches!(
             system_prompt.last(),