patch of improve error handling for overly long search queries · round #0 · pull #2 · zzstoatzz.io/find-bufo

Cargo.lock

···

       686
        
        "reqwest",

     

       687
        
        "serde",

     

       688
        
        "serde_json",

     

       0
        
       
     

       689
        
        "tokio",

     

       690
        
        "tracing",

     

       691
        
       ]

···

       686
        
        "reqwest",

     

       687
        
        "serde",

     

       688
        
        "serde_json",

     

       689
       +
        "thiserror 1.0.69",

     

       690
        
        "tokio",

     

       691
        
        "tracing",

     

       692
        
       ]

Cargo.toml

···

       12
        
       tokio = { version = "1", features = ["full"] }

     

       13
        
       reqwest = { version = "0.12", features = ["json", "multipart"] }

     

       14
        
       anyhow = "1.0"

     

       0
        
       
     

       15
        
       dotenv = "0.15"

     

       16
        
       base64 = "0.22"

     

       17
        
       actix-governor = "0.10.0"

···

       12
        
       tokio = { version = "1", features = ["full"] }

     

       13
        
       reqwest = { version = "0.12", features = ["json", "multipart"] }

     

       14
        
       anyhow = "1.0"

     

       15
       +
       thiserror = "1.0"

     

       16
        
       dotenv = "0.15"

     

       17
        
       base64 = "0.22"

     

       18
        
       actix-governor = "0.10.0"

+16 -5

src/search.rs

···

       42
        
       

     

       43
        
       use crate::config::Config;

     

       44
        
       use crate::embedding::EmbeddingClient;

     

       45
       -
       use crate::turbopuffer::{QueryRequest, TurbopufferClient};

     

       46
        
       use actix_web::{web, HttpRequest, HttpResponse, Result as ActixResult};

     

       47
        
       use serde::{Deserialize, Serialize};

     

       48
        
       use std::collections::hash_map::DefaultHasher;

     
···

       228
        
                       query = &query_text,

     

       229
        
                       top_k = search_top_k as i64

     

       230
        
                   );

     

       231
       -
                   actix_web::error::ErrorInternalServerError(format!(

     

       232
       -
                       "failed to query turbopuffer (BM25): {}",

     

       233
       -
                       e

     

       234
       -
                   ))

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       235
        
               })?

     

       236
        
           };

     

       237

···

       42
        
       

     

       43
        
       use crate::config::Config;

     

       44
        
       use crate::embedding::EmbeddingClient;

     

       45
       +
       use crate::turbopuffer::{QueryRequest, TurbopufferClient, TurbopufferError};

     

       46
        
       use actix_web::{web, HttpRequest, HttpResponse, Result as ActixResult};

     

       47
        
       use serde::{Deserialize, Serialize};

     

       48
        
       use std::collections::hash_map::DefaultHasher;

     
···

       228
        
                       query = &query_text,

     

       229
        
                       top_k = search_top_k as i64

     

       230
        
                   );

     

       231
       +
       

     

       232
       +
                   // return appropriate HTTP status based on error type

     

       233
       +
                   match e {

     

       234
       +
                       TurbopufferError::QueryTooLong { .. } => {

     

       235
       +
                           actix_web::error::ErrorBadRequest(

     

       236
       +
                               "search query is too long (max 1024 characters for text search). try a shorter query."

     

       237
       +
                           )

     

       238
       +
                       }

     

       239
       +
                       _ => {

     

       240
       +
                           actix_web::error::ErrorInternalServerError(format!(

     

       241
       +
                               "failed to query turbopuffer (BM25): {}",

     

       242
       +
                               e

     

       243
       +
                           ))

     

       244
       +
                       }

     

       245
       +
                   }

     

       246
        
               })?

     

       247
        
           };

     

       248

+43 -7

src/turbopuffer.rs

···

       1
        
       use anyhow::{Context, Result};

     

       2
        
       use reqwest::Client;

     

       3
        
       use serde::{Deserialize, Serialize};

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4
        
       

     

       5
        
       #[derive(Debug, Serialize)]

     

       6
        
       pub struct QueryRequest {

     
···

       64
        
                   .context(format!("failed to parse query response: {}", body))

     

       65
        
           }

     

       66
        
       

     

       67
       -
           pub async fn bm25_query(&self, query_text: &str, top_k: usize) -> Result<QueryResponse> {

     

       68
        
               let url = format!(

     

       69
        
                   "https://api.turbopuffer.com/v1/vectors/{}/query",

     

       70
        
                   self.namespace

     
···

       76
        
                   "include_attributes": ["url", "name", "filename"],

     

       77
        
               });

     

       78
        
       

     

       79
       -
               log::debug!("turbopuffer BM25 query request: {}", serde_json::to_string_pretty(&request)?);

     

       0
        
       
     

       0
        
       
     

       80
        
       

     

       81
        
               let response = self

     

       82
        
                   .client

     
···

       84
        
                   .header("Authorization", format!("Bearer {}", self.api_key))

     

       85
        
                   .json(&request)

     

       86
        
                   .send()

     

       87
       -
                   .await

     

       88
       -
                   .context("failed to send BM25 query request")?;

     

       89
        
       

     

       90
        
               if !response.status().is_success() {

     

       91
        
                   let status = response.status();

     

       92
        
                   let body = response.text().await.unwrap_or_default();

     

       93
       -
                   anyhow::bail!("turbopuffer BM25 query failed with status {}: {}", status, body);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       94
        
               }

     

       95
        
       

     

       96
       -
               let body = response.text().await.context("failed to read response body")?;

     

       0
        
       
     

       97
        
               log::debug!("turbopuffer BM25 response: {}", body);

     

       98
        
       

     

       99
        
               let parsed: QueryResponse = serde_json::from_str(&body)

     

       100
       -
                   .context(format!("failed to parse BM25 query response: {}", body))?;

     

       101
        
       

     

       102
        
               // DEBUG: log first result to see what BM25 returns

     

       103
        
               if let Some(first) = parsed.first() {

···

       1
        
       use anyhow::{Context, Result};

     

       2
        
       use reqwest::Client;

     

       3
        
       use serde::{Deserialize, Serialize};

     

       4
       +
       use thiserror::Error;

     

       5
       +
       

     

       6
       +
       #[derive(Debug, Error)]

     

       7
       +
       pub enum TurbopufferError {

     

       8
       +
           #[error("query too long: {message}")]

     

       9
       +
           QueryTooLong { message: String },

     

       10
       +
           #[error("turbopuffer API error: {0}")]

     

       11
       +
           ApiError(String),

     

       12
       +
           #[error("request failed: {0}")]

     

       13
       +
           RequestFailed(#[from] reqwest::Error),

     

       14
       +
           #[error("{0}")]

     

       15
       +
           Other(#[from] anyhow::Error),

     

       16
       +
       }

     

       17
       +
       

     

       18
       +
       #[derive(Debug, Deserialize)]

     

       19
       +
       struct TurbopufferErrorResponse {

     

       20
       +
           error: String,

     

       21
       +
           #[allow(dead_code)]

     

       22
       +
           status: String,

     

       23
       +
       }

     

       24
        
       

     

       25
        
       #[derive(Debug, Serialize)]

     

       26
        
       pub struct QueryRequest {

     
···

       84
        
                   .context(format!("failed to parse query response: {}", body))

     

       85
        
           }

     

       86
        
       

     

       87
       +
           pub async fn bm25_query(&self, query_text: &str, top_k: usize) -> Result<QueryResponse, TurbopufferError> {

     

       88
        
               let url = format!(

     

       89
        
                   "https://api.turbopuffer.com/v1/vectors/{}/query",

     

       90
        
                   self.namespace

     
···

       96
        
                   "include_attributes": ["url", "name", "filename"],

     

       97
        
               });

     

       98
        
       

     

       99
       +
               if let Ok(pretty) = serde_json::to_string_pretty(&request) {

     

       100
       +
                   log::debug!("turbopuffer BM25 query request: {}", pretty);

     

       101
       +
               }

     

       102
        
       

     

       103
        
               let response = self

     

       104
        
                   .client

     
···

       106
        
                   .header("Authorization", format!("Bearer {}", self.api_key))

     

       107
        
                   .json(&request)

     

       108
        
                   .send()

     

       109
       +
                   .await?;

     

       0
        
       
     

       110
        
       

     

       111
        
               if !response.status().is_success() {

     

       112
        
                   let status = response.status();

     

       113
        
                   let body = response.text().await.unwrap_or_default();

     

       114
       +
       

     

       115
       +
                   // try to parse turbopuffer error response

     

       116
       +
                   if let Ok(error_resp) = serde_json::from_str::<TurbopufferErrorResponse>(&body) {

     

       117
       +
                       // check if it's a query length error

     

       118
       +
                       if error_resp.error.contains("too long") && error_resp.error.contains("max 1024") {

     

       119
       +
                           return Err(TurbopufferError::QueryTooLong {

     

       120
       +
                               message: error_resp.error,

     

       121
       +
                           });

     

       122
       +
                       }

     

       123
       +
                   }

     

       124
       +
       

     

       125
       +
                   return Err(TurbopufferError::ApiError(format!(

     

       126
       +
                       "turbopuffer BM25 query failed with status {}: {}",

     

       127
       +
                       status, body

     

       128
       +
                   )));

     

       129
        
               }

     

       130
        
       

     

       131
       +
               let body = response.text().await

     

       132
       +
                   .map_err(|e| TurbopufferError::Other(anyhow::anyhow!("failed to read response body: {}", e)))?;

     

       133
        
               log::debug!("turbopuffer BM25 response: {}", body);

     

       134
        
       

     

       135
        
               let parsed: QueryResponse = serde_json::from_str(&body)

     

       136
       +
                   .map_err(|e| TurbopufferError::Other(anyhow::anyhow!("failed to parse BM25 query response: {}", e)))?;

     

       137
        
       

     

       138
        
               // DEBUG: log first result to see what BM25 returns

     

       139
        
               if let Some(first) = parsed.first() {

+12 -1

static/index.html

···

       691
        
                       });

     

       692
        
       

     

       693
        
                       if (!response.ok) {

     

       694
       -
                           throw new Error(`search failed: ${response.statusText}`);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       695
        
                       }

     

       696
        
       

     

       697
        
                       const data = await response.json();

···

       691
        
                       });

     

       692
        
       

     

       693
        
                       if (!response.ok) {

     

       694
       +
                           // try to extract error message from response body

     

       695
       +
                           let errorMessage = response.statusText;

     

       696
       +
                           try {

     

       697
       +
                               const errorText = await response.text();

     

       698
       +
                               // actix-web returns plain text error messages, not JSON

     

       699
       +
                               if (errorText) {

     

       700
       +
                                   errorMessage = errorText;

     

       701
       +
                               }

     

       702
       +
                           } catch (e) {

     

       703
       +
                               // if reading body fails, use the status text

     

       704
       +
                           }

     

       705
       +
                           throw new Error(errorMessage);

     

       706
        
                       }

     

       707
        
       

     

       708
        
                       const data = await response.json();