rab-agent 0.1.4

rab is a lightweight, extensible, Rust-based coding agent.
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! MCP config types — matching pi-mcp-adapter's config schema.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Root MCP config matching pi's mcp.json format.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct McpConfig {
    #[serde(default)]
    pub mcp_servers: HashMap<String, ServerEntry>,

    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub settings: Option<McpSettings>,
}

/// A single MCP server definition.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServerEntry {
    /// Command to spawn (e.g. "npx", "node").
    /// Optional for URL-based servers.
    #[serde(default)]
    pub command: Option<String>,

    #[serde(default)]
    pub args: Vec<String>,

    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<HashMap<String, String>>,

    /// Working directory for the server process.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,

    /// Lifecycle mode: "keep-alive" | "lazy" | "eager".
    /// Default: "lazy"
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub lifecycle: Option<String>,

    /// Idle timeout in minutes (overrides global setting for this server).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub idle_timeout: Option<u64>,

    /// Enable direct tools for this server (register as individual LLM tools).
    /// true = all tools, string[] = only named tools, false = proxy-only.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub direct_tools: Option<serde_json::Value>,

    /// Exclude specific MCP tools by original or prefixed name.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub exclude_tools: Vec<String>,

    /// For HTTP-based servers: the URL endpoint.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,

    /// HTTP headers for URL-based servers.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub headers: Option<HashMap<String, String>>,
}

/// Global MCP settings.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpSettings {
    /// Tool naming prefix mode: "server" (default), "none", or "short".
    #[serde(default = "default_tool_prefix")]
    pub tool_prefix: String,

    /// Idle timeout in minutes (default: 10, 0 = disable).
    #[serde(default = "default_idle_timeout")]
    pub idle_timeout: u64,

    /// Enable direct tools globally for all servers.
    #[serde(default)]
    pub direct_tools: bool,
}

fn default_tool_prefix() -> String {
    "server".to_string()
}

fn default_idle_timeout() -> u64 {
    10
}

impl Default for McpSettings {
    fn default() -> Self {
        Self {
            tool_prefix: default_tool_prefix(),
            idle_timeout: default_idle_timeout(),
            direct_tools: false,
        }
    }
}

/// Format a tool name with server prefix.
pub fn format_tool_name(tool_name: &str, server_name: &str, prefix_mode: &str) -> String {
    match prefix_mode {
        "none" => tool_name.to_string(),
        "short" => {
            let short = server_name
                .trim_end_matches("mcp")
                .trim_end_matches("-mcp")
                .trim_end_matches('_');
            let p = short.replace('-', "_");
            if p.is_empty() {
                tool_name.to_string()
            } else {
                format!("{}_{}", p, tool_name)
            }
        }
        _ => {
            // "server" mode
            let p = server_name.replace('-', "_");
            format!("{}_{}", p, tool_name)
        }
    }
}

/// Cached tool metadata (persisted to disk for fast startup).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CachedTool {
    pub name: String,
    pub description: Option<String>,
    pub input_schema: serde_json::Value,
}

/// Per-server cache entry.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServerCacheEntry {
    pub config_hash: u64,
    pub tools: Vec<CachedTool>,
    pub cached_at: u64,
}

/// Root metadata cache structure.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MetadataCache {
    pub version: u32,
    pub servers: HashMap<String, ServerCacheEntry>,
}