crabtalk 0.0.22

Crabtalk library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

//! `search_sessions` — BM25 over indexed conversation messages,
//! returns ranked excerpts with bounded context windows.

use super::SessionsHook;
use crabllm_core::Provider;
use runtime::sessions::{SearchOptions, SessionHit, WindowItem};
use schemars::JsonSchema;
use serde::Deserialize;
use wcore::ToolDispatch;

/// Search past conversation messages by keyword. Returns ranked
/// excerpts (matched message + surrounding context) — never full
/// sessions. Use the returned session handle to drill in further.
#[derive(Deserialize, JsonSchema)]
pub struct SearchSessions {
    /// Keyword or phrase to match against message content.
    pub query: String,
    /// Maximum number of session hits to return. Defaults to 5;
    /// clamped to the index's hard cap.
    pub limit: Option<usize>,
    /// Messages to include before each match. Defaults to 4.
    pub context_before: Option<usize>,
    /// Messages to include after each match. Defaults to 4.
    pub context_after: Option<usize>,
    /// Restrict to sessions for this agent name.
    pub agent: Option<String>,
    /// Restrict to sessions started by this sender.
    pub sender: Option<String>,
}

impl<P: Provider + 'static> SessionsHook<P> {
    pub(super) async fn handle_search_sessions(
        &self,
        call: ToolDispatch,
    ) -> Result<String, String> {
        let input: SearchSessions =
            serde_json::from_str(&call.args).map_err(|e| format!("invalid arguments: {e}"))?;
        let shared = self
            .runtime
            .get()
            .ok_or_else(|| "search_sessions: runtime not initialized".to_owned())?;
        let rt = shared.read().await.clone();
        let opts = SearchOptions {
            limit: input.limit.unwrap_or(5),
            context_before: input.context_before.unwrap_or(4),
            context_after: input.context_after.unwrap_or(4),
            agent_filter: input.agent,
            sender_filter: input.sender,
        };
        let hits = rt.search_sessions(&input.query, &opts);
        Ok(format_hits(&hits))
    }
}

fn format_hits(hits: &[SessionHit]) -> String {
    if hits.is_empty() {
        return "no sessions found".to_owned();
    }
    hits.iter()
        .map(format_hit)
        .collect::<Vec<_>>()
        .join("\n---\n")
}

fn format_hit(hit: &SessionHit) -> String {
    let handle = hit.session_handle.as_str();
    let title = if hit.title.is_empty() {
        "(untitled)".to_owned()
    } else {
        hit.title.clone()
    };
    let header = format!(
        "## {title}\nsession: {handle} · agent: {agent} · sender: {sender}\nupdated: {updated} · matched message #{idx}",
        agent = hit.agent,
        sender = hit.sender,
        updated = hit.updated_at,
        idx = hit.msg_idx,
    );
    let body = hit
        .window
        .iter()
        .map(format_item)
        .collect::<Vec<_>>()
        .join("\n");
    format!("{header}\n{body}")
}

fn format_item(item: &WindowItem) -> String {
    let role = role_label(item);
    let trunc = if item.truncated { " …" } else { "" };
    format!(
        "- [{role} #{idx}] {snippet}{trunc}",
        role = role,
        idx = item.msg_idx,
        snippet = item.snippet,
        trunc = trunc,
    )
}

fn role_label(item: &WindowItem) -> String {
    use wcore::model::Role;
    match item.role {
        Role::User => "user".to_owned(),
        Role::Assistant if item.tool_name.is_some() => format!(
            "tool-call:{}",
            item.tool_name.as_deref().unwrap_or_default()
        ),
        Role::Assistant => "assistant".to_owned(),
        Role::Tool => format!("tool:{}", item.tool_name.as_deref().unwrap_or_default()),
        Role::System => "system".to_owned(),
        _ => "other".to_owned(),
    }
}