@@ -1,218 +0,0 @@ -use std::future::Future; -use std::pin::Pin; - -use serde_json::json; - -use crate::{memory::MemoryStore, models::ToolDef, mvp::SimilarityMetric, retrieval}; - -use super::{Tool, ToolContext}; - -pub fn tool() -> Tool { - Tool::new(definition(), exec) -} - -fn definition() -> ToolDef { - ToolDef::function( - "recall", - "semantic search over long-term memory (facts stored across sessions). \ - does NOT search the current conversation — use this only for things you \ - might have stored previously with remember(). \ - use a specific, noun-heavy query like \"user's preferred editor\" not \ - \"what we just discussed\". \ - by default, filters out low-similarity hits using the runtime memory threshold. \ - with no tags: searches all memories by meaning. \ - with tags: searches only within memories that match those tags, \ - ranked by semantic similarity.", - json!({ - "type": "object", - "properties": { - "query": { - "type": "string", - "description": "what to search for by meaning" - }, - "tags": { - "type": "array", - "items": { "type": "string" }, - "description": "restrict search to memories with these tags, e.g. [\"person:mayer\"] or [\"preference\"]" - }, - "tag_mode": { - "type": "string", - "enum": ["and", "or"], - "description": "\"and\" = all tags must match, \"or\" = any tag matches (default: \"or\")" - }, - "limit": { - "type": "integer", - "description": "max results (default 5)" - }, - "max_distance": { - "type": "number", - "description": "optional cosine-distance cutoff (lower is stricter). defaults to the runtime memory similarity threshold" - } - }, - "required": ["query"] - }), - ) -} - -fn exec(args: serde_json::Value, ctx: ToolContext) -> Pin + Send>> { - Box::pin(execute(args, ctx)) -} - -async fn execute(args: serde_json::Value, ctx: ToolContext) -> String { - let query = match args["query"].as_str() { - Some(q) => q.to_string(), - None => return "error: missing required arg 'query'".into(), - }; - let tags: Vec = args["tags"] - .as_array() - .map(|arr| { - arr.iter() - .filter_map(|v| v.as_str().map(String::from)) - .collect() - }) - .unwrap_or_default(); - let tag_and = args["tag_mode"].as_str() == Some("and"); - let limit = args["limit"].as_u64().unwrap_or(5) as usize; - let max_distance = args["max_distance"] - .as_f64() - .map(|value| value as f32) - .unwrap_or(ctx.memory_sim_threshold); - - let emb = match ctx.llm.embed(&query).await { - Ok(e) => e, - Err(err) => return format!("error embedding query: {err}"), - }; - - if tags.is_empty() { - let corpus = match ctx.memory.get_searchable() { - Ok(corpus) => corpus, - Err(err) => return format!("error loading memories: {err}"), - }; - let outcome = retrieval::retrieve_exact( - &corpus, - &emb, - &retrieval::RetrievalConfig { - namespace: "default".to_string(), - top_k: limit, - initial_window_days: None, - expansion_window_days: Vec::new(), - expand_distance_threshold: None, - similarity_metric: SimilarityMetric::CosineDistance, - reference_time: Some(unix_timestamp()), - }, - None, - ); - let candidates: Vec<_> = outcome - .top_candidates - .into_iter() - .filter(|candidate| candidate.score < max_distance) - .collect(); - if candidates.is_empty() { - return "no memories found".into(); - } - return candidates - .into_iter() - .enumerate() - .map(|(idx, candidate)| { - let tag_str = if candidate.memory.tags.is_empty() { - String::new() - } else { - format!(" [{}]", candidate.memory.tags.join(", ")) - }; - let content = if idx >= ctx.verbatim_count { - if candidate.memory.text.chars().count() <= 120 { - format!("[snippet] {}", candidate.memory.text) - } else { - let truncated: String = candidate.memory.text.chars().take(120).collect(); - format!("[snippet] {truncated}...") - } - } else { - candidate.memory.text.clone() - }; - format!( - "[dist:{:.3}][id:{}]{tag_str}{} {}", - candidate.score, - candidate.memory.memory_id, - provenance_hint(&ctx.memory, candidate.memory.memory_id), - content - ) - }) - .collect::>() - .join("\n"); - } - - match ctx.memory.recall(Some(&emb), &tags, tag_and, limit) { - Ok(results) => { - let filtered: Vec<_> = results - .into_iter() - .filter(|entry| { - entry - .distance - .is_none_or(|distance| distance < max_distance) - }) - .collect(); - if filtered.is_empty() { - return "no memories found".into(); - } - filtered - .into_iter() - .enumerate() - .map(|(idx, e)| { - let tag_str = if e.tags.is_empty() { - String::new() - } else { - format!(" [{}]", e.tags.join(", ")) - }; - let content = if idx >= ctx.verbatim_count { - if e.content.chars().count() <= 120 { - format!("[snippet] {}", e.content) - } else { - let truncated: String = e.content.chars().take(120).collect(); - format!("[snippet] {truncated}...") - } - } else { - e.content.clone() - }; - format!( - "[dist:{:.3}][id:{}]{tag_str}{} {}", - e.distance.unwrap_or(0.0), - e.id, - provenance_hint(&ctx.memory, e.id), - content - ) - }) - .collect::>() - .join("\n") - } - Err(err) => format!("error: {err}"), - } -} - -fn provenance_hint(memory: &MemoryStore, memory_id: i64) -> String { - let hints = memory - .provenance_counts(memory_id) - .unwrap_or_default() - .into_iter() - .filter(|(_, count)| *count > 0) - .map(|(edge_type, count)| { - let name = match edge_type { - crate::mvp::MemoryEdgeType::DerivedFrom => "derived_from", - crate::mvp::MemoryEdgeType::Supersedes => "supersedes", - crate::mvp::MemoryEdgeType::Supports => "supports", - }; - format!("{name}:{count}") - }) - .collect::>(); - if hints.is_empty() { - String::new() - } else { - format!(" [{}]", hints.join(",")) - } -} - -fn unix_timestamp() -> i64 { - std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .map(|duration| duration.as_secs() as i64) - .unwrap_or_default() -}