adding some error handling

Author: rmuller-ml

server/bleep/src/agent/symbol.rs

@@ -7,7 +7,7 @@ use crate::llm_gateway;
 use crate::llm_gateway::api::{Function, FunctionCall};
 use crate::webserver::hoverable::{inner_handle, HoverableRequest, HoverableResponse};
 use crate::webserver::intelligence::{inner_handle as token_info, TokenInfoRequest};
-use crate::webserver::Error;
+use tracing::log::warn;
 
 pub struct ChunkRefDef {
     pub chunk: CodeChunk,
@@ -151,7 +151,7 @@ impl Agent {
         &self,
         query: &str,
         chunks_with_symbols: Vec<ChunkRefDef>,
-    ) -> Result<RefDefMetadata, Error> {
+    ) -> Result<RefDefMetadata, SymbolError> {
         let mut i: i32 = -1;
         // we have multiples chunks and each chunk may have multiple symbols
         // unique alias (i) per symbol
@@ -171,6 +171,9 @@ impl Agent {
                 )
             })
             .collect::<Vec<_>>();
+        if i == -1 {
+            return Err(SymbolError::SymbolListEmptyError);
+        }
 
         // Classifier
 
@@ -220,24 +223,36 @@ impl Agent {
         let llm_response = self
             .llm_with_function_call(prompt, filter_function)
             .await
-            .unwrap_or(FunctionCall {
-                name: Some("filter".to_string()),
-                arguments: "{\"symbol\": 0}".to_string(),
+            .unwrap_or({
+                warn!("Symbol classfier llm call failed, picking the first symbol.");
+                FunctionCall {
+                    name: Some("filter".to_string()),
+                    arguments: "{\"symbol\": 0}".to_string(),
+                }
             });
 
         let filter_argument: Filter =
-            serde_json::from_str(llm_response.arguments.as_str()).unwrap();
+            match serde_json::from_str(llm_response.clone().arguments.as_str()) {
+                Ok(argument) => argument,
+                Err(_e) => {
+                    warn!("Cannot deserialize: {:?}", llm_response);
+                    return Err(SymbolError::DeserializeFilterError);
+                }
+            };
 
         let selected_symbol = filter_argument.symbol;
 
         // finding symbol metadata
-        let output = symbols
+        let output = match symbols
             .into_iter()
             .flat_map(|(_, symbol_with_alias)| symbol_with_alias)
             .find(|(alias, _)| alias.clone() == selected_symbol as i32)
-            .unwrap();
+            {
+                Some((_alias, symbol_metadata)) => Ok(symbol_metadata),
+                _ => Err(SymbolError::SymbolOutOfBoundsError)
+            };
 
-        Ok(output.1)
+        output
     }
 
     pub async fn get_ref_def_extra_chunks(&mut self, chunks: Vec<CodeChunk>) -> Vec<CodeChunk> {
@@ -256,10 +271,13 @@ impl Agent {
         let user_query = self.last_exchange().query.target().unwrap();
 
         // select one symbol
-        let selected_symbol = self
-            .filter_symbols(&user_query, chunks_with_symbols)
-            .await
-            .unwrap();
+        let selected_symbol = match self.filter_symbols(&user_query, chunks_with_symbols).await {
+            Ok(selected_symbol) => selected_symbol,
+            Err(e) => {
+                warn!("Returning no extra chunks: {}", e);
+                return Vec::new();
+            }
+        };
 
         // get expanded chunks for selected symbol
         let extra_chunks = self.expand_symbol_into_chunks(selected_symbol).await;
@@ -333,3 +351,13 @@ pub struct RefDefMetadata {
 struct Filter {
     symbol: usize,
 }
+
+#[derive(thiserror::Error, Debug)]
+pub enum SymbolError {
+    #[error("No symbol retrieved in the provided chunks")]
+    SymbolListEmptyError,
+    #[error("Cannot deserialize llm function call arguments")]
+    DeserializeFilterError,
+    #[error("Selected symbol out of bounds")]
+    SymbolOutOfBoundsError,
+}