Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

fix(mcp): include complete result type in list responses

t8y2fd0e6ca31457
diff --git a/crates/dbx-mcp/src/http.rs b/crates/dbx-mcp/src/http.rs
index d75884bb11..6c7923d4a9 100644
--- a/crates/dbx-mcp/src/http.rs
+++ b/crates/dbx-mcp/src/http.rs
@@ -647,6 +647,27 @@ mod tests {
assert!(!modern_tools.is_empty());
assert_eq!(manager.sessions.read().await.len(), 1, "2026-07-28 discovery stays stateless");
+ for (client, is_modern) in [(&legacy, false), (&modern, true)] {
+ for (method, result) in [
+ ("tools/list", serde_json::to_value(client.list_tools(None).await.unwrap()).unwrap()),
+ ("resources/list", serde_json::to_value(client.list_resources(None).await.unwrap()).unwrap()),
+ (
+ "resources/templates/list",
+ serde_json::to_value(client.list_resource_templates(None).await.unwrap()).unwrap(),
+ ),
+ ] {
+ if is_modern {
+ assert_eq!(result["resultType"], "complete", "{method}");
+ assert_eq!(result["ttlMs"], 0, "{method}");
+ assert_eq!(result["cacheScope"], "private", "{method}");
+ } else {
+ for field in ["resultType", "ttlMs", "cacheScope"] {
+ assert!(result.get(field).is_none(), "legacy {method} unexpectedly includes {field}");
+ }
+ }
+ }
+ }
+
let _ = legacy.cancel().await;
let _ = modern.cancel().await;
cancellation.cancel();
diff --git a/crates/dbx-mcp/src/server.rs b/crates/dbx-mcp/src/server.rs
index 6650d6594c..4d3b70fc55 100644
--- a/crates/dbx-mcp/src/server.rs
+++ b/crates/dbx-mcp/src/server.rs
@@ -3781,14 +3781,7 @@ impl ServerHandler for DbxMcpServer {
})
.into_iter()
.collect();
- Ok(ListResourcesResult {
- result_type: None,
- meta: None,
- next_cursor: None,
- ttl_ms: None,
- cache_scope: None,
- resources,
- })
+ Ok(ListResourcesResult::with_all_items(resources))
}
async fn list_resource_templates(
@@ -3823,14 +3816,7 @@ impl ServerHandler for DbxMcpServer {
.with_mime_type("text/markdown"),
);
}
- Ok(ListResourceTemplatesResult {
- result_type: None,
- meta: None,
- next_cursor: None,
- ttl_ms: None,
- cache_scope: None,
- resource_templates,
- })
+ Ok(ListResourceTemplatesResult::with_all_items(resource_templates))
}
async fn read_resource(
@@ -3880,14 +3866,7 @@ impl ServerHandler for DbxMcpServer {
_request: Option<rmcp::model::PaginatedRequestParams>,
_context: rmcp::service::RequestContext<rmcp::service::RoleServer>,
) -> Result<rmcp::model::ListToolsResult, rmcp::ErrorData> {
- Ok(rmcp::model::ListToolsResult {
- result_type: None,
- meta: None,
- next_cursor: None,
- ttl_ms: None,
- cache_scope: None,
- tools: self.policy_filtered_tools().await,
- })
+ Ok(rmcp::model::ListToolsResult::with_all_items(self.policy_filtered_tools().await))
}
}
diff --git a/crates/dbx-mcp/tests/protocol.rs b/crates/dbx-mcp/tests/protocol.rs
index 0c62980070..30b99117c3 100644
--- a/crates/dbx-mcp/tests/protocol.rs
+++ b/crates/dbx-mcp/tests/protocol.rs
@@ -5,12 +5,13 @@ use dbx_core::{
agent_events::ToolResult, agent_tools::AgentSqlPermissions, models::connection::ConnectionConfig,
storage::McpGlobalPolicy,
};
-use dbx_mcp::{DbxBackend, DbxMcpServer, McpScope};
+use dbx_mcp::{with_legacy_discovery_fallback, DbxBackend, DbxMcpServer, McpScope};
use rmcp::{
model::{CallToolRequestParams, ReadResourceRequestParams, ResourceContents},
ServiceExt,
};
use serde_json::{json, Map, Value};
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, DuplexStream};
struct EmptyBackend;
@@ -357,6 +358,105 @@ fn postgres_connection(id: &str, name: &str) -> ConnectionConfig {
.expect("test PostgreSQL connection")
}
+async fn stdio_request(stream: &mut BufReader<DuplexStream>, id: i64, method: &str, params: Value) -> Value {
+ let request = json!({"jsonrpc": "2.0", "id": id, "method": method, "params": params});
+ stream.get_mut().write_all(format!("{request}\n").as_bytes()).await.unwrap();
+ let mut line = String::new();
+ tokio::time::timeout(std::time::Duration::from_secs(5), stream.read_line(&mut line))
+ .await
+ .expect("stdio response timed out")
+ .expect("read stdio response");
+ let response: Value = serde_json::from_str(&line).expect("JSON-RPC response");
+ assert_eq!(response["id"], id);
+ assert!(response.get("error").is_none(), "{method}: {response}");
+ response["result"].clone()
+}
+
+#[tokio::test]
+async fn list_results_include_complete_discriminator_for_modern_stdio_clients() {
+ let meta = json!({
+ "io.modelcontextprotocol/protocolVersion": "2026-07-28",
+ "io.modelcontextprotocol/clientCapabilities": {},
+ "io.modelcontextprotocol/clientInfo": {"name": "protocol-test", "version": "0"}
+ });
+ for hide_tools in [false, true] {
+ let backend = PolicyBackend {
+ policy: McpGlobalPolicy { allowed_tool_names: hide_tools.then(Vec::new), ..Default::default() },
+ connections: Vec::new(),
+ group_paths: Ok(HashMap::new()),
+ };
+ let (server_transport, client_transport) = tokio::io::duplex(16 * 1024);
+ let server = DbxMcpServer::with_runtime_options(Arc::new(backend), McpScope::default(), false);
+ let server_task =
+ tokio::spawn(async move { server.serve(with_legacy_discovery_fallback(server_transport)).await });
+ let mut client = BufReader::new(client_transport);
+ let discovery = stdio_request(&mut client, 1, "server/discover", json!({"_meta": meta})).await;
+ assert!(discovery["supportedVersions"].as_array().unwrap().contains(&json!("2026-07-28")));
+
+ for (index, (method, items)) in [
+ ("tools/list", "tools"),
+ ("resources/list", "resources"),
+ ("resources/templates/list", "resourceTemplates"),
+ ]
+ .into_iter()
+ .enumerate()
+ {
+ let result = stdio_request(&mut client, index as i64 + 2, method, json!({"_meta": meta})).await;
+ assert_eq!(result["resultType"], "complete", "{method} requires resultType on 2026-07-28");
+ assert_eq!(result["ttlMs"], 0, "{method}");
+ assert_eq!(result["cacheScope"], "private", "{method}");
+ assert!(result.get("nextCursor").is_none(), "{method}");
+ assert_eq!(result[items].as_array().unwrap().is_empty(), hide_tools, "{method}");
+ }
+
+ drop(client);
+ server_task.abort();
+ }
+}
+
+#[tokio::test]
+async fn list_results_preserve_legacy_stdio_shapes_after_initialize() {
+ for requested_version in ["2025-03-26", "2025-06-18", "2025-11-25", "2026-07-28"] {
+ let (server_transport, client_transport) = tokio::io::duplex(16 * 1024);
+ let server = DbxMcpServer::with_runtime_options(Arc::new(EmptyBackend), McpScope::default(), false);
+ let server_task =
+ tokio::spawn(async move { server.serve(with_legacy_discovery_fallback(server_transport)).await });
+ let mut client = BufReader::new(client_transport);
+ let initialized = stdio_request(
+ &mut client,
+ 1,
+ "initialize",
+ json!({
+ "protocolVersion": requested_version,
+ "capabilities": {},
+ "clientInfo": {"name": "protocol-test", "version": "0"}
+ }),
+ )
+ .await;
+ let negotiated_version = if requested_version == "2026-07-28" { "2025-11-25" } else { requested_version };
+ assert_eq!(initialized["protocolVersion"], negotiated_version);
+ client.get_mut().write_all(b"{\"jsonrpc\":\"2.0\",\"method\":\"notifications/initialized\"}\n").await.unwrap();
+
+ for (index, (method, items)) in [
+ ("tools/list", "tools"),
+ ("resources/list", "resources"),
+ ("resources/templates/list", "resourceTemplates"),
+ ]
+ .into_iter()
+ .enumerate()
+ {
+ let result = stdio_request(&mut client, index as i64 + 2, method, json!({})).await;
+ for field in ["resultType", "ttlMs", "cacheScope", "nextCursor"] {
+ assert!(result.get(field).is_none(), "{method} on {negotiated_version} unexpectedly includes {field}");
+ }
+ assert!(!result[items].as_array().unwrap().is_empty(), "{method}");
+ }
+
+ drop(client);
+ server_task.abort();
+ }
+}
+
#[tokio::test]
async fn initializes_lists_tools_and_calls_a_tool() {
let (server_transport, client_transport) = tokio::io::duplex(16 * 1024);