crabmate 0.4.0

Rust AI agent: OpenAI-compatible chat/completions, function calling, HTTP serve, ops CLI
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

//! `crabmate-internal` 对 [`crate::cm_tools::memory_tool_host`] 的实现。

use std::path::Path;
use std::sync::Arc;

use crate::cm_config::AgentConfig;
use crate::cm_tools::memory_tool_host::{CodebaseSemanticToolHost, LongTermMemoryToolHost};

use crate::cm_internal::long_term_memory_tools::{
    LongTermMemoryHostInner, LongTermMemoryToolState, long_term_forget, long_term_memory_list,
    long_term_remember, summarize_experience,
};
use crate::cm_internal::memory::codebase_semantic_index::{CodebaseSemanticToolParams, run_tool};

pub struct CodebaseSemanticHost {
    pub params: CodebaseSemanticToolParams,
}

impl CodebaseSemanticHost {
    pub fn from_config(cfg: &AgentConfig) -> Self {
        Self {
            params: CodebaseSemanticToolParams::from_agent_config(cfg),
        }
    }

    pub fn from_params(params: CodebaseSemanticToolParams) -> Self {
        Self { params }
    }
}

impl CodebaseSemanticToolHost for CodebaseSemanticHost {
    fn run_search(&self, args_json: &str, working_dir: &Path, max_output_len: usize) -> String {
        run_tool(args_json, working_dir, &self.params, max_output_len)
    }
}

pub struct LongTermMemoryHost {
    inner: LongTermMemoryHostInner,
}

impl LongTermMemoryHost {
    pub fn new(
        rt: Arc<crate::cm_internal::memory::long_term_memory::LongTermMemoryRuntime>,
        scope_id: String,
    ) -> Self {
        Self {
            inner: LongTermMemoryHostInner { rt, scope_id },
        }
    }
}

impl LongTermMemoryToolHost for LongTermMemoryHost {
    fn dispatch(&self, tool_name: &str, args_json: &str, cfg: &AgentConfig) -> String {
        let st = LongTermMemoryToolState {
            cfg,
            rt: &self.inner.rt,
            scope: self.inner.scope_id.as_str(),
        };
        match tool_name {
            "long_term_remember" => long_term_remember(args_json, &st),
            "long_term_forget" => long_term_forget(args_json, &st),
            "long_term_memory_list" => long_term_memory_list(args_json, &st),
            "summarize_experience" => summarize_experience(args_json, &st),
            _ => format!("错误：未知长期记忆工具 `{tool_name}`"),
        }
    }
}

/// 工具 dispatch 路径在栈上构造记忆宿主，供 [`crate::cm_tools::tools::ToolContext`] 借用。
pub struct DispatchMemoryHosts {
    pub codebase: CodebaseSemanticHost,
    pub long_term: Option<LongTermMemoryHost>,
}

impl DispatchMemoryHosts {
    pub fn from_dispatch_inputs(
        cfg: &AgentConfig,
        ltm: Option<Arc<crate::cm_internal::memory::long_term_memory::LongTermMemoryRuntime>>,
        scope_id: Option<&str>,
    ) -> Self {
        let codebase = CodebaseSemanticHost::from_config(cfg);
        let (mem_rt, mem_scope) =
            crate::cm_internal::memory::long_term_memory::tool_context_memory_extras(cfg, ltm, scope_id);
        let long_term = mem_rt
            .zip(mem_scope)
            .map(|(rt, scope)| LongTermMemoryHost::new(rt, scope));
        Self {
            codebase,
            long_term,
        }
    }

    pub fn codebase_ref(&self) -> &dyn CodebaseSemanticToolHost {
        &self.codebase
    }

    pub fn long_term_ref(&self) -> Option<&dyn LongTermMemoryToolHost> {
        self.long_term
            .as_ref()
            .map(|h| h as &dyn LongTermMemoryToolHost)
    }
}