actionmcp 0.1.2 → 0.2.3

data/lib/action_mcp/transport/stdio_client.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "open3"
+module ActionMCP
+  module Transport
+    class StdioClient < TransportBase
+      attr_reader :received_server_message
+
+      def initialize(command, **options)
+        super(**options)
+        @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(command)
+        @threads_started = false
+        @received_server_message = false
+        @capabilities_sent = false
+      end
+
+      def start
+        start_output_threads
+
+        # Just log that connection is established but don't send capabilities yet
+        if @threads_started && @wait_thr.alive?
+          log_info("STDIO connection established")
+        else
+          log_error("Failed to start STDIO threads or process is not alive")
+        end
+      end
+
+      def send_message(json)
+        log_debug("\e[34m--> #{json}\e[0m")
+        @stdin.puts("#{json}\n\n")
+      end
+
+      def stop
+        cleanup_resources
+      end
+
+      def ready?
+        true
+      end
+
+      # Check if we've received any message from the server
+      def received_server_message?
+        @received_server_message
+      end
+
+      # Mark the client as ready and send initial capabilities if not already sent
+      def mark_ready_and_send_capabilities
+        unless @received_server_message
+          @received_server_message = true
+          log_info("Received first server message")
+
+          # Send initial capabilities if not already sent
+          unless @capabilities_sent
+            log_info("Server is ready, sending initial capabilities...")
+            send_initial_capabilities
+            @capabilities_sent = true
+          end
+        end
+      end
+
+      private
+
+      def start_output_threads
+        @stdout_thread = Thread.new do
+          @stdout.each_line do |line|
+            line = line.chomp
+            # Mark ready and send capabilities when we get any stdout
+            mark_ready_and_send_capabilities
+
+            # Continue with normal message handling
+            handle_raw_message(line)
+          end
+        end
+
+        @stderr_thread = Thread.new do
+          @stderr.each_line do |line|
+            line = line.chomp
+            log_info(line)
+
+            # Check stderr for server messages
+            if line.include?("MCP Server") || line.include?("running on stdio")
+              mark_ready_and_send_capabilities
+            end
+          end
+        end
+
+        @threads_started = true
+      end
+
+      def cleanup_resources
+        @stdin.close
+        wait_for_server_exit
+        cleanup_threads
+      end
+
+      def wait_for_server_exit
+        @wait_thr.join(0.5)
+        kill_server if @wait_thr.alive?
+      end
+
+      def kill_server
+        Process.kill("TERM", @wait_thr.pid)
+      rescue StandardError => e
+        log_error("Failed to kill server process: #{e}")
+      end
+
+      def cleanup_threads
+        @stdout_thread&.kill
+        @stderr_thread&.kill
+      end
+
+      def user_agent
+        "ActionMCP-stdio-client"
+      end
+    end
+  end
+end

data/lib/action_mcp/transport/tools.rb

@@ -0,0 +1,20 @@
+module ActionMCP
+  module Transport
+    module Tools
+      def send_tools_list(request_id)
+        tools = format_registry_items(ToolsRegistry.non_abstract)
+        send_jsonrpc_response(request_id, result: { tools: tools })
+      end
+
+      def send_tools_call(request_id, tool_name, arguments, _meta = {})
+        result = ToolsRegistry.tool_call(tool_name, arguments, _meta)
+        send_jsonrpc_response(request_id, result: 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
+    end
+  end
+end

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,241 +1,4 @@
-# frozen_string_literal: true
-
 module ActionMCP
-  class Transport
-    HEARTBEAT_INTERVAL = 15 # seconds
-
-    def initialize(output_io)
-      # output_io can be any IO-like object where we write events.
-      @output = output_io
-      @output.sync = true
-    end
-
-    # Sends the capabilities JSON-RPC notification.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    def send_capabilities(request_id)
-      capabilities = {}
-
-      # Only include each capability if the corresponding registry is non-empty.
-      capabilities[:tools] = { listChanged: true } if ActionMCP::ToolsRegistry.available_tools.any?
-
-      capabilities[:prompts] = { listChanged: true } if ActionMCP::PromptsRegistry.available_prompts.any?
-
-      capabilities[:resources] = { listChanged: true } if ActionMCP::ResourcesBank.all_resources.any?
-
-      # Add logging capability only if enabled by configuration.
-      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
-
-    # 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(ActionMCP::ToolsRegistry.available_tools)
-      send_jsonrpc_response(request_id, result: { tools: tools })
-    end
-
-    # Sends the resources list JSON-RPC response.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    def send_resources_list(request_id)
-      resources = ActionMCP::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 = 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 = ActionMCP::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 = 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 = 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 = ActionMCP::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 = 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 = JsonRpcError.new(
-          :internal_error,
-          message: "Failed to read resource: #{e.message}"
-        ).as_json
-        send_jsonrpc_response(request_id, error: error_obj)
-      end
-    end
-
-    # Sends a call to a tool. Currently logs the call details.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    # @param tool_name [String] The name of the tool.
-    # @param params [Hash] The parameters for the tool.
-    def send_tools_call(request_id, tool_name, params)
-      ActionMCP::ToolsRegistry.fetch_available_tool(tool_name.to_s)
-      Rails.logger.info("Sending tool call: #{tool_name} with params: #{params}")
-      # TODO: Implement tool call handling and response if needed.
-    rescue StandardError => e
-      Rails.logger.error("tools/call: Failed to call tool #{tool_name} - #{e.message}")
-      error_obj = JsonRpcError.new(
-        :internal_error,
-        message: "Failed to call tool #{tool_name}: #{e.message}"
-      ).as_json
-      send_jsonrpc_response(request_id, error: error_obj)
-    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(ActionMCP::PromptsRegistry.available_prompts)
-      send_jsonrpc_response(request_id, result: { prompts: prompts })
-    rescue StandardError => e
-      Rails.logger.error("prompts/list failed: #{e.message}")
-      error_obj = JsonRpcError.new(
-        :internal_error,
-        message: "Failed to list prompts: #{e.message}"
-      ).as_json
-      send_jsonrpc_response(request_id, error: error_obj)
-    end
-
-    def send_prompts_get(request_id, params)
-      prompt_name = params&.fetch("name", nil)
-      if prompt_name.nil? || prompt_name.strip.empty?
-        Rails.logger.error("prompts/get: 'name' parameter is missing")
-        error_obj = JsonRpcError.new(
-          :invalid_params,
-          message: "Missing 'name' parameter for prompts/get"
-        ).as_json
-        return send_jsonrpc_response(request_id, error: error_obj)
-      end
-
-      begin
-        # Assume a method similar to fetch_available_tool exists for prompts.
-        prompt = ActionMCP::PromptsRegistry.fetch_available_prompt(prompt_name.to_s)
-        if prompt.nil?
-          Rails.logger.error("prompts/get: Prompt not found for name #{prompt_name}")
-          error_obj = JsonRpcError.new(
-            :invalid_params,
-            message: "Prompt not found: #{prompt_name}"
-          ).as_json
-          return send_jsonrpc_response(request_id, error: error_obj)
-        end
-
-        result_data = { "prompt" => prompt.to_h }
-        send_jsonrpc_response(request_id, result: result_data)
-        Rails.logger.info("prompts/get: Returned prompt #{prompt_name}")
-      rescue StandardError => e
-        Rails.logger.error("prompts/get: Error retrieving prompt #{prompt_name} - #{e.message}")
-        error_obj = JsonRpcError.new(
-          :internal_error,
-          message: "Failed to get prompt: #{e.message}"
-        ).as_json
-        send_jsonrpc_response(request_id, error: error_obj)
-      end
-    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
-
-    # 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 = {})
-      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[:class].to_h }
-    end
-
-    # Writes a message to the output IO.
-    #
-    # @param data [String] The data to write.
-    def write_message(data)
-      Rails.logger.debug("Response Sent: #{data}")
-      @output.write("#{data}\n")
-    rescue IOError => e
-      Rails.logger.error("Failed to write message: #{e.message}")
-    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.1.2"
-  # 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,52 +2,65 @@
 
 require "rails"
 require "active_support"
-require "active_model"
-require "action_mcp/version"
-require "action_mcp/railtie" if defined?(Rails)
+require "active_support/rails"
+require "multi_json"
+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
-  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
+
+  ActiveModel::Type.register(:string_array, StringArray)
+  ActiveModel::Type.register(:integer_array, IntegerArray)
 end

data/lib/generators/action_mcp/install/install_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionMCP
   module Generators
     class InstallGenerator < Rails::Generators::Base

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