Add Streamable HTTP MCP and harden web /v1 invoke auth.

agent_mcp_serve gains http transport; invoke injects Bearer/X-Api-Key and maps
unauthorized to 401; openai/agent field access prefers json.get over footnotes.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
cflmyandCursor committed 2026-10-16 17:33:24 +08:00
1 parent b43a08b2e2
commit 8353ba38fe
8 files changed
+525 -112

No files matched your search

+336 -41
View File
@@ -1,9 +1,14 @@
//! Minimal MCP Server (stdio JSON-RPC) — tools map to `lib.member` via host `call_lib_path`.
//! Minimal MCP Server — stdio JSON-RPC + Streamable HTTP (spec 2025-03-26).
use serde_json::{json, Map, Value};
use std::ffi::CStr;
use std::io::{BufRead, BufReader, Write};
use std::io::{BufRead, BufReader, Read, Write};
use std::net::{TcpListener, TcpStream};
use std::os::raw::{c_char, c_int};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::thread;
use std::time::{SystemTime, UNIX_EPOCH};
use crate::{host_query_json_args, parse_args, set_err, set_out};
@@ -98,6 +103,40 @@ fn call_tool(tools: &[Value], name: &str, arguments: &Value) -> Result<Value, St
}))
}
/// Handle one JSON-RPC message. Returns `None` for notifications (no response body).
fn dispatch_rpc(name: &str, tools: &[Value], msg: &Value) -> Option<Value> {
let id = msg.get("id").cloned().unwrap_or(Value::Null);
let method = msg.get("method").and_then(|v| v.as_str()).unwrap_or("");
let params = msg.get("params").cloned().unwrap_or(json!({}));
if matches!(id, Value::Null) && method.starts_with("notifications/") {
return None;
}
Some(match method {
"initialize" => rpc_result(
&id,
json!({
"protocolVersion": "2025-03-26",
"capabilities": { "tools": {} },
"serverInfo": { "name": name, "version": "0.1.0" }
}),
),
"tools/list" | "list_tools" => rpc_result(&id, tools_list(tools)),
"tools/call" | "call_tool" => {
let tname = params.get("name").and_then(|v| v.as_str()).unwrap_or("");
let args = params.get("arguments").cloned().unwrap_or(json!({}));
match call_tool(tools, tname, &args) {
Ok(r) => rpc_result(&id, r),
Err(e) => rpc_error(&id, -32000, &e),
}
}
"ping" => rpc_result(&id, json!({})),
"" => rpc_error(&id, -32600, "missing method"),
other => rpc_error(&id, -32601, &format!("method not found: {other}")),
})
}
/// Blocking stdio MCP loop. `tools` is a JSON array of `{name, fn, description}`.
pub fn serve_stdio(name: &str, tools: Vec<Value>) -> Result<Value, String> {
let stdin = std::io::stdin();
@@ -106,41 +145,274 @@ pub fn serve_stdio(name: &str, tools: Vec<Value>) -> Result<Value, String> {
let Some(msg) = read_line_message(&mut reader)? else {
break;
};
let id = msg.get("id").cloned().unwrap_or(Value::Null);
let method = msg.get("method").and_then(|v| v.as_str()).unwrap_or("");
let params = msg.get("params").cloned().unwrap_or(json!({}));
if matches!(id, Value::Null) && method.starts_with("notifications/") {
continue;
if let Some(reply) = dispatch_rpc(name, &tools, &msg) {
write_message(&reply)?;
}
let reply_msg = match method {
"initialize" => rpc_result(
&id,
json!({
"protocolVersion": "2024-11-05",
"capabilities": { "tools": {} },
"serverInfo": { "name": name, "version": "0.1.0" }
}),
),
"tools/list" | "list_tools" => rpc_result(&id, tools_list(&tools)),
"tools/call" | "call_tool" => {
let tname = params.get("name").and_then(|v| v.as_str()).unwrap_or("");
let args = params.get("arguments").cloned().unwrap_or(json!({}));
match call_tool(&tools, tname, &args) {
Ok(r) => rpc_result(&id, r),
Err(e) => rpc_error(&id, -32000, &e),
}
}
"ping" => rpc_result(&id, json!({})),
"" => rpc_error(&id, -32600, "missing method"),
other => rpc_error(&id, -32601, &format!("method not found: {other}")),
};
write_message(&reply_msg)?;
}
Ok(json!({ "ok": true, "transport": "stdio" }))
}
fn new_session_id() -> String {
static SEQ: AtomicU64 = AtomicU64::new(1);
let n = SEQ.fetch_add(1, Ordering::Relaxed);
let ms = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_millis())
.unwrap_or(0);
format!("mcp-{ms}-{n}")
}
fn read_http_request(
reader: &mut BufReader<TcpStream>,
) -> Result<(String, String, Vec<(String, String)>, Vec<u8>), String> {
let mut request_line = String::new();
reader
.read_line(&mut request_line)
.map_err(|e| format!("read request: {e}"))?;
let parts: Vec<&str> = request_line.trim().split_whitespace().collect();
if parts.len() < 2 {
return Err("bad request line".into());
}
let method = parts[0].to_string();
let path = parts[1].to_string();
let mut headers = Vec::new();
let mut content_length = 0usize;
loop {
let mut line = String::new();
reader
.read_line(&mut line)
.map_err(|e| format!("read header: {e}"))?;
let line = line.trim_end_matches(['\r', '\n']);
if line.is_empty() {
break;
}
if let Some((k, v)) = line.split_once(':') {
let key = k.trim().to_string();
let val = v.trim().to_string();
if key.eq_ignore_ascii_case("content-length") {
content_length = val.parse().unwrap_or(0);
}
headers.push((key, val));
}
}
let mut body = vec![0u8; content_length];
if content_length > 0 {
reader
.read_exact(&mut body)
.map_err(|e| format!("read body: {e}"))?;
}
Ok((method, path, headers, body))
}
fn header_get<'a>(headers: &'a [(String, String)], name: &str) -> Option<&'a str> {
headers
.iter()
.find(|(k, _)| k.eq_ignore_ascii_case(name))
.map(|(_, v)| v.as_str())
}
fn write_http(
stream: &mut TcpStream,
status: u16,
reason: &str,
content_type: &str,
body: &[u8],
extra: &[(&str, &str)],
) -> Result<(), String> {
let mut head = format!(
"HTTP/1.1 {status} {reason}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n",
body.len()
);
for (k, v) in extra {
head.push_str(k);
head.push_str(": ");
head.push_str(v);
head.push_str("\r\n");
}
head.push_str("\r\n");
stream
.write_all(head.as_bytes())
.map_err(|e| e.to_string())?;
stream.write_all(body).map_err(|e| e.to_string())?;
stream.flush().map_err(|e| e.to_string())?;
Ok(())
}
fn path_matches(req_path: &str, endpoint: &str) -> bool {
let base = req_path.split('?').next().unwrap_or(req_path);
base == endpoint || base.trim_end_matches('/') == endpoint.trim_end_matches('/')
}
fn handle_http_conn(
stream: TcpStream,
name: &str,
tools: &[Value],
endpoint: &str,
) -> Result<(), String> {
let mut reader = BufReader::new(stream);
let (method, path, headers, body) = read_http_request(&mut reader)?;
let mut stream = reader.into_inner();
if !path_matches(&path, endpoint) {
write_http(
&mut stream,
404,
"Not Found",
"application/json",
br#"{"error":"not_found"}"#,
&[],
)?;
return Ok(());
}
if method.eq_ignore_ascii_case("GET") {
// Optional SSE stream — empty keepalive then close (clients may 405).
let accept = header_get(&headers, "Accept").unwrap_or("");
if accept.contains("text/event-stream") {
let body = b": mcp streamable-http ready\n\n";
write_http(
&mut stream,
200,
"OK",
"text/event-stream",
body,
&[("Cache-Control", "no-cache")],
)?;
} else {
write_http(
&mut stream,
405,
"Method Not Allowed",
"application/json",
br#"{"error":"use_post_for_jsonrpc"}"#,
&[("Allow", "POST, GET")],
)?;
}
return Ok(());
}
if method.eq_ignore_ascii_case("DELETE") {
write_http(&mut stream, 200, "OK", "application/json", b"{}", &[])?;
return Ok(());
}
if !method.eq_ignore_ascii_case("POST") {
write_http(
&mut stream,
405,
"Method Not Allowed",
"application/json",
br#"{"error":"method_not_allowed"}"#,
&[("Allow", "POST, GET, DELETE")],
)?;
return Ok(());
}
let text = String::from_utf8_lossy(&body);
let msg: Value = serde_json::from_str(text.trim()).map_err(|e| format!("json-rpc: {e}"))?;
let is_init = msg.get("method").and_then(|v| v.as_str()) == Some("initialize");
let existing_sid = header_get(&headers, "Mcp-Session-Id")
.or_else(|| header_get(&headers, "MCP-Session-Id"))
.map(|s| s.to_string());
// Notifications → 202 Accepted, empty body.
if msg.get("id").is_none() || msg.get("id") == Some(&Value::Null) {
if let Some(m) = msg.get("method").and_then(|v| v.as_str()) {
if m.starts_with("notifications/") {
write_http(
&mut stream,
202,
"Accepted",
"application/json",
b"",
&[],
)?;
return Ok(());
}
}
}
let reply = match dispatch_rpc(name, tools, &msg) {
Some(r) => r,
None => {
write_http(
&mut stream,
202,
"Accepted",
"application/json",
b"",
&[],
)?;
return Ok(());
}
};
let body = serde_json::to_vec(&reply).map_err(|e| e.to_string())?;
let mut extras: Vec<(&str, String)> = Vec::new();
if is_init {
let sid = existing_sid.unwrap_or_else(new_session_id);
extras.push(("Mcp-Session-Id", sid));
} else if let Some(sid) = existing_sid {
extras.push(("Mcp-Session-Id", sid));
}
let extra_refs: Vec<(&str, &str)> = extras.iter().map(|(k, v)| (*k, v.as_str())).collect();
write_http(
&mut stream,
200,
"OK",
"application/json",
&body,
&extra_refs,
)?;
Ok(())
}
/// Streamable HTTP MCP (POST JSON-RPC + optional GET SSE). Spec 2025-03-26.
pub fn serve_http(
name: &str,
tools: Vec<Value>,
host: &str,
port: u16,
path: &str,
) -> Result<Value, String> {
let addr = format!("{host}:{port}");
let listener = TcpListener::bind(&addr).map_err(|e| format!("bind {addr}: {e}"))?;
let name = Arc::new(name.to_string());
let tools = Arc::new(tools);
let endpoint = Arc::new(if path.is_empty() {
"/mcp".to_string()
} else if path.starts_with('/') {
path.to_string()
} else {
format!("/{path}")
});
eprintln!(
"mcp streamable-http listening on http://{addr}{} (POST JSON-RPC)",
&*endpoint
);
for conn in listener.incoming() {
match conn {
Ok(stream) => {
let name = Arc::clone(&name);
let tools = Arc::clone(&tools);
let endpoint = Arc::clone(&endpoint);
thread::spawn(move || {
if let Err(e) = handle_http_conn(stream, &name, &tools, &endpoint) {
eprintln!("mcp http conn: {e}");
}
});
}
Err(e) => eprintln!("mcp http accept: {e}"),
}
}
Ok(json!({
"ok": true,
"transport": "http",
"host": host,
"port": port,
"path": *endpoint
}))
}
pub fn tools_from_value(v: &Value) -> Vec<Value> {
if let Some(arr) = v.as_array() {
return arr.clone();
@@ -180,13 +452,6 @@ pub unsafe extern "C" fn agent_mcp_serve(
.get("transport")
.and_then(|v| v.as_str())
.unwrap_or("stdio");
if transport != "stdio" {
set_err(
err_msg,
&format!("mcp serve: transport `{transport}` not implemented yet (use stdio)"),
);
return 1;
}
let name = args
.get("name")
.and_then(|v| v.as_str())
@@ -195,7 +460,38 @@ pub unsafe extern "C" fn agent_mcp_serve(
.get("tools")
.map(tools_from_value)
.unwrap_or_default();
match serve_stdio(name, tools) {
let result = match transport {
"stdio" => serve_stdio(name, tools),
"http" | "streamable-http" | "sse" => {
let host = args
.get("host")
.and_then(|v| v.as_str())
.unwrap_or("127.0.0.1");
let port = args
.get("port")
.and_then(|v| {
v.as_u64()
.or_else(|| v.as_i64().map(|n| n as u64))
.or_else(|| v.as_str().and_then(|s| s.parse().ok()))
})
.unwrap_or(7434) as u16;
let path = args
.get("path")
.and_then(|v| v.as_str())
.unwrap_or("/mcp");
serve_http(name, tools, host, port, path)
}
other => {
set_err(
err_msg,
&format!("mcp serve: transport `{other}` not supported (use stdio|http)"),
);
return 1;
}
};
match result {
Ok(v) => {
set_out(out_json, &v.to_string());
0
@@ -207,6 +503,5 @@ pub unsafe extern "C" fn agent_mcp_serve(
}
}
// Silence unused import if CStr unused in this module.
#[allow(dead_code)]
fn _unused(_: &CStr) {}