actionmcp 0.2.0 → 0.2.3

data/lib/action_mcp/transport/transport_base.rb

@@ -0,0 +1,125 @@
+module ActionMCP
+  module Transport
+    class TransportBase
+      attr_reader :logger, :client_capabilities, :server_capabilities
+
+      def initialize(logger: Logger.new(STDOUT))
+        @logger = logger
+        @on_message = nil
+        @on_error = nil
+        @client_capabilities = default_capabilities
+        @server_capabilities = nil
+        @initialize_request_id = SecureRandom.hex(6)
+        @initialization_sent = false
+      end
+
+      def on_message(&block)
+        @on_message = block
+      end
+
+      def on_error(&block)
+        @on_error = block
+      end
+
+      def send_initial_capabilities
+        return if @initialization_sent
+
+        log_info("Sending client capabilities: #{@client_capabilities}")
+
+        request = JsonRpc::Request.new(
+          id: @initialize_request_id,
+          method: "initialize",
+          params: {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: @client_capabilities,
+            clientInfo: {
+              name: user_agent,
+              version: ActionMCP.gem_version.to_s
+            }
+          }
+        )
+        @initialization_sent = true
+        send_message(request.to_json)
+      end
+
+      def handle_initialize_response(response)
+        unless @server_capabilities
+
+          if response.result
+            @server_capabilities = response.result["capabilities"]
+            send_initialized_notification
+          else
+            log_error("Server initialization failed: #{response.error}")
+          end
+        end
+      end
+
+      protected
+
+      def handle_raw_message(raw)
+        # Debug - log all raw messages
+        log_debug("\e[31m<-- #{raw}\e[0m")
+
+        begin
+          msg_hash = MultiJson.load(raw)
+          response = nil
+
+          if msg_hash.key?("jsonrpc")
+            if msg_hash.key?("id")
+              response = JsonRpc::Response.new(**msg_hash.slice("id", "result", "error").symbolize_keys)
+            else
+              response = JsonRpc::Notification.new(**msg_hash.slice("method", "params").symbolize_keys)
+            end
+          end
+          # Check if this is a response to our initialize request
+          if response && @initialize_request_id && response.id == @initialize_request_id
+            handle_initialize_response(response)
+          else
+            @on_message&.call(response) if response
+          end
+        rescue MultiJson::ParseError => e
+          log_error("JSON parse error: #{e} (raw: #{raw})")
+          @on_error&.call(e) if @on_error
+        rescue StandardError => e
+          log_error("Error handling message: #{e} (raw: #{raw})")
+          @on_error&.call(e) if @on_error
+        end
+      end
+
+      # Send the initialized notification to the server
+      def send_initialized_notification
+        notification = JsonRpc::Notification.new(
+          method: "initialized"
+        )
+
+        logger.info("Sent initialized notification to server")
+        send_message(notification)
+      end
+
+      def default_capabilities
+        {
+          # Base client capabilities
+          # roots: {}, # Remove from now.
+        }
+      end
+
+      def log_debug(message)
+        @logger.debug("[#{log_prefix}] #{message}")
+      end
+
+      def log_info(message)
+        @logger.info("[#{log_prefix}] #{message}")
+      end
+
+      def log_error(message)
+        @logger.error("[#{log_prefix}] #{message}")
+      end
+
+      private
+
+      def log_prefix
+        self.class.name.split("::").last
+      end
+    end
+  end
+end

data/lib/action_mcp/transport.rb

@@ -1,238 +1,4 @@
-# frozen_string_literal: true
-
 module ActionMCP
-  class Transport
-    HEARTBEAT_INTERVAL = 15 # seconds
-    attr_reader :initialized
-
-    # Initializes a new Transport.
-    #
-    # @param output_io [IO] An IO-like object where events will be written.
-    def initialize(output_io)
-      # output_io can be any IO-like object where we write events.
-      @output = output_io
-      @output.sync = true
-      @initialized = false
-      @client_capabilities = {}
-      @client_info = {}
-      @protocol_version = ""
-    end
-
-    # Sends the capabilities JSON-RPC notification.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    def send_capabilities(request_id, params = {})
-      @protocol_version = params["protocolVersion"]
-      @client_info = params["clientInfo"]
-      @client_capabilities = params["capabilities"]
-      Rails.logger.info("Client capabilities stored: #{@client_capabilities}")
-      capabilities = {}
-
-      # Only include each capability if the corresponding registry is non-empty.
-      capabilities[:tools] = { listChanged: ActionMCP.configuration.list_changed } if ToolsRegistry.available_tools.any?
-      if PromptsRegistry.available_prompts.any?
-        capabilities[:prompts] =
-          { listChanged: ActionMCP.configuration.list_changed }
-      end
-      capabilities[:resources] = { subscribe: ActionMCP.configuration.list_changed } if ResourcesBank.all_resources.any?
-      capabilities[:logging] = {} if ActionMCP.configuration.logging_enabled
-
-      payload = {
-        protocolVersion: "2024-11-05",
-        capabilities: capabilities,
-        serverInfo: {
-          name: ActionMCP.configuration.name,
-          version: ActionMCP.configuration.version
-        }
-      }
-      send_jsonrpc_response(request_id, result: payload)
-    end
-
-    def initialized!
-      @initialized = true
-      Rails.logger.info("Transport initialized.")
-    end
-
-    # Sends the resources list JSON-RPC response.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    def send_resources_list(request_id)
-      resources = ResourcesBank.all_resources # fetch all resources
-      result_data = { "resources" => resources }
-      send_jsonrpc_response(request_id, result: result_data)
-      Rails.logger.info("resources/list: Returned #{resources.size} resources.")
-    rescue StandardError => e
-      Rails.logger.error("resources/list failed: #{e.message}")
-      error_obj = JsonRpc::JsonRpcError.new(
-        :internal_error,
-        message: "Failed to list resources: #{e.message}"
-      ).as_json
-      send_jsonrpc_response(request_id, error: error_obj)
-    end
-
-    # Sends the resource templates list JSON-RPC response.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    def send_resource_templates_list(request_id)
-      templates = ResourcesBank.all_templates # get all resource templates
-      result_data = { "resourceTemplates" => templates }
-      send_jsonrpc_response(request_id, result: result_data)
-      Rails.logger.info("resources/templates/list: Returned #{templates.size} resource templates.")
-    rescue StandardError => e
-      Rails.logger.error("resources/templates/list failed: #{e.message}")
-      error_obj = JsonRpc::JsonRpcError.new(
-        :internal_error,
-        message: "Failed to list resource templates: #{e.message}"
-      ).as_json
-      send_jsonrpc_response(request_id, error: error_obj)
-    end
-
-    # Sends the resource read JSON-RPC response.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    # @param params [Hash] The parameters including the 'uri' for the resource.
-    def send_resource_read(request_id, params)
-      uri = params&.fetch("uri", nil)
-      if uri.nil? || uri.empty?
-        Rails.logger.error("resources/read: 'uri' parameter is missing")
-        error_obj = JsonRpc::JsonRpcError.new(
-          :invalid_params,
-          message: "Missing 'uri' parameter for resources/read"
-        ).as_json
-        return send_jsonrpc_response(request_id, error: error_obj)
-      end
-
-      begin
-        content = ResourcesBank.read(uri) # Expecting an instance of an ActionMCP::Content subclass
-        if content.nil?
-          Rails.logger.error("resources/read: Resource not found for URI #{uri}")
-          error_obj = JsonRpc::JsonRpcError.new(
-            :invalid_params,
-            message: "Resource not found: #{uri}"
-          ).as_json
-          return send_jsonrpc_response(request_id, error: error_obj)
-        end
-
-        # Use the content object's `to_h` to build the JSON-RPC result.
-        result_data = { "contents" => [ content.to_h ] }
-        send_jsonrpc_response(request_id, result: result_data)
-
-        log_msg = "resources/read: Successfully read content of #{uri}"
-        log_msg += " (#{content.text.size} bytes)" if content.respond_to?(:text) && content.text
-        Rails.logger.info(log_msg)
-      rescue StandardError => e
-        Rails.logger.error("resources/read: Error reading #{uri} - #{e.message}")
-        error_obj = JsonRpc::JsonRpcError.new(
-          :internal_error,
-          message: "Failed to read resource: #{e.message}"
-        ).as_json
-        send_jsonrpc_response(request_id, error: error_obj)
-      end
-    end
-
-    # Sends the tools list JSON-RPC notification.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    def send_tools_list(request_id)
-      tools = format_registry_items(ToolsRegistry.available_tools)
-      send_jsonrpc_response(request_id, result: { tools: tools })
-    end
-
-    # Sends a call to a tool.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    # @param tool_name [String] The name of the tool.
-    # @param arguments [Hash] The arguments for the tool.
-    # @param _meta [Hash] Additional metadata.
-    def send_tools_call(request_id, tool_name, arguments, _meta = {})
-      result = ToolsRegistry.tool_call(tool_name, arguments, _meta)
-      send_jsonrpc_response(request_id, result:)
-    rescue RegistryBase::NotFound
-      send_jsonrpc_response(request_id, error: JsonRpc::JsonRpcError.new(:method_not_found,
-                                                                         message: "Tool not found: #{tool_name}").as_json)
-    end
-
-    # Sends the prompts list JSON-RPC notification.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    def send_prompts_list(request_id)
-      prompts = format_registry_items(PromptsRegistry.available_prompts)
-      send_jsonrpc_response(request_id, result: { prompts: prompts })
-    end
-
-    def send_prompts_get(request_id, prompt_name, params)
-      send_jsonrpc_response(request_id, result: PromptsRegistry.prompt_call(prompt_name.to_s, params))
-    rescue RegistryBase::NotFound
-      send_jsonrpc_response(request_id, error: JsonRpc::JsonRpcError.new(:method_not_found,
-                                                                         message: "Prompt not found: #{prompt_name}").as_json)
-    end
-
-    # Sends the roots list JSON-RPC request.
-    # TODO: test it
-    def send_roots_list
-      send_jsonrpc_request("roots/list")
-    end
-
-    # Sends a JSON-RPC pong response.
-    # We don't actually to send any data back because the spec are not fun anymore.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    def send_pong(request_id)
-      send_jsonrpc_response(request_id, result: {})
-    end
-
-    def send_ping
-      send_jsonrpc_request("ping")
-    end
-
-    # Sends a JSON-RPC request.
-    # @param method [String] The JSON-RPC method.
-    # @param params [Hash] The parameters for the method.
-    # @param id [String] The request identifier.
-    def send_jsonrpc_request(method, params: nil, id: SecureRandom.uuid_v7)
-      request = JsonRpc::Request.new(id: id, method: method, params: params)
-      write_message(request.to_json)
-    end
-
-    # Sends a JSON-RPC response.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    # @param result [Object] The result data.
-    # @param error [Object, nil] The error data, if any.
-    def send_jsonrpc_response(request_id, result: nil, error: nil)
-      response = JsonRpc::Response.new(id: request_id, result: result, error: error)
-      write_message(response.to_json)
-    end
-
-    # Sends a generic JSON-RPC notification (no response expected).
-    #
-    # @param method [String] The JSON-RPC method.
-    # @param params [Hash] The parameters for the method.
-    def send_jsonrpc_notification(method, params = nil)
-      notification = JsonRpc::Notification.new(method: method, params: params)
-      write_message(notification.to_json)
-    end
-
-    private
-
-    # Formats registry items to a hash representation.
-    #
-    # @param registry [Hash] The registry containing tool or prompt definitions.
-    # @return [Array<Hash>] The formatted registry items.
-    def format_registry_items(registry)
-      registry.map { |item| item.klass.to_h }
-    end
-
-    # Writes a message to the output IO.
-    #
-    # @param data [String] The data to write.
-    def write_message(data)
-      Timeout.timeout(5) do # 5 second timeout
-        @output.write("#{data}\n")
-      end
-    rescue Timeout::Error
-      Rails.logger.error("Write operation timed out")
-      # Handle timeout appropriately
-    end
+  module Transport
   end
 end

data/lib/action_mcp/transport_handler.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  class TransportHandler
+    include Logging
+
+    include Transport::Capabilities
+    include Transport::Tools
+    include Transport::Prompts
+    include Transport::Messaging
+
+    HEARTBEAT_INTERVAL = 15 # seconds
+    attr_reader :initialized
+
+    def initialize(output_io)
+      @output = output_io
+      @output.sync = true if @output.respond_to?(:sync=)
+      @initialized = false
+      @client_capabilities = {}
+      @client_info = {}
+      @protocol_version = ""
+    end
+
+    def send_ping
+      send_jsonrpc_request("ping")
+    end
+
+    def send_pong(request_id)
+      send_jsonrpc_response(request_id, result: {})
+    end
+
+    def initialized?
+      @initialized
+    end
+
+    def initialized!
+      @initialized = true
+    end
+
+    private
+
+    def write_message(data)
+      Timeout.timeout(5) do
+        @output.write("#{data}\n")
+      end
+    rescue Timeout::Error
+      # ActionMCP.logger.error("Write operation timed out")
+    end
+
+    def format_registry_items(registry)
+      registry.map { |item| item.klass.to_h }
+    end
+  end
+end

data/lib/action_mcp/version.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "gem_version"
-
 module ActionMCP
-  VERSION = "0.2.0"
-  # Returns the currently loaded version of Active MCP as a +Gem::Version+.
-  def self.version
-    gem_version
+  VERSION = "0.2.3"
+
+  class << self
+    alias version gem_version
   end
 end

data/lib/action_mcp.rb

@@ -2,58 +2,61 @@
 
 require "rails"
 require "active_support"
-require "active_model"
-require "action_mcp/version"
+require "active_support/rails"
 require "multi_json"
-require "action_mcp/railtie" if defined?(Rails)
-require_relative "action_mcp/integer_array"
-require_relative "action_mcp/string_array"
+require "concurrent"
+require "active_record/railtie"
+require "action_controller/railtie"
+require "action_cable/engine"
+require "action_mcp/engine"
+require "zeitwerk"
 
-ActiveSupport::Inflector.inflections(:en) do |inflect|
-  inflect.acronym "MCP"
-end
-module ActionMCP
-  extend ActiveSupport::Autoload
-
-  autoload :RegistryBase
-  autoload :Resource
-  autoload :ToolsRegistry
-  autoload :PromptsRegistry
-  autoload :ResourcesBank
-  autoload :Tool
-  autoload :Prompt
-  autoload :JsonRpc
-  autoload :Transport
-  autoload :Content
-  autoload :Renderable
-
-  eager_autoload do
-    autoload :Configuration
-  end
+lib = File.dirname(__FILE__)
 
-  # Accessor for the configuration instance.
-  def self.configuration
-    @configuration ||= Configuration.new
-  end
+Zeitwerk::Loader.for_gem.tap do |loader|
+  loader.ignore(
+    "#{lib}/generators",
+    "#{lib}/action_mcp/version.rb",
+    "#{lib}/action_mcp/gem_version.rb",
+    "#{lib}/actionmcp.rb"
+  )
 
-  def self.configure
-    yield(configuration)
-  end
+  loader.inflector.inflect("action_mcp" => "ActionMCP")
+  loader.inflector.inflect("sse_client" => "SSEClient")
+  loader.inflector.inflect("sse_server" => "SSEServer")
+end.setup
+
+module ActionMCP
+  require_relative "action_mcp/version"
+  require_relative "action_mcp/configuration"
+  PROTOCOL_VERSION =  "2024-11-05"
 
   module_function
 
+  # Returns the tools registry.
+  #
+  # @return [Hash] the tools registry
   def tools
     ToolsRegistry.tools
   end
 
+  # Returns the prompts registry.
+  #
+  # @return [Hash] the prompts registry
   def prompts
     PromptsRegistry.prompts
   end
 
+  # Returns the available tools.
+  #
+  # @return [ActionMCP::RegistryBase::RegistryScope] the available tools
   def available_tools
     ToolsRegistry.available_tools
   end
 
+  # Returns the available prompts.
+  #
+  # @return [ActionMCP::RegistryBase::RegistryScope] the available prompts
   def available_prompts
     PromptsRegistry.available_prompts
   end

data/lib/generators/action_mcp/prompt/templates/prompt.rb.erb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+# Template for generating new prompts.
 class <%= class_name %> < ApplicationPrompt
+  # Set the prompt name.
   prompt_name "<%= prompt_name %>"
 
   # Provide a user-facing description for your prompt.
@@ -13,7 +15,7 @@ class <%= class_name %> < ApplicationPrompt
   # Add validations (note: "Ruby" is not allowed per the validation)
   validates :language, inclusion: { in: %w[Ruby C Cobol FORTRAN] }
 
+  # Implement your prompt's behavior here
   def call
-    # Implement your prompt's behavior here
   end
 end

data/lib/generators/action_mcp/tool/templates/tool.rb.erb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
+# Template for generating new tools.
 class <%= class_name %> < ApplicationTool
+  # Set the tool name.
   tool_name "<%= tool_name %>"
   description "Calculate the sum of two numbers"
 
+  # Define input properties.
   property :a, type: "number", description: "First number", required: true
   property :b, type: "number", description: "Second number", required: true
 
+  # Implement the tool's logic here.
   def call
-    a + b
+    render_text(a + b)
   end
 end

data/lib/tasks/action_mcp_tasks.rake

@@ -1,6 +1,29 @@
-# frozen_string_literal: true
+namespace :action_mcp do
+  desc "List all tools with their names and descriptions"
+  task list_tools: :environment do
+    # Ensure Rails eager loads all classes
+    Rails.application.eager_load!
 
-# desc "Explaining what the task does"
-# task :action_mcp do
-#   # Task goes here
-# end
+    puts "\e[34mACTION MCP TOOLS\e[0m"  # Blue
+    puts "\e[34m---------------\e[0m"   # Blue
+    ActionMCP::Tool.descendants.each do |tool|
+      puts "\e[34m#{tool.capability_name}:\e[0m #{tool.description}"  # Blue name
+    end
+  end
+
+  desc "List all prompts with their names and descriptions"
+  task list_prompts: :environment do
+    # Ensure Rails eager loads all classes
+    Rails.application.eager_load!
+
+    puts "\e[32mACTION MCP PROMPTS\e[0m"  # Red
+    puts "\e[32m-----------------\e[0m"   # Red
+    ActionMCP::Prompt.descendants.each do |prompt|
+      puts "\e[32m#{prompt.capability_name}:\e[0m #{prompt.description}"  # Red name
+    end
+  end
+
+  desc "List all tools and prompts with their names and descriptions"
+  task list: [ :list_tools, :list_prompts ] do
+  end
+end