Route MCP protocol through shared libraries

Cargo.lock

@@ -758,6 +758,8 @@ dependencies = [
  "cadcraft-io",
  "cadcraft-render",
  "clap",
+ "craft-jsonrpc",
+ "craft-mcp",
  "getrandom 0.4.3",
  "libc",
  "log",
@@ -1131,11 +1133,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "craft-codepage"
-version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=6345459e1297ee85a7ca62b428a440691bd062c1#6345459e1297ee85a7ca62b428a440691bd062c1"
-
 [[package]]
 name = "craft-docpath"
 version = "0.1.0"
@@ -1153,11 +1150,9 @@ dependencies = [
 [[package]]
 name = "craft-dxf"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=6345459e1297ee85a7ca62b428a440691bd062c1#6345459e1297ee85a7ca62b428a440691bd062c1"
+source = "git+https://github.com/storytold/craft-libs?rev=006e4df225fca57e95ead0fb1f91920900798a99#006e4df225fca57e95ead0fb1f91920900798a99"
 dependencies = [
- "craft-codepage",
  "encoding_rs",
- "kurbo",
  "log",
  "thiserror 2.0.21",
 ]
@@ -1190,6 +1185,23 @@ dependencies = [
  "writeable",
 ]
 
+[[package]]
+name = "craft-jsonrpc"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=2c9903ca1d892b5446acf3598d8b142f3e64842f#2c9903ca1d892b5446acf3598d8b142f3e64842f"
+dependencies = [
+ "serde_json",
+]
+
+[[package]]
+name = "craft-mcp"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=2c9903ca1d892b5446acf3598d8b142f3e64842f#2c9903ca1d892b5446acf3598d8b142f3e64842f"
+dependencies = [
+ "craft-jsonrpc",
+ "serde_json",
+]
+
 [[package]]
 name = "craft-pdf"
 version = "0.1.0"

Cargo.toml

@@ -14,7 +14,7 @@ repository = "https://github.com/storytold/cadcraft"
 # internal
 cadcraft-geom = { path = "crates/geom" }
 # DXF tags: the shared reader and writer (moved from crates/dxf; craft-libs#791).
-craft-dxf = { git = "https://github.com/storytold/craft-libs", rev = "6345459e1297ee85a7ca62b428a440691bd062c1" }
+craft-dxf = { git = "https://github.com/storytold/craft-libs", rev = "006e4df225fca57e95ead0fb1f91920900798a99" }
 craft-dwg = { git = "https://github.com/storytold/craft-libs", rev = "7bb6c90076a0177d01cc4c482e7fd8dc9f31a8bf" }
 cadcraft-color = { path = "crates/color" }
 cadcraft-doc = { path = "crates/doc" }
@@ -25,6 +25,8 @@ cadcraft-io = { path = "crates/io" }
 cadcraft-engine = { path = "crates/engine" }
 cadcraft-ui-egui = { path = "crates/ui-egui" }
 cadcraft-mcp = { path = "crates/mcp" }
+craft-mcp = { git = "https://github.com/storytold/craft-libs", rev = "2c9903ca1d892b5446acf3598d8b142f3e64842f" }
+craft-jsonrpc = { git = "https://github.com/storytold/craft-libs", rev = "2c9903ca1d892b5446acf3598d8b142f3e64842f" }
 # Which paths stored in a drawing (xrefs, data links) may be opened.
 craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0" }
 # PDF writing (krilla) for plots, and reading them back in tests. The root patches below pin

crates/fonts/src/mtext.rs

@@ -225,8 +225,11 @@ const MAX_ATOMS: usize = 200_000;
 /// Scale of stacked text relative to the surrounding text.
 const STACK_SCALE: f64 = 0.7;
 
-// Shared DXF escape handling and parameterized-command classification.
-pub(crate) use craft_dxf::mtext::{takes_arg, unescape_codes};
+/// Codes that take an argument terminated by `;` (besides `\S`, which has its own scan). Any
+/// other code stands alone, so a missing `;` must not swallow the text after it.
+pub(crate) fn takes_arg(code: char) -> bool {
+    matches!(code, 'f' | 'F' | 'H' | 'W' | 'Q' | 'T' | 'A' | 'C' | 'c' | 'p')
+}
 
 /// The line-spacing factor to lay out with: AutoCAD's 0.25..=4 range, 1 for a missing or
 /// non-finite value.
@@ -234,6 +237,77 @@ pub(crate) fn sane_line_spacing(v: f64) -> f64 {
     if v.is_finite() && v > 0.0 { v.clamp(0.25, 4.0) } else { 1.0 }
 }
 
+/// Four hex digits at `chars[at..at + 4]`.
+fn hex4(chars: &[char], at: usize) -> Option<u32> {
+    let digits = chars.get(at..at.checked_add(4)?)?;
+    digits.iter().try_fold(0u32, |acc, c| Some(acc * 16 + c.to_digit(16)?))
+}
+
+/// Push a decoded character so that the tokenizers read it as text, never as markup.
+fn push_literal(out: &mut String, c: char) {
+    if matches!(c, '\\' | '{' | '}') {
+        out.push('\\');
+    }
+    out.push(c);
+}
+
+/// Decode `\U+hhhh` (one UTF-16 unit; a surrogate pair gives one character, a lone surrogate
+/// U+FFFD) and `\M+nhhhh` (double-byte East Asian characters) to the characters they stand
+/// for. Malformed escapes are left for the tokenizers, which drop the backslash and the code.
+/// An escaped backslash (`\\U+0041`) is not an escape.
+pub(crate) fn unescape_codes(s: &str) -> std::borrow::Cow<'_, str> {
+    if !s.contains("\\U+") && !s.contains("\\M+") {
+        return std::borrow::Cow::Borrowed(s);
+    }
+    let chars: Vec<char> = s.chars().collect();
+    let mut out = String::with_capacity(s.len());
+    let mut i = 0;
+    while let Some(&c) = chars.get(i) {
+        if c != '\\' {
+            out.push(c);
+            i += 1;
+            continue;
+        }
+        let (n, plus) = (chars.get(i + 1).copied(), chars.get(i + 2).copied());
+        if n == Some('U') && plus == Some('+') {
+            if let Some(unit) = hex4(&chars, i + 3) {
+                i += 7;
+                let low = |at: usize| {
+                    (chars.get(at) == Some(&'\\') && chars.get(at + 1) == Some(&'U') && chars.get(at + 2) == Some(&'+'))
+                        .then(|| hex4(&chars, at + 3))
+                        .flatten()
+                        .filter(|u| (0xDC00..0xE000).contains(u))
+                };
+                let ch = if (0xD800..0xDC00).contains(&unit) {
+                    match low(i) {
+                        Some(lo) => {
+                            i += 7;
+                            char::from_u32(0x10000 + ((unit - 0xD800) << 10) + (lo - 0xDC00))
+                        }
+                        None => None,
+                    }
+                } else {
+                    char::from_u32(unit)
+                };
+                push_literal(&mut out, ch.unwrap_or('\u{fffd}'));
+                continue;
+            }
+        } else if n == Some('M') && plus == Some('+') && chars.get(i + 3).is_some_and(char::is_ascii_digit) && hex4(&chars, i + 4).is_some() {
+            push_literal(&mut out, craft_dxf::mif_escape_at(&chars, i).unwrap_or('\u{fffd}'));
+            i += 8;
+            continue;
+        }
+        // Any other backslash pair stays as it is (and an escaped backslash stays one).
+        out.push('\\');
+        i += 1;
+        if let Some(&next) = chars.get(i) {
+            out.push(next);
+            i += 1;
+        }
+    }
+    std::borrow::Cow::Owned(out)
+}
+
 fn arg(chars: &[char], from: usize) -> (String, usize) {
     let mut j = from;
     let mut a = String::new();

crates/mcp/Cargo.toml

@@ -9,6 +9,8 @@ license.workspace = true
 workspace = true
 
 [dependencies]
+craft-mcp = { workspace = true }
+craft-jsonrpc = { workspace = true }
 cadcraft-engine = { workspace = true }
 cadcraft-render = { workspace = true }
 cadcraft-io = { workspace = true }

crates/mcp/src/server.rs

@@ -22,25 +22,24 @@ Verify with inspect_drawing / query_entities and look with render.";
 
 pub struct Server {
     backend: Box<dyn Backend>,
-    initialized: bool,
-}
-
-fn response(id: Value, result: Value) -> Value {
-    json!({"jsonrpc": "2.0", "id": id, "result": result})
-}
-fn error(id: Value, code: i64, message: impl Into<String>) -> Value {
-    json!({"jsonrpc": "2.0", "id": id, "error": {"code": code, "message": message.into()}})
+    session: craft_mcp::Session,
 }
 
 impl Server {
     pub fn new(backend: Box<dyn Backend>) -> Self {
-        Self { backend, initialized: false }
+        Self {
+            backend,
+            session: craft_mcp::Session::new("cadcraft", env!("CARGO_PKG_VERSION"), craft_mcp::Policy::Compatible)
+                .with_capabilities(json!({"tools": {"listChanged": false}, "resources": {"listChanged": false}}))
+                .unwrap_or_else(|_| craft_mcp::Session::new("cadcraft", env!("CARGO_PKG_VERSION"), craft_mcp::Policy::Compatible))
+                .with_legacy_initialize(SUPPORTED, json!({"name": "cadcraft", "title": "CADCraft", "version": env!("CARGO_PKG_VERSION")})),
+        }
     }
     pub fn backend(&mut self) -> &mut dyn Backend {
         self.backend.as_mut()
     }
     pub fn is_initialized(&self) -> bool {
-        self.initialized
+        self.session.is_initialized()
     }
 
     /// Serve newline-delimited JSON-RPC until `input` closes (logs to stderr only).
@@ -62,53 +61,43 @@ impl Server {
             return None;
         }
         let reply = match serde_json::from_str::<Value>(line) {
-            // JSON-RPC 2.0: an empty batch is one Invalid Request, not silence.
-            Ok(Value::Array(batch)) if batch.is_empty() => Some(error(Value::Null, INVALID_REQUEST, "empty batch")),
-            Ok(Value::Array(batch)) => {
-                let replies: Vec<Value> = batch.into_iter().filter_map(|m| self.handle(m)).collect();
-                (!replies.is_empty()).then_some(Value::Array(replies))
-            }
-            Ok(msg) => self.handle(msg),
-            Err(e) => Some(error(Value::Null, PARSE_ERROR, format!("parse error: {e}"))),
+            Ok(msg) => self.handle_message(&msg),
+            Err(e) => Some(craft_jsonrpc::error_response(Value::Null, craft_jsonrpc::RpcError::new(PARSE_ERROR, format!("parse error: {e}")))),
         };
         reply.map(|r| r.to_string())
     }
 
     pub fn handle(&mut self, msg: Value) -> Option<Value> {
-        let Value::Object(o) = &msg else { return Some(error(Value::Null, INVALID_REQUEST, "message must be an object")) };
-        let id = o.get("id").cloned();
-        let Some(method) = o.get("method").and_then(Value::as_str) else {
-            if o.contains_key("result") || o.contains_key("error") {
-                return None;
-            }
-            return Some(error(id.unwrap_or(Value::Null), INVALID_REQUEST, "missing `method`"));
-        };
-        let params = o.get("params").cloned().unwrap_or(Value::Null);
-        let Some(id) = id else {
-            if method == "notifications/initialized" {
-                self.initialized = true;
-            }
-            return None;
-        };
-        Some(match self.request(method, &params) {
-            Ok(r) => response(id, r),
-            Err((code, m)) => error(id, code, m),
-        })
+        // `handle` historically routes only one envelope; batches belong to `handle_line`.
+        if msg.is_array() {
+            return Some(craft_jsonrpc::error_response(Value::Null, craft_jsonrpc::RpcError::new(INVALID_REQUEST, "message must be an object")));
+        }
+        self.handle_message(&msg)
+    }
+
+    fn handle_message(&mut self, msg: &Value) -> Option<Value> {
+        let server = std::cell::RefCell::new(self);
+        craft_jsonrpc::process_legacy(
+            msg,
+            |request| {
+                let mut server = server.borrow_mut();
+                if request.method == "initialize" {
+                    let instructions = format!("{INSTRUCTIONS} Backend: {}.", server.backend.describe());
+                    server.session.set_instructions(instructions);
+                }
+                if let Some(result) = server.session.request(request, msg.is_array()) {
+                    return result;
+                }
+                server
+                    .request(request.method, request.params.unwrap_or(&Value::Null))
+                    .map_err(|(code, message)| craft_jsonrpc::RpcError::new(code, message))
+            },
+            |request| server.borrow_mut().session.notification(request),
+        )
     }
 
     fn request(&mut self, method: &str, params: &Value) -> Result<Value, (i64, String)> {
         match method {
-            "initialize" => {
-                let asked = params.get("protocolVersion").and_then(Value::as_str).unwrap_or(PROTOCOL_VERSION);
-                let version = if SUPPORTED.contains(&asked) { asked } else { PROTOCOL_VERSION };
-                Ok(json!({
-                    "protocolVersion": version,
-                    "capabilities": {"tools": {"listChanged": false}, "resources": {"listChanged": false}},
-                    "serverInfo": {"name": "cadcraft", "title": "CADCraft", "version": env!("CARGO_PKG_VERSION")},
-                    "instructions": format!("{INSTRUCTIONS} Backend: {}.", self.backend.describe()),
-                }))
-            }
-            "ping" => Ok(json!({})),
             "tools/list" => Ok(tool_definitions(self.backend.has_ui())),
             "tools/call" => {
                 let name = params.get("name").and_then(Value::as_str).ok_or((INVALID_PARAMS, "missing tool `name`".to_string()))?;

crates/mcp/src/tests.rs

@@ -391,3 +391,24 @@ fn render_refuses_unknown_backgrounds_and_plot_styles() {
     assert!(crate::Backend::call(&mut h, "ui.render", json!({"background": "purple"})).is_err());
     assert!(crate::Backend::call(&mut h, "ui.render", json!({"plot_style": 3})).is_err());
 }
+
+#[test]
+fn legacy_protocol_routing_and_version_negotiation() {
+    let mut s = Server::new(Box::new(Headless::default()));
+    assert!(s.handle_line(r#"{"method":"notifications/initialized"}"#).is_none());
+    assert!(s.is_initialized());
+    for (params, expected) in
+        [(json!(null), "2025-06-18"), (json!({"protocolVersion":"2024-11-05"}), "2024-11-05"), (json!({"protocolVersion":"other"}), "2025-06-18")]
+    {
+        let response = call(&mut s, 1, "initialize", params);
+        assert_eq!(response["result"]["protocolVersion"], expected);
+        assert_eq!(response["result"]["serverInfo"]["title"], "CADCraft");
+        assert!(response["result"]["instructions"].as_str().unwrap().contains("Backend:"));
+    }
+    let response: Value =
+        serde_json::from_str(&s.handle_line(r#"[{"id":[1],"method":"ping","params":5},{"method":"ignored"},{"result":1},{}]"#).unwrap()).unwrap();
+    assert_eq!(
+        response,
+        json!([{"jsonrpc":"2.0","id":[1],"result":{}},{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"missing `method`"}}])
+    );
+}