actionmcp 0.2.0 → 0.2.4

data/lib/action_mcp/registry_base.rb

@@ -1,55 +1,61 @@
 # 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, klass)
-        raise ArgumentError, "Name can't be blank" if name.blank?
-        raise ArgumentError, "Name '#{name}' is already registered." if items.key?(name)
-
-        items[name] = { klass: klass, enabled: true }
-      end
-
-      # Retrieve an item’s metadata by name.
+      # 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?
 
-        item[:klass]
+        item
       end
 
       # 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
-      end
-
-      def unregister(name)
-        items.delete(name)
+        items.size
       end
 
-      def clear!
-        items.clear
-      end
-
-      # Chainable scope: returns only enabled, non-abstract items.
-      def enabled
+      # Chainable scope: returns only non-abstract items.
+      #
+      # @return [RegistryScope] A RegistryScope instance.
+      def non_abstract
         RegistryScope.new(items)
       end
 
       private
 
       # Helper to determine if an item is abstract.
-      def abstract_item?(item)
-        klass = item[:klass]
+      #
+      # @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 item_klass
+        raise NotImplementedError, "Implement in subclass"
+      end
     end
 
     # Query object for chainable registry scopes.
@@ -59,22 +65,35 @@ module ActionMCP
       # Using a Data type for items.
       Item = Data.define(:name, :klass)
 
+      # Initializes a new RegistryScope instance.
+      #
+      # @param items [Hash] The items to scope.
+      # @return [void]
       def initialize(items)
-        @items = items.reject do |_name, item|
-          RegistryBase.send(:abstract_item?, item) || !item[:enabled]
-        end.map { |name, item| Item.new(name, item[:klass]) }
+        @items = items.reject do |_name, klass|
+          RegistryBase.send(:abstract_item?, klass)
+        end.map { |name, klass| Item.new(name, klass) }
       end
 
+      # Iterates over the items in the scope.
+      #
+      # @yield [Item] The item to yield.
+      # @return [void]
       def each(&)
         @items.each(&)
       end
 
-      # Returns the names (keys) of all enabled items.
+      # 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
 
       # 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

data/lib/action_mcp/renderable.rb

@@ -1,23 +1,49 @@
 # 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,

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,7 +15,6 @@ module ActionMCP
       hash
     end
 
-    # Convert the resource to a JSON string.
     def to_json(*)
       MultiJson.dump(to_h, *)
     end

data/lib/action_mcp/server.rb

@@ -1,7 +1,10 @@
-# frozen_string_literal: true
 
 # 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

@@ -1,7 +1,12 @@
 # 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

data/lib/action_mcp/tool.rb

@@ -5,49 +5,16 @@ module ActionMCP
   #
   # Provides a DSL for specifying metadata, properties, and nested collection schemas.
   # Tools are registered automatically in the ToolsRegistry unless marked as abstract.
-  class Tool
-    include ActiveModel::Model
-    include ActiveModel::Attributes
-    include Renderable
-
+  class Tool < Capability
     # --------------------------------------------------------------------------
     # Class Attributes for Tool Metadata and Schema
     # --------------------------------------------------------------------------
-    class_attribute :_tool_name, instance_accessor: false
-    class_attribute :_description, instance_accessor: false, default: ""
+    # @!attribute _schema_properties
+    #   @return [Hash] The schema properties of the tool.
+    # @!attribute _required_properties
+    #   @return [Array<String>] The required properties of the tool.
     class_attribute :_schema_properties, instance_accessor: false, default: {}
     class_attribute :_required_properties, instance_accessor: false, default: []
-    class_attribute :abstract_tool, instance_accessor: false, default: false
-
-    # --------------------------------------------------------------------------
-    # Subclass Registration
-    # --------------------------------------------------------------------------
-    # Automatically registers non-abstract subclasses in the ToolsRegistry.
-    #
-    # @param subclass [Class] the subclass inheriting from Tool.
-    def self.inherited(subclass)
-      super
-      return if subclass == Tool
-
-      subclass.abstract_tool = false
-      return if subclass.name == "ApplicationTool"
-
-      ToolsRegistry.register(subclass.tool_name, subclass)
-    end
-
-    # Marks this tool as abstract so that it won’t be available for use.
-    # If the tool is registered in ToolsRegistry, it is unregistered.
-    def self.abstract!
-      self.abstract_tool = true
-      ToolsRegistry.unregister(tool_name) if ToolsRegistry.items.key?(tool_name)
-    end
-
-    # Returns whether this tool is abstract.
-    #
-    # @return [Boolean] true if abstract, false otherwise.
-    def self.abstract?
-      abstract_tool
-    end
 
     # --------------------------------------------------------------------------
     # Tool Name and Description DSL
@@ -58,9 +25,9 @@ module ActionMCP
     # @return [String] The current tool name.
     def self.tool_name(name = nil)
       if name
-        self._tool_name = name
+        self._capability_name = name
       else
-        _tool_name || default_tool_name
+        _capability_name || default_tool_name
       end
     end
 
@@ -68,19 +35,11 @@ module ActionMCP
     #
     # @return [String] The default tool name.
     def self.default_tool_name
-      name.demodulize.underscore.dasherize.sub(/-tool$/, "")
+      name.demodulize.underscore.sub(/_tool$/, "")
     end
 
-    # Sets or retrieves the tool's description.
-    #
-    # @param text [String, nil] Optional. The description text to set.
-    # @return [String] The current description.
-    def self.description(text = nil)
-      if text
-        self._description = text
-      else
-        _description
-      end
+    class << self
+      alias default_capability_name default_tool_name
     end
 
     # --------------------------------------------------------------------------
@@ -97,6 +56,7 @@ module ActionMCP
     # @param required [Boolean] Whether the property is required (default: false).
     # @param default [Object, nil] The default value for the property.
     # @param opts [Hash] Additional options for the JSON Schema.
+    # @return [void]
     def self.property(prop_name, type: "string", description: nil, required: false, default: nil, **opts)
       # Build the JSON Schema definition.
       prop_definition = { type: type }
@@ -127,6 +87,7 @@ module ActionMCP
     # @param description [String, nil] Optional description for the collection.
     # @param required [Boolean] Whether the collection is required (default: false).
     # @param default [Array, nil] The default value for the collection.
+    # @return [void]
     def self.collection(prop_name, type:, description: nil, required: false, default: [])
       raise ArgumentError, "Type is required for a collection" if type.nil?
 
@@ -166,6 +127,7 @@ module ActionMCP
     # Subclasses must implement this method.
     #
     # @raise [NotImplementedError] Always raised if not implemented in a subclass.
+    # @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)
@@ -184,13 +146,14 @@ module ActionMCP
     # @return [Symbol] The corresponding ActiveModel attribute type.
     def self.map_json_type_to_active_model_type(type)
       case type.to_s
-      when "number" then  :float # JSON Schema "number" is a float in Ruby, the spec doesn't have an integer type yet.
+      when "number" then :float # JSON Schema "number" is a float in Ruby, the spec doesn't have an integer type yet.
       when "array_number" then :integer_array
       when "array_integer" then :string_array
       when "array_string" then :string_array
-      else                :string
+      else :string
       end
     end
+
     private_class_method :map_json_type_to_active_model_type
   end
 end

data/lib/action_mcp/tools_registry.rb

@@ -1,11 +1,20 @@
 # frozen_string_literal: true
 
 module ActionMCP
+  # Registry for managing tools.
   class ToolsRegistry < RegistryBase
     class << self
+      # @!method tools
+      #   Returns all registered tools.
+      #   @return [Hash] A hash of registered tools.
       alias tools items
-      alias available_tools enabled
 
+      # Calls a tool with the given name and arguments.
+      #
+      # @param tool_name [String] The name of the tool to call.
+      # @param arguments [Hash] The arguments to pass to the tool.
+      # @param _metadata [Hash] Optional metadata.
+      # @return [Hash] A hash containing the tool's response.
       def tool_call(tool_name, arguments, _metadata = {})
         tool = find(tool_name)
         tool = tool.new(arguments)
@@ -19,6 +28,10 @@ module ActionMCP
           }
         end
       end
+
+      def item_klass
+        Tool
+      end
     end
   end
 end

data/lib/action_mcp/transport/capabilities.rb

@@ -0,0 +1,21 @@
+module ActionMCP
+  module Transport
+    module Capabilities
+      def send_capabilities(request_id, params = {})
+        @protocol_version = params["protocolVersion"]
+        @client_info = params["clientInfo"]
+        @client_capabilities = params["capabilities"]
+        capabilities = ActionMCP.configuration.capabilities
+
+        payload = {
+          protocolVersion: PROTOCOL_VERSION,
+          serverInfo: {
+            name: ActionMCP.configuration.name,
+            version: ActionMCP.configuration.version
+          }
+        }.merge(capabilities)
+        send_jsonrpc_response(request_id, result: payload)
+      end
+    end
+  end
+end

data/lib/action_mcp/transport/messaging.rb

@@ -0,0 +1,20 @@
+module ActionMCP
+  module Transport
+    module Messaging
+      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
+
+      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
+
+      def send_jsonrpc_notification(method, params = nil)
+        notification = JsonRpc::Notification.new(method: method, params: params)
+        write_message(notification.to_json)
+      end
+    end
+  end
+end

data/lib/action_mcp/transport/prompts.rb

@@ -0,0 +1,19 @@
+module ActionMCP
+  module Transport
+    module Prompts
+      def send_prompts_list(request_id)
+        prompts = format_registry_items(PromptsRegistry.non_abstract)
+        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
+    end
+  end
+end