actionmcp 0.1.2 → 0.2.3

data/lib/action_mcp/json_rpc/response.rb

@@ -2,51 +2,62 @@
 
 module ActionMCP
   module JsonRpc
+    # Represents a JSON-RPC response.
     Response = Data.define(:id, :result, :error) do
+      # Initializes a new Response.
+      #
+      # @param id [String, Numeric] The request identifier.
+      # @param result [Object, nil] The result data (optional).
+      # @param error [Object, nil] The error data (optional).
+      # @raise [ArgumentError] if neither result nor error is provided, or if both are provided.
       def initialize(id:, result: nil, error: nil)
-        processed_error = process_error(error)
-        processed_result = error ? nil : result
-        validate_result_error!(processed_result, processed_error)
-        super(id: id, result: processed_result, error: processed_error)
+        validate_presence_of_result_or_error!(result, error)
+        validate_absence_of_both_result_and_error!(result, error)
+        result, error = transform_value_to_hash!(result, error)
+
+        super(id: id, result: result, error: error)
       end
 
+      # Returns a hash representation of the response.
+      #
+      # @return [Hash] The hash representation.
       def to_h
-        hash = {
+        {
           jsonrpc: "2.0",
-          id: id
-        }
-        if error
-          hash[:error] = {
-            code: error[:code],
-            message: error[:message]
-          }
-          hash[:error][:data] = error[:data] if error[:data]
-        else
-          hash[:result] = result
-        end
-        hash
+          id: id,
+          result: result,
+          error: error
+        }.compact
+      end
+
+      def is_error?
+        error.present?
       end
 
       private
 
-      def process_error(error)
-        case error
-        when Symbol
-          ErrorCodes[error]
-        when Hash
-          validate_error!(error)
-          error
-        end
+      # Validates that either result or error is present.
+      #
+      # @param result [Object, nil] The result data.
+      # @param error [Object, nil] The error data.
+      # @raise [ArgumentError] if neither result nor error is provided.
+      def validate_presence_of_result_or_error!(result, error)
+        raise ArgumentError, "Either result or error must be provided." if result.nil? && error.nil?
       end
 
-      def validate_error!(error)
-        raise Error, "Error code must be an integer" unless error[:code].is_a?(Integer)
-        raise Error, "Error message is required" unless error[:message].is_a?(String)
+      # Validates that both result and error are not present simultaneously.
+      #
+      # @param result [Object, nil] The result data.
+      # @param error [Object, nil] The error data.
+      # @raise [ArgumentError] if both result and error are provided.
+      def validate_absence_of_both_result_and_error!(result, error)
+        raise ArgumentError, "Both result and error cannot be provided simultaneously." if result && error
       end
 
-      def validate_result_error!(result, error)
-        raise Error, "Either result or error must be set" unless result || error
-        raise Error, "Cannot set both result and error" if result && error
+      def transform_value_to_hash!(result, error)
+        result = result.is_a?(String) ? (MultiJson.load(result) rescue result) : result
+        error = error.is_a?(String) ? (MultiJson.load(error) rescue error) : error
+        [ result, error ]
       end
     end
   end

data/lib/action_mcp/json_rpc.rb

@@ -1,13 +1,7 @@
 # frozen_string_literal: true
 
 module ActionMCP
+  # Module for handling JSON-RPC communication.
   module JsonRpc
-    extend ActiveSupport::Autoload
-
-    autoload :Base
-    autoload :JsonRpcError
-    autoload :Notification
-    autoload :Request
-    autoload :Response
   end
 end

data/lib/action_mcp/json_rpc_handler.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  class JsonRpcHandler
+    attr_reader :transport
+
+    def initialize(transport)
+      @transport = transport
+    end
+
+    # Process a single line of input.
+    def call(line)
+      request = if line.is_a?(String)
+                  line.strip!
+                  return if line.empty?
+                  begin
+                    MultiJson.load(line)
+                  rescue MultiJson::ParseError => e
+                    Rails.logger.error("Failed to parse JSON: #{e.message}")
+                    return
+                  end
+
+      else
+                  line
+      end
+      process_request(request)
+    end
+
+    private
+
+    def process_request(request)
+       unless request["jsonrpc"] == "2.0"
+         puts "Invalid request: #{request}"
+         return
+       end
+      method = request["method"]
+      id = request["id"]
+      params = request["params"]
+
+      case method
+      when "initialize"
+        puts "\e[31mSending capabilities\e[0m"
+        transport.send_capabilities(id, params)
+      when "ping"
+        transport.send_pong(id)
+      when /^notifications\//
+        puts "\e[31mProcessing notifications\e[0m"
+        process_notifications(method, id, params)
+      when /^prompts\//
+        process_prompts(method, id, params)
+      when /^resources\//
+        process_resources(method, id, params)
+      when /^tools\//
+        process_tools(method, id, params)
+      else
+        puts "\e[31mUnknown method: #{method}\e[0m"
+        Rails.logger.warn("Unknown method: #{method}")
+      end
+    end
+
+    def process_notifications(method, _id, _params)
+      case method
+      when "notifications/initialized"
+        puts "\e[31mInitialized\e[0m"
+        transport.initialized!
+      else
+        Rails.logger.warn("Unknown notifications method: #{method}")
+      end
+    end
+
+    def process_prompts(method, id, params)
+      case method
+      when "prompts/get"
+        transport.send_prompts_get(id, params&.dig("name"), params&.dig("arguments"))
+      when "prompts/list"
+        transport.send_prompts_list(id)
+      else
+        Rails.logger.warn("Unknown prompts method: #{method}")
+      end
+    end
+
+    def process_resources(method, id, params)
+      case method
+      when "resources/list"
+        transport.send_resources_list(id)
+      when "resources/templates/list"
+        transport.send_resource_templates_list(id)
+      when "resources/read"
+        transport.send_resource_read(id, params)
+      else
+        Rails.logger.warn("Unknown resources method: #{method}")
+      end
+    end
+
+    def process_tools(method, id, params)
+      case method
+      when "tools/list"
+        transport.send_tools_list(id)
+      when "tools/call"
+        transport.send_tools_call(id, params&.dig("name"), params&.dig("arguments"))
+      else
+        Rails.logger.warn("Unknown tools method: #{method}")
+      end
+    end
+  end
+end

data/lib/action_mcp/logging.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_support/tagged_logging"
+require "active_support/logger"
+require "logger"
+
+module ActionMCP
+  # Module for providing logging functionality to ActionMCP transport.
+  module Logging
+    extend ActiveSupport::Concern
+
+    # Included hook to configure the logger.
+    included do
+      logger_instance = ActiveSupport::Logger.new(STDOUT)
+      logger_instance.level = Logger.const_get(ActionMCP.configuration.logging_level.to_s.upcase)
+      cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(logger_instance)
+    end
+  end
+end

data/lib/action_mcp/prompt.rb

@@ -2,65 +2,44 @@
 
 module ActionMCP
   # Abstract base class for Prompts
-  # Defines: name, description, arguments, plus auto-registration.
-  class Prompt
-    include ActiveModel::Model
-    include ActiveModel::Attributes
-
-    class_attribute :_prompt_name, instance_accessor: false
-    class_attribute :_description, instance_accessor: false, default: ""
+  class Prompt < Capability
     class_attribute :_argument_definitions, instance_accessor: false, default: []
-    class_attribute :abstract_prompt, instance_accessor: false, default: false
-
-    def self.inherited(subclass)
-      super
-      return if subclass == Prompt
-      return if subclass.name == "ApplicationPrompt"
-
-      subclass.abstract_prompt = false
-
-      # Automatically register the subclass with the PromptsRegistry
-      PromptsRegistry.register(subclass.prompt_name, subclass)
-    end
-
-    def self.abstract!
-      self.abstract_prompt = true
-      # If already registered, you might want to unregister it here.
-    end
-
-    def self.abstract?
-      abstract_prompt
-    end
 
     # ---------------------------------------------------
     # Prompt Name
     # ---------------------------------------------------
+    # Gets or sets the prompt name.
+    #
+    # @param name [String, nil] The prompt name to set.
+    # @return [String] The prompt name.
     def self.prompt_name(name = nil)
       if name
-        self._prompt_name = name
+        self._capability_name = name
       else
-        _prompt_name || default_prompt_name
+        _capability_name || default_prompt_name
       end
     end
 
+    # Returns the default prompt name based on the class name.
+    #
+    # @return [String] The default prompt name.
     def self.default_prompt_name
-      name.demodulize.underscore.dasherize.sub(/-prompt$/, "")
+      name.demodulize.underscore.sub(/_prompt$/, "")
     end
-
-    # ---------------------------------------------------
-    # Description
-    # ---------------------------------------------------
-    def self.description(text = nil)
-      if text
-        self._description = text
-      else
-        _description
-      end
+    class << self
+    alias default_capability_name default_prompt_name
     end
 
     # ---------------------------------------------------
     # Argument DSL
     # ---------------------------------------------------
+    # Defines an argument for the prompt.
+    #
+    # @param arg_name [Symbol] The name of the argument.
+    # @param description [String] The description of the argument.
+    # @param required [Boolean] Whether the argument is required.
+    # @param default [Object] The default value of the argument.
+    # @return [void]
     def self.argument(arg_name, description: "", required: false, default: nil)
       arg_def = {
         name: arg_name.to_s,
@@ -72,8 +51,14 @@ module ActionMCP
 
       # Register the attribute so it's recognized by ActiveModel
       attribute arg_name, :string, default: default
+      return unless required
+
+      validates arg_name, presence: true
     end
 
+    # Returns the list of argument definitions.
+    #
+    # @return [Array<Hash>] The list of argument definitions.
     def self.arguments
       _argument_definitions
     end
@@ -81,6 +66,7 @@ module ActionMCP
     # ---------------------------------------------------
     # Convert prompt definition to Hash
     # ---------------------------------------------------
+    # @return [Hash] The prompt definition as a Hash.
     def self.to_h
       {
         name: prompt_name,
@@ -102,6 +88,8 @@ module ActionMCP
     # Raises:
     #   ActionMCP::JsonRpc::JsonRpcError(:invalid_params) if validation fails.
     #
+    # @param params [Hash] The parameters for the prompt.
+    # @return [Object] The result of the prompt's call method.
     def self.call(params)
       prompt = new(params) # Initialize an instance with provided params
       unless prompt.valid?
@@ -127,14 +115,14 @@ module ActionMCP
     #
     # Usage: Called internally after validation in self.call
     #
+    # @raise [NotImplementedError] Subclasses must implement the call method.
+    # @return [Array<Content>] Array of Content objects is expected as return value
     def call
       raise NotImplementedError, "Subclasses must implement the call method"
       # Default implementation (no-op)
       # In a real subclass, you might do:
-      #   def call
-      #     # Perform logic, e.g. analyze code, etc.
-      #     # Return something meaningful.
-      #   end
+      #  # Perform logic, e.g. analyze code, etc.
+      #  # Return something meaningful.
     end
   end
 end

data/lib/action_mcp/prompts_registry.rb

@@ -1,10 +1,41 @@
 # frozen_string_literal: true
 
 module ActionMCP
+  # Registry for managing prompts.
   class PromptsRegistry < RegistryBase
     class << self
+      # @!method prompts
+      #   Returns all registered prompts.
+      #   @return [Hash] A hash of registered prompts.
       alias prompts items
-      alias available_prompts enabled
+
+      # Calls a prompt with the given name and arguments.
+      #
+      # @param prompt_name [String] The name of the prompt to call.
+      # @param arguments [Hash] The arguments to pass to the prompt.
+      # @return [Hash] A hash containing the prompt's response.
+      def prompt_call(prompt_name, arguments)
+        prompt = find(prompt_name)
+        prompt = prompt.new(arguments)
+        prompt.valid?
+        if prompt.valid?
+          {
+            messages: [ {
+              role: "user",
+              content: prompt.call
+            } ]
+          }
+        else
+          {
+            content: prompt.errors.full_messages.map { |msg| Content::Text.new(msg) },
+            isError: true
+          }
+        end
+      end
+
+      def item_klass
+        Prompt
+      end
     end
   end
 end

data/lib/action_mcp/registry_base.rb

@@ -1,70 +1,102 @@
 # frozen_string_literal: true
 
 module ActionMCP
+  # Base class for registries.
   class RegistryBase
+    # Error raised when an item is not found in the registry.
+    class NotFound < StandardError; end
+
     class << self
+      # Returns all registered items.
+      #
+      # @return [Hash] A hash of registered items.
       def items
-        @items ||= {}
+        @items = item_klass.descendants.each_with_object({}) do |klass, hash|
+          next if klass.abstract?
+          hash[klass.capability_name] = klass
+        end
       end
 
-      # Register an item by unique name
-      def register(name, item_class)
-        raise ArgumentError, "Name can't be blank" if name.blank?
-        raise ArgumentError, "Name '#{name}' is already registered." if items.key?(name)
-
-        items[name] = { class: item_class, enabled: true }
-      end
+      # Retrieve an item by name.
+      #
+      # @param name [String] The name of the item to find.
+      # @raise [NotFound] if the item is not found.
+      # @return [Class] The class of the item.
+      def find(name)
+        item = items[name]
+        raise NotFound, "Item '#{name}' not found." if item.nil?
 
-      # Fetch an item’s metadata
-      # Returns { class: <Class>, enabled: <Boolean> } or nil
-      def fetch(name)
-        items[name]
+        item
       end
 
-      # Number of registered items, ignoring abstract ones.
+      # Return the number of registered items, ignoring abstract ones.
+      #
+      # @return [Integer] The number of registered items.
       def size
-        items.values.reject { |item| abstract_item?(item) }.size
+        items.size
       end
 
-      def unregister(name)
-        items.delete(name)
+      # Chainable scope: returns only non-abstract items.
+      #
+      # @return [RegistryScope] A RegistryScope instance.
+      def non_abstract
+        RegistryScope.new(items)
       end
 
-      def clear!
-        items.clear
-      end
+      private
 
-      # List of currently available items, excluding abstract ones.
-      def enabled
-        items
-          .reject { |_name, item| item[:class].abstract? }
-          .select { |_name, item| item[:enabled] }
+      # Helper to determine if an item is abstract.
+      #
+      # @param klass [Class] The class to check.
+      # @return [Boolean] True if the class is abstract, false otherwise.
+      def abstract_item?(klass)
+        klass.respond_to?(:abstract?) && klass.abstract?
       end
 
-      def fetch_available_tool(name)
-        enabled[name]&.fetch(:class)
+      def item_klass
+        raise NotImplementedError, "Implement in subclass"
       end
+    end
 
-      # Enable an item by name
-      def enable(name)
-        raise ArgumentError, "Name '#{name}' not found." unless items.key?(name)
+    # Query object for chainable registry scopes.
+    class RegistryScope
+      include Enumerable
 
-        items[name][:enabled] = true
-      end
+      # Using a Data type for items.
+      Item = Data.define(:name, :klass)
 
-      # Disable an item by name
-      def disable(name)
-        raise ArgumentError, "Name '#{name}' not found." unless items.key?(name)
+      # Initializes a new RegistryScope instance.
+      #
+      # @param items [Hash] The items to scope.
+      # @return [void]
+      def initialize(items)
+        @items = items.reject do |_name, klass|
+          RegistryBase.send(:abstract_item?, klass)
+        end.map { |name, klass| Item.new(name, klass) }
+      end
 
-        items[name][:enabled] = false
+      # Iterates over the items in the scope.
+      #
+      # @yield [Item] The item to yield.
+      # @return [void]
+      def each(&)
+        @items.each(&)
       end
 
-      private
+      # Returns the names (keys) of all non-abstract items.
+      #
+      # @return [Array<String>] The names of all non-abstract items.
+      def keys
+        @items.map(&:name)
+      end
 
-      # Helper to determine if an item is abstract.
-      def abstract_item?(item)
-        klass = item[:class]
-        klass.respond_to?(:abstract?) && klass.abstract?
+      # Chainable finder for available tools by name.
+      #
+      # @param name [String] The name of the tool to find.
+      # @return [Class, nil] The class of the tool, or nil if not found.
+      def find_available_tool(name)
+        item = @items.find { |i| i.name == name }
+        item&.klass
       end
     end
   end

data/lib/action_mcp/renderable.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  # Module for rendering content.
+  module Renderable
+    # Renders text content.
+    #
+    # @param text [String] The text to render.
+    # @return [Content::Text] The rendered text content.
+    def render_text(text)
+      Content::Text.new(text)
+    end
+
+    # Renders audio content.
+    #
+    # @param data [String] The audio data.
+    # @param mime_type [String] The MIME type of the audio data.
+    # @return [Content::Audio] The rendered audio content.
+    def render_audio(data, mime_type)
+      Content::Audio.new(data, mime_type)
+    end
+
+    # Renders image content.
+    #
+    # @param data [String] The image data.
+    # @param mime_type [String] The MIME type of the image data.
+    # @return [Content::Image] The rendered image content.
+    def render_image(data, mime_type)
+      Content::Image.new(data, mime_type)
+    end
+
+    # Renders a resource.
+    #
+    # @param uri [String] The URI of the resource.
+    # @param mime_type [String] The MIME type of the resource.
+    # @param text [String, nil] The text associated with the resource.
+    # @param blob [String, nil] The blob associated with the resource.
+    # @return [Content::Resource] The rendered resource content.
+    def render_resource(uri, mime_type, text: nil, blob: nil)
+      Content::Resource.new(uri, mime_type, text: text, blob: blob)
+    end
+
+    # Renders an error.
+    #
+    # @param errors [Array<String>] The errors to render.
+    # @return [Hash] A hash containing the error information.
+    def render_error(errors)
+      {
+        isError: true,
+        content: errors.map { |error| render_text(error) }
+      }
+    end
+  end
+end

data/lib/action_mcp/resource.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
 module ActionMCP
+  # Represents a resource with its metadata.
   Resource = Data.define(:uri, :name, :description, :mime_type, :size) do
     # Convert the resource to a hash with the keys expected by MCP.
     # Note: The key for mime_type is converted to 'mimeType' as specified.
+    #
+    # @return [Hash] A hash representation of the resource.
     def to_h
       hash = { uri: uri, name: name }
       hash[:description] = description if description
@@ -12,9 +15,8 @@ module ActionMCP
       hash
     end
 
-    # Convert the resource to a JSON string.
-    def to_json(*args)
-      to_h.to_json(*args)
+    def to_json(*)
+      MultiJson.dump(to_h, *)
     end
   end
 end

data/lib/action_mcp/server.rb

@@ -0,0 +1,10 @@
+
+# TODO: move all server related code here before version 1.0.0
+module ActionMCP
+  # Module for server-related functionality.
+  module Server
+    module_function def server
+      @server ||= ActionCable::Server::Base.new
+    end
+  end
+end

data/lib/action_mcp/string_array.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  # Custom type for handling arrays of strings in ActiveModel.
+  class StringArray < ActiveModel::Type::Value
+    # Casts the given value to an array of strings.
+    #
+    # @param value [Object] The value to cast.
+    # @return [Array<String>] The array of strings.
+    def cast(value)
+      Array(value).map(&:to_s) # Ensure all elements are strings
+    end
+  end
+end