fix(search): wire LLM cache into search_with_intelligence

When an orchestrator is present, compute a SHA256 cache key from the
query and check the llm_cache table first. On miss, call the
orchestrator and store the result. Adds Serialize/Deserialize to
QueryIntent and OrchestrationResult for JSON round-tripping.
Removes #[allow(dead_code)] from orchestration_cache_key.

Author: devwhodevs

src/llm.rs

@@ -71,7 +71,7 @@ impl PromptFormat {
 // ── Types ────────────────────────────────────────────────────────────────────
 
 /// Classified intent of an incoming search query.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum QueryIntent {
     /// User wants a precise fact or term match.
     Exact,
@@ -84,7 +84,7 @@ pub enum QueryIntent {
 }
 
 /// Output produced by an orchestrator model for a query.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct OrchestrationResult {
     /// Classified query intent.
     pub intent: QueryIntent,
@@ -566,11 +566,15 @@ fn try_external_tokenizer(uri: &HfModelUri, models_dir: &Path) -> Option<tokeniz
         };
         let tok_path = tok_uri.cache_path(models_dir);
 
-        if tok_path.exists() && let Ok(tok) = tokenizers::Tokenizer::from_file(&tok_path) {
+        if tok_path.exists()
+            && let Ok(tok) = tokenizers::Tokenizer::from_file(&tok_path)
+        {
             return Some(tok);
         }
 
-        if let Ok(p) = ensure_model(&tok_uri, models_dir) && let Ok(tok) = tokenizers::Tokenizer::from_file(&p) {
+        if let Ok(p) = ensure_model(&tok_uri, models_dir)
+            && let Ok(tok) = tokenizers::Tokenizer::from_file(&p)
+        {
             return Some(tok);
         }
     }
@@ -1473,7 +1477,6 @@ impl CandleRerank {
             no_token_id,
         })
     }
-
 }
 
 impl RerankModel for CandleRerank {

src/search.rs

@@ -10,7 +10,6 @@ use crate::llm::{self, EmbedModel, OrchestratorModel, RerankModel};
 use crate::store::{Store, StoreStats};
 
 /// Compute cache key for orchestration results (SHA256 of query).
-#[allow(dead_code)]
 fn orchestration_cache_key(query: &str) -> String {
     use sha2::{Digest, Sha256};
     let hash = Sha256::digest(query.as_bytes());
@@ -85,9 +84,25 @@ pub fn search_with_intelligence(
     embedder: &mut impl EmbedModel,
     config: &mut SearchConfig<'_>,
 ) -> Result<SearchOutput> {
-    // --- Step 1: Orchestrate ---
+    // --- Step 1: Orchestrate (with LLM cache when orchestrator is present) ---
     let orchestration = match &mut config.orchestrator {
-        Some(orch) => orch.orchestrate(query)?,
+        Some(orch) => {
+            let cache_key = orchestration_cache_key(query);
+            if let Some(cached_json) = config.store.get_llm_cache(&cache_key)? {
+                serde_json::from_str(&cached_json).unwrap_or_else(|_| {
+                    orch.orchestrate(query)
+                        .unwrap_or_else(|_| llm::heuristic_orchestrate(query))
+                })
+            } else {
+                let result = orch.orchestrate(query)?;
+                if let Ok(json) = serde_json::to_string(&result) {
+                    let _ = config
+                        .store
+                        .set_llm_cache(&cache_key, &json, "orchestrator");
+                }
+                result
+            }
+        }
         None => llm::heuristic_orchestrate(query),
     };
     let weights = llm::LaneWeights::from_intent(&orchestration.intent);