refactor: switch from clojure.data.json to cheshire

.mcp-tasks.edn

@@ -1 +1 @@
-{:story-branch-management? true}
+{:branch-management? true}

components/client-transport/src/mcp_clj/client_transport/stdio.clj

@@ -80,7 +80,7 @@
     (let [^Process process (:process process-info)]
       (try
         (.destroy process)
-        (when-not (.waitFor process 5000 TimeUnit/MILLISECONDS)
+        (when-not (.waitFor process (long 5000) TimeUnit/MILLISECONDS)
           (log/warn :client/process-force-kill))
         (catch Exception e
           (log/error :client/process-close-error {:error e})))))

components/http-client/deps.edn

@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure {:mvn/version "1.12.0"}
-        org.clojure/data.json {:mvn/version "2.5.0"}}
+        poly/json {:local/root "../json"}}
  :aliases
  {:test {:extra-paths ["test"]
          :extra-deps {}}}}

components/http-client/src/mcp_clj/http_client/core.clj

@@ -1,8 +1,8 @@
 (ns mcp-clj.http-client.core
   "HTTP client implementation using JDK HttpClient"
   (:require
-    [clojure.data.json :as json]
-    [clojure.string :as str])
+    [clojure.string :as str]
+    [mcp-clj.json :as json])
   (:import
     (java.net
       URI)
@@ -98,7 +98,7 @@
      :headers headers
      :body (case as
              :json (when (and body (not (str/blank? body)))
-                     (json/read-str body :key-fn keyword))
+                     (json/parse body))
              :stream body
              :string body
              body)}))

components/http/deps.edn

@@ -1 +1,3 @@
-{}
+{:paths ["src"]
+ :deps {org.clojure/clojure {:mvn/version "1.12.0"}
+        poly/json {:local/root "../json"}}}

components/http/src/mcp_clj/http.clj

@@ -1,13 +1,13 @@
 (ns mcp-clj.http
   (:require
-    [clojure.data.json :as json]))
+    [mcp-clj.json :as json]))
 
 (defn response
   "Return a minimal status 200 response map with the given body."
   [body]
-  {:status  200
+  {:status 200
    :headers {}
-   :body    body})
+   :body body})
 
 (defn status
   "Returns an updated response map with the given status."
@@ -27,7 +27,7 @@
 (defn json-response
   "Create a JSON response with given status"
   [data status-code]
-  (-> (response (json/write-str data))
+  (-> (response (json/write data))
       (status status-code)
       (content-type "application/json")))
 

components/in-memory-transport/src/mcp_clj/in_memory_transport/shared.clj

@@ -73,22 +73,29 @@
 ;; Pending requests management
 
 (defn add-pending-request!
-  "Add a pending request future"
+  "Add a pending request future.
+
+   Coerces request-id to Long for consistent map key type."
   [shared-transport request-id future]
-  (swap! (:pending-requests shared-transport) assoc request-id future))
+  (swap! (:pending-requests shared-transport) assoc (long request-id) future))
 
 (defn remove-pending-request!
-  "Remove and return a pending request future"
+  "Remove and return a pending request future.
+
+   Coerces request-id to Long to handle JSON parsing returning Integer."
   ^CompletableFuture [shared-transport request-id]
   (let [requests (:pending-requests shared-transport)
-        future   (get @requests request-id)]
-    (swap! requests dissoc request-id)
+        id (long request-id)
+        future (get @requests id)]
+    (swap! requests dissoc id)
     future))
 
 (defn get-pending-request
-  "Get a pending request future without removing it"
+  "Get a pending request future without removing it.
+
+   Coerces request-id to Long to handle JSON parsing returning Integer."
   [shared-transport request-id]
-  (get @(:pending-requests shared-transport) request-id))
+  (get @(:pending-requests shared-transport) (long request-id)))
 
 ;; Server handler management
 

components/json-rpc/deps.edn

@@ -1,9 +1,9 @@
 {:paths ["src"]
- :deps  {org.clojure/clojure   {:mvn/version "1.12.0"}
-         org.clojure/data.json {:mvn/version "2.5.0"}
-         poly/http-client      {:local/root "../http-client"}}
+ :deps {org.clojure/clojure {:mvn/version "1.12.0"}
+        poly/http-client {:local/root "../http-client"}
+        poly/json {:local/root "../json"}}
  :aliases
- {:dev  {:extra-paths ["test"]
-         :extra-deps  {hato/hato {:mvn/version "1.0.0"}}}
+ {:dev {:extra-paths ["test"]
+        :extra-deps {hato/hato {:mvn/version "1.0.0"}}}
   :test {:extra-paths ["test"]
-         :extra-deps  {hato/hato {:mvn/version "1.0.0"}}}}}
+         :extra-deps {hato/hato {:mvn/version "1.0.0"}}}}}

components/json-rpc/src/mcp_clj/json_rpc/http_client.clj

@@ -1,9 +1,9 @@
 (ns mcp-clj.json-rpc.http-client
   "JSON-RPC client for HTTP transport with SSE support"
   (:require
-    [clojure.data.json :as json]
     [clojure.string :as str]
     [mcp-clj.http-client.core :as http-client]
+    [mcp-clj.json :as json]
     [mcp-clj.json-rpc.executor :as executor]
     [mcp-clj.json-rpc.protocols :as protocols]
     [mcp-clj.log :as log])
@@ -71,12 +71,14 @@
   "Handle JSON-RPC response by completing the corresponding future"
   [client {:keys [id result error] :as response}]
   (if id
-    (if-let [future (.remove ^ConcurrentHashMap (:pending-requests client) id)]
-      (if error
-        (.completeExceptionally ^CompletableFuture future
-                                (ex-info "JSON-RPC error" error))
-        (.complete ^CompletableFuture future result))
-      (log/warn :rpc/orphan-response {:response response}))
+    ;; Normalize ID to Long to handle Integer/Long mismatch from JSON parsing
+    (let [normalized-id (long id)]
+      (if-let [future (.remove ^ConcurrentHashMap (:pending-requests client) normalized-id)]
+        (if error
+          (.completeExceptionally ^CompletableFuture future
+                                  (ex-info "JSON-RPC error" error))
+          (.complete ^CompletableFuture future result))
+        (log/warn :rpc/orphan-response {:response response})))
     ;; No ID means it's a notification
     (when-let [handler (:notification-handler client)]
       (handler response))))
@@ -122,7 +124,7 @@
             ;; Empty line signals end of event
             (when-let [event (parse-sse-event event-lines)]
               (try
-                (let [data (json/read-str (:data event) :key-fn keyword)]
+                (let [data (json/parse (:data event))]
                   (log/debug :sse/event {:event event :data data})
                   (handle-response client data))
                 (catch Exception e
@@ -185,11 +187,11 @@
   "Send JSON-RPC request and return CompletableFuture with response"
   [client method params timeout-ms]
   (let [request-id (generate-request-id client)
-        request    {:jsonrpc "2.0"
-                    :id      request-id
-                    :method  method
-                    :params  params}
-        future     (CompletableFuture.)]
+        request {:jsonrpc "2.0"
+                 :id request-id
+                 :method method
+                 :params params}
+        future (CompletableFuture.)]
 
     ;; Store the future for this request
     (.put ^ConcurrentHashMap (:pending-requests client) request-id future)
@@ -200,17 +202,17 @@
       (fn []
         (try
           (log/debug :client/send "Send request" {:method method})
-          (let [url      (str (:base-url client) "/")
-                headers  (make-headers client)
+          (let [url (str (:base-url client) "/")
+                headers (make-headers client)
                 response (http-client/http-post url
-                                                {:headers          headers
-                                                 :body             (json/write-str request)
-                                                 :content-type     :json
-                                                 :accept           :json
-                                                 :as               :json
+                                                {:headers headers
+                                                 :body (json/write request)
+                                                 :content-type :json
+                                                 :accept :json
+                                                 :as :json
                                                  :throw-exceptions false})]
             (log/debug :client/send
-                       {:msg      "Receive response"
+                       {:msg "Receive response"
                         :response response})
             (if (= 200 (:status response))
               (do
@@ -239,13 +241,13 @@
                 (log/error
                   :http/request-failed
                   {:status (:status response)
-                   :body   (:body response)})
+                   :body (:body response)})
                 (.completeExceptionally
                   future
                   (ex-info
                     error-msg
                     {:status (:status response)
-                     :body   (:body response)})))))
+                     :body (:body response)})))))
           (catch Exception e
             (log/error :http/request-error {:error e :method method})
             (.completeExceptionally future e)))))
@@ -273,7 +275,7 @@
                               response (http-client/http-post
                                          url
                                          {:headers headers
-                                          :body (json/write-str notification)
+                                          :body (json/write notification)
                                           :content-type :json
                                           :throw-exceptions false})]
                           (when (not= 200 (:status response))

components/json-rpc/src/mcp_clj/json_rpc/http_server.clj

@@ -1,10 +1,10 @@
 (ns mcp-clj.json-rpc.http-server
   "JSON-RPC 2.0 server with MCP Streamable HTTP transport (2025-03-26 spec)"
   (:require
-    [clojure.data.json :as json]
     [clojure.string :as str]
     [mcp-clj.http :as http]
     [mcp-clj.http-server.adapter :as http-server]
+    [mcp-clj.json :as json]
     [mcp-clj.json-rpc.executor :as executor]
     [mcp-clj.json-rpc.json-protocol :as json-protocol]
     [mcp-clj.json-rpc.protocols :as protocols]
@@ -91,7 +91,7 @@
       (let [session-id (extract-session-id request)
             session (get @session-id->session session-id)
             body-str (slurp (:body request))
-            rpc-data (json/read-str body-str :key-fn keyword)]
+            rpc-data (json/parse body-str)]
         (log/info :rpc/http-post
                   {:session-id session-id
                    :has-session (some? session)
@@ -111,13 +111,36 @@
                              :internal-error
                              (.getMessage e))))]
             (http/json-response result http/Ok)))))
+    (catch com.fasterxml.jackson.core.JsonParseException e
+      (log/warn :rpc/json-parse-error {:error (.getMessage e)})
+      (http/json-response
+        (json-protocol/json-rpc-error
+          :parse-error
+          (str "Invalid JSON: " (.getMessage e)))
+        http/BadRequest))
+    (catch clojure.lang.ExceptionInfo e
+      (if (= :parse-error (:type (ex-data e)))
+        (do
+          (log/warn :rpc/json-parse-error {:error (.getMessage e)})
+          (http/json-response
+            (json-protocol/json-rpc-error
+              :parse-error
+              (.getMessage e))
+            http/BadRequest))
+        (do
+          (log/error :rpc/post-error {:error (.getMessage e)})
+          (http/json-response
+            (json-protocol/json-rpc-error
+              :internal-error
+              (.getMessage e))
+            http/InternalServerError))))
     (catch Exception e
       (log/error :rpc/post-error {:error (.getMessage e)})
       (http/json-response
         (json-protocol/json-rpc-error
-          :parse-error
-          "Invalid JSON")
-        http/BadRequest))))
+          :internal-error
+          (.getMessage e))
+        http/InternalServerError))))
 
 (defn- handle-sse-get
   "Handle SSE stream setup via GET"
@@ -135,7 +158,7 @@
                       session-id
                       (fn [message]
                         (let [event-id (.incrementAndGet event-counter)]
-                          (reply! (assoc (sse/message (json/write-str message))
+                          (reply! (assoc (sse/message (json/write message))
                                          :id (str event-id)))))
                       (fn []
                         (log/info :http/sse-close {:session-id session-id})
@@ -176,19 +199,19 @@
     (if (str/includes? (get (:headers request) "accept" "") "text/event-stream")
       (handle-sse-get session-id->session allowed-origins request)
       (http/json-response
-        {"transport"    "streamable-http"
-         "version"      "2025-03-26"
-         "capabilities" {"sse"       true
-                         "batch"     true
+        {"transport" "streamable-http"
+         "version" "2025-03-26"
+         "capabilities" {"sse" true
+                         "batch" true
                          "resumable" true}}
         http/Ok))
 
     ;; 404 for unknown endpoints
     (do
       (log/warn :http/not-found
-                {:method   request-method
-                 :uri      uri
-                 :request  request
+                {:method request-method
+                 :uri uri
+                 :request request
                  :handlers handlers})
       (http/text-response "Not Found" http/NotFound))))
 
@@ -201,35 +224,35 @@
            allowed-origins
            on-connect
            on-disconnect]
-    :or   {num-threads     (* 2 (.availableProcessors (Runtime/getRuntime)))
-           port            0
-           allowed-origins []
-           on-connect      (fn [& _])
-           on-disconnect   (fn [& _])}}]
+    :or {num-threads (* 2 (.availableProcessors (Runtime/getRuntime)))
+         port 0
+         allowed-origins []
+         on-connect (fn [& _])
+         on-disconnect (fn [& _])}}]
   {:pre [(ifn? on-connect) (ifn? on-disconnect) (coll? allowed-origins)]}
-  (let [executor                   (executor/create-executor num-threads)
-        session-id->session        (atom {})
-        handlers                   (atom nil)
-        handler                    (partial handle-request
-                                            executor
-                                            session-id->session
-                                            handlers
-                                            allowed-origins)
+  (let [executor (executor/create-executor num-threads)
+        session-id->session (atom {})
+        handlers (atom nil)
+        handler (partial handle-request
+                         executor
+                         session-id->session
+                         handlers
+                         allowed-origins)
         {:keys [server port stop]} (http-server/run-server
                                      handler
                                      {:executor executor :port port})]
 
     (log/info :http/server-created
               {:port port :allowed-origins allowed-origins})
 
-    {:server              server
-     :port                port
-     :handlers            handlers
+    {:server server
+     :port port
+     :handlers handlers
      :session-id->session session-id->session
-     :stop                (fn []
-                            (log/info :http/server-stopping)
-                            (stop)
-                            (executor/shutdown-executor executor))}))
+     :stop (fn []
+             (log/info :http/server-stopping)
+             (stop)
+             (executor/shutdown-executor executor))}))
 
 ;; Server Operations