oxios-kernel 1.0.0

Oxios kernel: supervisor, event bus, state store
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
144
145
146
147
148

//! MCP integration — adapters between `oxios-mcp` and the kernel.
//!
//! Re-exports all types from the `oxios-mcp` crate and provides conversion
//! functions between MCP-native types and Oxios kernel types (`ToolDef`).

pub use oxios_mcp::{
    ClientInfo, InitializeParams, InitializeResult, MappedResource, McpBridge, McpCapabilities,
    McpClient, McpContentBlock, McpError, McpRequest, McpResponse, McpServer, McpServerConfig,
    McpTool, McpToolCallResult, McpToolsResult, ServerInfo,
};

use crate::tools::tool_types::{ArgumentDef, ToolDef};

/// Convert an MCP tool to an Oxios `ToolDef`.
///
/// Parses the `input_schema` as a JSON Schema object, extracting
/// properties from the top-level `"properties"` key.
pub fn mcp_tool_to_tool_def(tool: &McpTool) -> ToolDef {
    let arguments = if let Some(properties) = tool
        .input_schema()
        .get("properties")
        .and_then(|p| p.as_object())
    {
        let required_list: Vec<&str> = tool
            .input_schema()
            .get("required")
            .and_then(|r| r.as_array())
            .map(|arr| arr.iter().filter_map(|v| v.as_str()).collect())
            .unwrap_or_default();

        properties
            .iter()
            .map(|(name, schema)| {
                let description = schema
                    .get("description")
                    .and_then(|d| d.as_str())
                    .unwrap_or("No description")
                    .to_string();
                let required =
                    required_list.iter().any(|r| *r == name) && schema.get("default").is_none();

                ArgumentDef {
                    name: name.clone(),
                    description,
                    required,
                    default: schema
                        .get("default")
                        .and_then(|d| d.as_str().map(String::from)),
                }
            })
            .collect()
    } else {
        Vec::new()
    };

    ToolDef {
        name: tool.name().to_string(),
        description: tool.description().to_string(),
        arguments,
        command: String::new(),
    }
}

/// List all MCP tools as Oxios `ToolDef`s (existing API compatibility).
pub async fn list_tool_defs(bridge: &McpBridge) -> anyhow::Result<Vec<ToolDef>> {
    let tools = bridge.list_tools().await?;
    Ok(tools.iter().map(mcp_tool_to_tool_def).collect())
}

/// Get cached MCP tools as Oxios `ToolDef`s for a specific server.
pub async fn cached_tool_defs(bridge: &McpBridge, server_name: &str) -> Option<Vec<ToolDef>> {
    bridge
        .cached_tools(server_name)
        .await
        .map(|tools| tools.iter().map(mcp_tool_to_tool_def).collect())
}

/// Refresh and return MCP tools as Oxios `ToolDef`s for a specific server.
pub async fn refresh_tool_defs(
    bridge: &McpBridge,
    server_name: &str,
) -> anyhow::Result<Vec<ToolDef>> {
    let tools = bridge.refresh_tools(server_name).await?;
    Ok(tools.iter().map(mcp_tool_to_tool_def).collect())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_mcp_tool_to_tool_def() {
        let mcp_tool = McpTool {
            name: "test_tool".to_string(),
            description: "A test tool".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "arg1": {
                        "type": "string",
                        "description": "First argument"
                    },
                    "arg2": {
                        "type": "number",
                        "description": "Second argument",
                        "default": "42"
                    }
                },
                "required": ["arg1"]
            }),
        };

        let tool_def = mcp_tool_to_tool_def(&mcp_tool);

        assert_eq!(tool_def.name, "test_tool");
        assert_eq!(tool_def.description, "A test tool");
        assert_eq!(tool_def.arguments.len(), 2);

        let arg1 = tool_def
            .arguments
            .iter()
            .find(|a| a.name == "arg1")
            .unwrap();
        assert!(arg1.required);
        assert_eq!(arg1.description, "First argument");

        let arg2 = tool_def
            .arguments
            .iter()
            .find(|a| a.name == "arg2")
            .unwrap();
        assert!(!arg2.required);
        assert_eq!(arg2.default, Some("42".to_string()));
    }

    #[test]
    fn test_mcp_tool_to_tool_def_no_properties() {
        let mcp_tool = McpTool {
            name: "simple".to_string(),
            description: "No args".to_string(),
            input_schema: serde_json::json!({"type": "object"}),
        };

        let tool_def = mcp_tool_to_tool_def(&mcp_tool);
        assert!(tool_def.arguments.is_empty());
        assert_eq!(tool_def.command, "");
    }
}