Slim/0.0.14 (#195)

* make resource scraping optional
* Remove images/json calls
* Check whether it's a poci at tool call time

Author: slimslenderslacks

runbook.md

@@ -20,7 +20,7 @@ docker pull mcp/docker:prerelease
 
 ```sh
 # docker:command=build-release
-VERSION="0.0.13"
+VERSION="0.0.14"
 docker buildx build \
     --builder hydrobuild \
     --platform linux/amd64,linux/arm64 \

src/docker.clj

@@ -185,11 +185,10 @@
                   {:HostConfig
                    (merge
                     {:Binds
-                     (concat ["docker-lsp:/docker-lsp"
-                              "/var/run/docker.sock:/var/run/docker.sock"]
-                             (when host-dir [(format "%s:/project:rw" host-dir)])
-                             (when thread-id [(format "%s:/thread:rw" thread-id)])
-                             (or volumes mounts))}
+                     (concat
+                      (when host-dir [(format "%s:/project:rw" host-dir)])
+                      (when thread-id [(format "%s:/thread:rw" thread-id)])
+                      (or volumes mounts))}
                     (when network_mode
                       {:NetworkMode network_mode})
                     (when ports
@@ -227,9 +226,9 @@
    {:raw-args ["--unix-socket" "/var/run/docker.sock"]
     :throw false}))
 
-(defn inspect-image [{:keys [Id]}]
+(defn inspect-image [{:keys [Name Id]}]
   (curl/get
-   (format "http://localhost/images/%s/json" Id)
+    (format "http://localhost/images/%s/json" (or Name Id))
    {:raw-args ["--unix-socket" "/var/run/docker.sock"]
     :throw false}))
 
@@ -339,12 +338,9 @@
 
 (defn has-image? [image]
   (let [[_ digest] (re-find #".*@(.*)" image)]
-    (some
-     (fn [{:keys [RepoTags Id]}]
-       (or
-        (some #(= % image)  RepoTags)
-        (and digest (= digest Id))))
-     (images {}))))
+    (try
+      (image-inspect (if digest {:Id digest} {:Name image}))
+      (catch Throwable _))))
 
 (defn check-then-pull [container-definition]
   (when (not (has-image? (:image container-definition)))
@@ -375,9 +371,7 @@
   (check-then-pull container-definition)
   (let [{:keys [Entrypoint Cmd Env]}
         (->
-         (image-inspect
-          (-> (images {"reference" [(:image container-definition)]})
-              first))
+         (image-inspect {:Name (:image container-definition)})
          :Config)
         real-entrypoint (string/join " " (concat
                                           (or (:entrypoint container-definition) Entrypoint)
@@ -554,9 +548,9 @@
           stdout (PipedOutputStream.)
           stdout-reader (io/reader (PipedInputStream. stdout))]
       (async/go-loop []
-                     (when-let [line (.readLine stdout-reader)]
-                       (async/put! c {:stdout line})
-                       (recur))) 
+        (when-let [line (.readLine stdout-reader)]
+          (async/put! c {:stdout line})
+          (recur)))
       (loop [offset 0]
         (let [result (.read ^SocketChannel in header-buf)]
           (cond

src/extension/Makefile

@@ -1,6 +1,6 @@
 # IMAGE?=docker/labs-ai-tools-for-devs
 IMAGE?=docker/labs-ai-tools-for-devs
-TAG?=0.2.50
+TAG?=0.2.56
 
 BUILDER=buildx-multi-arch
 

src/extension/docker-compose.yaml

@@ -1,6 +1,6 @@
 services:
   mcp_docker:
-    image: mcp/docker:0.0.13
+    image: mcp/docker:0.0.14
     ports:
       - 8811:8811
     volumes:

src/jsonrpc/logger.clj

@@ -54,9 +54,9 @@
     `(when *logger*
        (-debug *logger* ~fmeta ~@args))))
 
-(defn trace [x]
-  (info "trace " x)
-  x)
+(defn trace
+  ([x] (info "trace " x) x)
+  ([s x] (info (format "%s %s" s x)) x))
 
 (defn log! [level args fmeta]
   (timbre/log! level :p args {:?line (:line fmeta)

src/jsonrpc/server.clj

@@ -201,9 +201,9 @@
                                 (async/into [])
                                 (async/<!!))]
     (merge
-      {:resourceTemplates resource-templates}
-      (when (= 100 (count resource-templates))
-        {:nextCursor nextCursor}))))
+     {:resourceTemplates resource-templates}
+     (when (= 100 (count resource-templates))
+       {:nextCursor nextCursor}))))
 
 (defmethod lsp.server/receive-request "resources/subscribe" [_ _ params]
   (logger/info "resources/subscribe" params)
@@ -261,51 +261,69 @@
          (mapcat (comp :content :result))
          (into []))))
 
+(defn get-functions [db*]
+  (->> @db* :mcp.prompts/registry vals (mapcat :functions)))
+
+(defn poci? [{:keys [db*] :as components} params]
+  (not
+   (= :mcp
+      (-> (filter #(= (-> params :name) (-> % :function :name)) (get-functions db*))
+          first
+          :function
+          :container
+          :type))))
+
+(defn make-tool-calls [{:keys [db* server-id] :as components} params {:keys [thread-id] :as opts}]
+  ;; TODO non-mcp tool calls are maps of content, role tool_call_id
+  ;;      we turn them into one text message and respond to the jsonrpc request here
+  ;;      for mcp tool calls the response will already be valid content
+  ;;        so we can concat it and just return the result (or error)
+  ;; tool-outputs are :content, :role, :tool_call_id 
+  ;;   (MCP doesn't care about :role or :tool_call_id - these are client concerns)
+  (let [tool-outputs (->>
+                      (tools/make-tool-calls
+                       0
+                       (partial
+                        tools/function-handler
+                        (merge
+                         {:functions (get-functions db*)
+                          :host-dir (-> @db* :host-dir)
+                          :server-id server-id}
+                         (when thread-id {:thread-id thread-id})))
+                       ;; tool calls are functions, which are arguments,name maps, and ids
+                       ;; mcp tool call params are also maps of name, and arguments
+                       [{:function (update
+                                    params :arguments
+                                    (fn [arguments]
+                                      (logger/trace
+                                       (-> arguments
+                                           (merge
+                                            (db/parameter-values (:name params))
+                                            (select-keys (-> @db* :servers (get server-id)) [:roots]))
+                                           (json/generate-string)))))
+                         ;; TODO there's no id here like in regular agent tool calling loops
+                         ;; MCP clients do this on their side (using just the response id)
+                         :id "1"}])
+                      (async/reduce conj [])
+                      (async/<!!))]
+    ;; TODO with mcp, tool-calls with errors are still jsonrpc results
+    ;;      protocol errors are jsonrpc errors, with a code and a message
+    ;; TODO if result is ::method-not-found, we'll get a protocol error
+    ;;      responding with a map containing an :error key will also generate a protocol error
+    {:content (create-tool-outputs tool-outputs)
+     :is-error false}))
+
 (defn mcp-tool-calls
   " params
   db* - uses mcp.prompts/registry and host-dir
   params - tools/call mcp params"
   [{:keys [db* server-id] :as components} params]
-  (volumes/with-volume
-    (fn [thread-id]
-      ;; TODO non-mcp tool calls are maps of content, role tool_call_id
-      ;;      we turn them into one text message and respond to the jsonrpc request here
-      ;;      for mcp tool calls the response will already be valid content
-      ;;        so we can concat it and just return the result (or error)
-      ;; tool-outputs are :content, :role, :tool_call_id 
-      ;;   (MCP doesn't care about :role or :tool_call_id - these are client concerns)
-      (let [tool-outputs (->>
-                          (tools/make-tool-calls
-                           0
-                           (partial
-                            tools/function-handler
-                            {:functions (->> @db* :mcp.prompts/registry vals (mapcat :functions))
-                             :host-dir (-> @db* :host-dir)
-                             :server-id server-id
-                             :thread-id thread-id})
-                           ;; tool calls are functions, which are arguments,name maps, and ids
-                           ;; mcp tool call params are also maps of name, and arguments
-                           [{:function (update
-                                        params :arguments
-                                        (fn [arguments]
-                                          (logger/trace
-                                           (-> arguments
-                                               (merge
-                                                (db/parameter-values (:name params))
-                                                (select-keys (-> @db* :servers (get server-id)) [:roots]))
-                                               (json/generate-string)))))
-                             :id "1"}])
-                          (async/reduce conj [])
-                          (async/<!!))]
-     ;; TODO with mcp, tool-calls with errors are still jsonrpc results
-     ;;      protocol errors are jsonrpc errors, with a code and a message
-     ;; TODO if result is ::method-not-found, we'll get a protocol error
-     ;;      responding with a map containing an :error key will also generate a protocol error
-        {:content
-         (concat
-          (create-tool-outputs tool-outputs)
-          (volumes/pick-up-mcp-resources thread-id (partial update-resources components)))
-         :is-error false}))))
+  (if (poci? components params)
+    (volumes/with-volume
+      (fn [thread-id]
+        (let [response (make-tool-calls components params {:thread-id thread-id})]
+          (update response :content concat (volumes/pick-up-mcp-resources thread-id (partial update-resources components))))))
+    (make-tool-calls components params {})))
 
 (defmethod lsp.server/receive-request "tools/call" [_ components params]
   (logger/info "tools/call")

src/mcp/client.clj

@@ -305,15 +305,9 @@
     (recur)))
 ;; ------------------------------
 
-(defn inspect-image [container-definition]
-  (:Id
-   (docker/image-inspect
-    (-> (docker/images {"reference" [(:image container-definition)]})
-        first))))
-
 (defn add-digest [container-definition]
   (docker/check-then-pull container-definition)
-  (assoc container-definition :digest (inspect-image container-definition)))
+  (assoc container-definition :digest (:Id (docker/image-inspect {:Name (:image container-definition)}))))
 
 (def cached-mcp-get-tools
   (fn [container-definition]

test/mcp/client_t.clj

@@ -253,6 +253,20 @@
             :workdir "/usr/local/app" }}]
     :local-get-tools -get-tools})
 
+  (get-mcp-tools-from-prompt
+   {:mcp [{:container
+           {:image "mcp/webflow:latest" 
+            :workdir "/app"
+            :secrets {:webflow.token "WEBFLOW_TOKEN"} }}]
+    :local-get-tools -get-tools})
+
+  (get-mcp-tools-from-prompt
+   {:mcp [{:container
+           {:image "mcp/azure:latest" 
+            :workdir "/app"
+            :command ["server" "start"] }}]
+    :local-get-tools -get-tools})
+
   (docker/run-container
    (docker/inject-secret-transform
     {:image "mcp/time:latest"