foobara-mcp-connector 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9887a812a0026b235492eaf1c5c4af194bc11b784211baaeb3e742a5c4377aca
-  data.tar.gz: 242f3614112c8a58613e7773421356a888a7214a2e235341efdfdc871425e23a
+  metadata.gz: 907ef0b728ab96d109ef5db1a5938a322537dc97b442d36386fcdbb8826fbcee
+  data.tar.gz: afef5e6b376f2f50cc630b535d0edc0f110d4421c5540ce33322b55e4ffc5c89
 SHA512:
-  metadata.gz: 86a3e8605855df453482e0ac38b7bdf329b6afcaab574bea1061e8931cec9051cdcc032cf53a8c062d1422b83251ba5a32d1f71f0448bbf4df5f2cabf9f0685e
-  data.tar.gz: df1d38a223b69e48f009881b3e4b4ecca9768c6b6a21030326e4d8310e4f23ec1c3c77e8725632bdbf4fb7dce65bde45731a656c294d1be22a3421d6132da5e8
+  metadata.gz: a43ce9d80d6f3540b4cb62e52c616758d1fb322d43d418405e90bc2226ac30406663659171c2f87e43483d4d20118569777cf3b0ff04cf3f5d29ba278917fc6a
+  data.tar.gz: c8a6234d60d32123cd97cc7fd6abfe8f98cf183b43e627b079094806f84ff4a159772da5002d0f895dd88b56e32d12b88103546e1cd3de165c8441b408ee05d0

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [0.0.5] - 2025-05-03
+
+- Handle changes to CommandConnector interface
+
 ## [0.0.4] - 2025-04-14
 
 - Do not log requests/responses/errors by default

data/README.md

@@ -6,6 +6,8 @@ Exposes Foobara commands according to the Model Context Protocol (MCP) specifica
 * [Foobara::McpConnector](#foobaramcpconnector)
   * [Installation](#installation)
   * [Usage](#usage)
+    * [Code demo video!](#code-demo-video)
+    * [Code examples](#code-examples)
     * [Super basic example](#super-basic-example)
     * [An example with entities](#an-example-with-entities)
     * [A destructive example](#a-destructive-example)
@@ -21,6 +23,12 @@ Typical stuff: add `gem "foobara-mcp-connector` to your Gemfile or .gemspec file
 
 ## Usage
 
+### Code demo video!
+
+You can watch a code demo here: https://youtu.be/_w3ZHdiJEGU
+
+### Code examples
+
 You can find examples in `examples/`
 
 ### Super basic example

data/src/jsonrpc_request.rb

@@ -2,12 +2,29 @@ module Foobara
   class McpConnector < CommandConnector
     # Isolating jsonrpc specific logic to this abstract class
     class JsonrpcRequest < CommandConnector::Request
-      class InvalidJsonrpcVersionError < StandardError; end
-      class InvalidJsonrpcMethodError < StandardError; end
-      class InvalidJsonrpcParamsError < StandardError; end
-      class InvalidJsonrpcRequestStructureError < StandardError; end
-      class EmptyBatchError < StandardError; end
-      class InvalidJsonError < StandardError; end
+      class InvalidJsonrpcVersionError < Foobara::Error
+        context({})
+      end
+
+      class InvalidJsonrpcMethodError < Foobara::Error
+        context({})
+      end
+
+      class InvalidJsonrpcParamsError < Foobara::Error
+        context({})
+      end
+
+      class InvalidJsonrpcRequestStructureError < Foobara::Error
+        context({})
+      end
+
+      class EmptyBatchError < Foobara::Error
+        context({})
+      end
+
+      class InvalidJsonError < Foobara::Error
+        context({})
+      end
 
       # TODO: push response into base class?
       attr_accessor :raw_request_json, :parsed_request_body, :request_id, :batch, :is_batch_child
@@ -45,7 +62,9 @@ module Foobara
                                      begin
                                        JSON.parse(raw_request_json)
                                      rescue => e
-                                       self.error = InvalidJsonError.new("Could not parse request: #{e.message}")
+                                       self.error = InvalidJsonError.new(
+                                         message: "Could not parse request: #{e.message}"
+                                       )
                                        error.set_backtrace(caller)
                                        nil
                                      end
@@ -62,7 +81,9 @@ module Foobara
 
       def verify_jsonrpc_version
         if parsed_request_body["jsonrpc"] != "2.0"
-          self.error = InvalidJsonrpcVersionError.new("Unsupported jsonrpc version: #{parsed_request_body["jsonrpc"]}")
+          self.error = InvalidJsonrpcVersionError.new(
+            message: "Unsupported jsonrpc version: #{parsed_request_body["jsonrpc"]}"
+          )
           error.set_backtrace(caller)
         end
       end
@@ -93,7 +114,9 @@ module Foobara
 
       def validate_batch_not_empty
         if batch? && batch.empty?
-          self.error = EmptyBatchError.new("An empty array/batch is not allowed")
+          self.error = EmptyBatchError.new(
+            message: "An empty array/batch is not allowed"
+          )
           error.set_backtrace(caller)
         end
       end
@@ -101,7 +124,7 @@ module Foobara
       def validate_request_structure
         unless parsed_request_body.is_a?(::Hash)
           self.error = InvalidJsonrpcRequestStructureError.new(
-            "Invalid jsonrpc request structure. Expected a hash but got a #{parsed_request_body.class}"
+            message: "Invalid jsonrpc request structure. Expected a hash but got a #{parsed_request_body.class}"
           )
           error.set_backtrace(caller)
         end

data/src/mcp_connector.rb

@@ -40,33 +40,41 @@ module Foobara
       StdioRunner.new(self).run(io_in: io_in, io_out: io_out, io_err: io_err)
     end
 
-    def request_to_command(request)
-      action = request.action
-
+    def request_to_command_class(request)
       return if request.error?
 
-      case action
-      when "initialize"
-        command_class = find_builtin_command_class("Initialize")
-      when "notifications/initialized", "notifications/cancelled", "notifications/progress",
-        "notifications/roots/list_changed"
-        command_class = find_builtin_command_class("Noop")
-      else
-        return super
-      end
+      builtin_command_class_name = case request.action
+                                   when "initialize"
+                                     "Initialize"
+                                   when "notifications/initialized", "notifications/cancelled",
+                                        "notifications/progress", "notifications/roots/list_changed"
+                                     "Noop"
+                                   else
+                                     return super
+                                   end
 
-      full_command_name = command_class.full_command_name
-      inputs = (request.params || {}).merge(request:)
+      command_class = find_builtin_command_class(builtin_command_class_name)
 
-      transformed_command_class = transformed_command_from_name(full_command_name) ||
-                                  transform_command_class(command_class)
+      full_command_name = command_class.full_command_name
 
-      transformed_command_class.new(inputs)
+      transformed_command_from_name(full_command_name) || transform_command_class(command_class)
     rescue CommandConnector::NoCommandFoundError => e
       request.error = e
       nil
     end
 
+    def request_to_command_inputs(request)
+      return if request.error?
+
+      case request.action
+      when "initialize", "notifications/initialized", "notifications/cancelled", "notifications/progress",
+        "notifications/roots/list_changed"
+        (request.params || {}).merge(request:)
+      else
+        super
+      end
+    end
+
     # TODO: figure out how to support multiple sessions
     def session_created(session)
       self.current_session = session

data/src/request.rb

@@ -3,8 +3,15 @@ require_relative "jsonrpc_request"
 module Foobara
   class McpConnector < CommandConnector
     class Request < JsonrpcRequest
-      class FoobaraCommandsDoNotAcceptArraysError < StandardError; end
-      class MethodNotYetSupportedError < StandardError; end
+      class FoobaraCommandsDoNotAcceptArraysError < Foobara::Error
+        context({})
+      end
+
+      class MethodNotYetSupportedError < Foobara::Error
+        context({})
+      end
+
+      attr_accessor :action_loaded
 
       def full_command_name
         return if error || batch?
@@ -24,11 +31,11 @@ module Foobara
         unless inputs.is_a?(::Hash)
           self.error = if inputs.is_a?(::Array)
                          FoobaraCommandsDoNotAcceptArraysError.new(
-                           "Foobara commands do not accept arrays as inputs"
+                           message: "Foobara commands do not accept arrays as inputs"
                          )
                        else
                          InvalidJsonrpcParamsError.new(
-                           "Invalid MCP arguments structure. Expected a hash got a #{inputs.class}"
+                           message: "Invalid MCP arguments structure. Expected a hash got a #{inputs.class}"
                          )
                        end
 
@@ -46,7 +53,14 @@ module Foobara
         !error && super
       end
 
+      def error?
+        action unless action_loaded
+        super
+      end
+
       def action
+        self.action_loaded = true
+
         case method
         when "tools/call"
           "run"
@@ -58,9 +72,9 @@ module Foobara
           method
         when "completion/complete", "logging/setLevel", "prompts/get", "prompts/list",
           "resources/list", "resources/read", "resources/subscribe", "resources/unsubscribe"
-          raise MethodNotYetSupportedError, "#{method} not yet supported!"
+          raise MethodNotYetSupportedError.new(message: "#{method} not yet supported!")
         else
-          self.error = InvalidJsonrpcMethodError.new("Unknown method: #{method}")
+          self.error = InvalidJsonrpcMethodError.new(message: "Unknown method: #{method}")
           error.set_backtrace(caller)
           nil
         end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foobara-mcp-connector
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Miles Georgi
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foobara
@@ -78,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Gives an easy way to expose your Foobara commands to tools like Claude Code
   via the Model Context Protocol (MCP)