actionmcp 0.55.2 → 0.60.1

data/lib/action_mcp/tool.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "action_mcp/types/float_array_type"
+
 module ActionMCP
   # Base class for defining tools.
   #
@@ -8,6 +10,7 @@ module ActionMCP
   class Tool < Capability
     include ActionMCP::Callbacks
     include ActionMCP::CurrentHelpers
+
     # --------------------------------------------------------------------------
     # Class Attributes for Tool Metadata and Schema
     # --------------------------------------------------------------------------
@@ -18,6 +21,8 @@ module ActionMCP
     class_attribute :_schema_properties, instance_accessor: false, default: {}
     class_attribute :_required_properties, instance_accessor: false, default: []
     class_attribute :_annotations, instance_accessor: false, default: {}
+    class_attribute :_output_schema, instance_accessor: false, default: nil
+    class_attribute :_meta, instance_accessor: false, default: {}
 
     # --------------------------------------------------------------------------
     # Tool Name and Description DSL
@@ -82,6 +87,47 @@ module ActionMCP
         # Always include annotations now that we only support 2025+
         _annotations
       end
+
+      # Class method to call the tool with arguments
+      def call(arguments = {})
+        new(arguments).call
+      end
+
+      # Helper methods for checking annotations
+      def read_only?
+        _annotations["readOnlyHint"] == true
+      end
+
+      def idempotent?
+        _annotations["idempotentHint"] == true
+      end
+
+      def destructive?
+        _annotations["destructiveHint"] == true
+      end
+
+      def open_world?
+        _annotations["openWorldHint"] == true
+      end
+
+      # Sets the output schema for structured content
+      def output_schema(schema = nil)
+        if schema
+          raise NotImplementedError, "Output schema DSL not yet implemented. Coming soon with structured content DSL!"
+        else
+          _output_schema
+        end
+      end
+
+      # Sets or retrieves the _meta field
+      def meta(data = nil)
+        if data
+          raise ArgumentError, "_meta must be a hash" unless data.is_a?(Hash)
+          self._meta = _meta.merge(data)
+        else
+          _meta
+        end
+      end
     end
 
     # --------------------------------------------------------------------------
@@ -133,16 +179,32 @@ module ActionMCP
     def self.collection(prop_name, type:, description: nil, required: false, default: [])
       raise ArgumentError, "Type is required for a collection" if type.nil?
 
-      collection_definition = { type: "array", description: description, items: { type: type } }
+      collection_definition = { type: "array", items: { type: type } }
+      collection_definition[:description] = description if description && !description.empty?
 
       self._schema_properties = _schema_properties.merge(prop_name.to_s => collection_definition)
       self._required_properties = _required_properties.dup.tap do |req|
         req << prop_name.to_s if required
       end
 
-      type = map_json_type_to_active_model_type("array_#{type}")
-      attribute prop_name, type, default: default
-      validates prop_name, presence: true, if: -> { required }
+      # Map the type - for number arrays, use our custom type instance
+      mapped_type = if type == "number"
+        Types::FloatArrayType.new
+      else
+        map_json_type_to_active_model_type("array_#{type}")
+      end
+
+      attribute prop_name, mapped_type, default: default
+
+      # For arrays, we need to check if the attribute is nil, not if it's empty
+      if required
+        validates prop_name, presence: true, unless: -> { self.send(prop_name).is_a?(Array) }
+        validate do
+          if self.send(prop_name).nil?
+            errors.add(prop_name, "can't be blank")
+          end
+        end
+      end
     end
 
     # --------------------------------------------------------------------------
@@ -152,7 +214,10 @@ module ActionMCP
     #
     # @return [Hash] The tool definition.
     def self.to_h(protocol_version: nil)
-      schema = { type: "object", properties: _schema_properties }
+      schema = {
+        type: "object",
+        properties: _schema_properties
+      }
       schema[:required] = _required_properties if _required_properties.any?
 
       result = {
@@ -161,10 +226,16 @@ module ActionMCP
         inputSchema: schema
       }.compact
 
+      # Add output schema if defined
+      result[:outputSchema] = _output_schema if _output_schema.present?
+
       # Add annotations if protocol supports them
       annotations = annotations_for_protocol(protocol_version)
       result[:annotations] = annotations if annotations.any?
 
+      # Add _meta if present
+      result[:_meta] = _meta if _meta.any?
+
       result
     end
 
@@ -223,6 +294,13 @@ module ActionMCP
       content # Return the content for potential use in perform
     end
 
+    # Override render_resource_link to collect ResourceLink objects
+    def render_resource_link(**args)
+      content = super(**args) # Call Renderable's render_resource_link method
+      @response.add(content)  # Add to the response
+      content # Return the content for potential use in perform
+    end
+
     protected
 
     # Abstract method for subclasses to implement their logic
@@ -239,6 +317,22 @@ module ActionMCP
       render text: message
     end
 
+    # Helper method to set structured content
+    def set_structured_content(content)
+      return unless @response
+
+      # Validate against output schema if defined
+      if self.class._output_schema
+        # TODO: Add JSON Schema validation here
+        # For now, just ensure it's a hash/object
+        unless content.is_a?(Hash)
+          raise ArgumentError, "Structured content must be a hash/object when output_schema is defined"
+        end
+      end
+
+      @response.set_structured_content(content)
+    end
+
     # Maps a JSON Schema type to an ActiveModel attribute type.
     #
     # @param type [String] The JSON Schema type.
@@ -246,8 +340,8 @@ module ActionMCP
     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 "array_number" then :integer_array
-      when "array_integer" then :string_array
+      when "array_number" then :float_array
+      when "array_integer" then :integer_array
       when "array_string" then :string_array
       else :string
       end

data/lib/action_mcp/tool_response.rb

@@ -3,13 +3,14 @@
 module ActionMCP
   # Manages the collection of content objects for tool results
   class ToolResponse < BaseResponse
-    attr_reader :contents
+    attr_reader :contents, :structured_content
 
     delegate :empty?, :size, :each, :find, :map, to: :contents
 
     def initialize
       super
       @contents = []
+      @structured_content = nil
     end
 
     # Add content to the response
@@ -18,26 +19,36 @@ module ActionMCP
       content # Return the content for chaining
     end
 
+    # Set structured content for the response
+    def set_structured_content(content)
+      @structured_content = content
+    end
+
     # Implementation of build_success_hash for ToolResponse
     def build_success_hash
-      {
+      result = {
         content: @contents.map(&:to_h)
       }
+      result[:structuredContent] = @structured_content if @structured_content
+      result
     end
 
     # Implementation of compare_with_same_class for ToolResponse
     def compare_with_same_class(other)
-      contents == other.contents && is_error == other.is_error
+      contents == other.contents && is_error == other.is_error && structured_content == other.structured_content
     end
 
     # Implementation of hash_components for ToolResponse
     def hash_components
-      [ contents, is_error ]
+      [ contents, is_error, structured_content ]
     end
 
     # Pretty print for better debugging
     def inspect
-      "#<#{self.class.name} content: #{contents.inspect}, isError: #{is_error}>"
+      parts = [ "content: #{contents.inspect}" ]
+      parts << "structuredContent: #{structured_content.inspect}" if structured_content
+      parts << "isError: #{is_error}"
+      "#<#{self.class.name} #{parts.join(', ')}>"
     end
   end
 end

data/lib/action_mcp/types/float_array_type.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Types
+    # Custom ActiveModel type for handling arrays of floating point numbers
+    class FloatArrayType < ActiveModel::Type::Value
+      def type
+        :float_array
+      end
+
+      def cast(value)
+        return [] if value.nil?
+        return value if value.is_a?(Array) && value.all? { |v| v.is_a?(Float) }
+
+        Array(value).map do |v|
+          case v
+          when Float then v
+          when Numeric then v.to_f
+          when String
+            case v.downcase
+            when "infinity", "+infinity"
+              Float::INFINITY
+            when "-infinity"
+              -Float::INFINITY
+            when "nan"
+              Float::NAN
+            else
+              Float(v) rescue nil
+            end
+          else
+            nil
+          end
+        end.compact
+      end
+
+      def serialize(value)
+        cast(value)
+      end
+
+      def deserialize(value)
+        return value if value.is_a?(Array)
+        return [] if value.nil?
+
+        # Handle JSON deserialization
+        if value.is_a?(String)
+          begin
+            parsed = JSON.parse(value)
+            cast(parsed)
+          rescue JSON::ParserError
+            []
+          end
+        else
+          cast(value)
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/version.rb

@@ -2,7 +2,7 @@
 
 require_relative "gem_version"
 module ActionMCP
-  VERSION = "0.55.2"
+  VERSION = "0.60.1"
 
   class << self
     alias version gem_version

data/lib/action_mcp.rb

@@ -37,9 +37,15 @@ module ActionMCP
   require_relative "action_mcp/version"
   require_relative "action_mcp/client"
   include Logging
-  PROTOCOL_VERSION = "2025-03-26"  # Default version
-  CURRENT_VERSION = "2025-03-26"   # Current version
-  SUPPORTED_VERSIONS = %w[2025-03-26].freeze
+
+  # Protocol version constants
+  SUPPORTED_VERSIONS = [
+    "2025-06-18", # Dr. Identity McBouncer - OAuth 2.1, elicitation, structured output, resource links
+    "2025-03-26"  # The Persistent Negotiator - StreamableHTTP, resumability, audio support
+  ].freeze
+
+  LATEST_VERSION = SUPPORTED_VERSIONS.first.freeze
+  DEFAULT_PROTOCOL_VERSION = "2025-03-26".freeze  # Default to initial stable version for backwards compatibility
   class << self
     # Returns a Rack-compatible application for serving MCP requests
     # This makes ActionMCP.server work similar to ActionCable.server

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

@@ -49,7 +49,7 @@ module ActionMCP
         say "Available adapters:"
         say "  - simple      : In-memory adapter for development"
         say "  - test        : Test adapter for testing environments"
-        say "  - solid_cable : Database-backed adapter (requires solid_cable gem)"
+        say "  - solid_mcp   : Database-backed adapter optimized for MCP (requires solid_mcp gem)"
         say "  - redis       : Redis-backed adapter (requires redis gem)"
         say ""
         say "Next steps:"

data/lib/generators/action_mcp/install/templates/mcp.yml

@@ -107,9 +107,10 @@ production:
   # Choose one of the following adapters:
   
   # 1. Database-backed adapter (recommended)
-  adapter: solid_cable
+  adapter: solid_mcp
   polling_interval: 0.5.seconds
-  # connects_to: cable  # Optional: specify a different database connection
+  batch_size: 200      # Number of messages to write in a single batch
+  flush_interval: 0.05 # Seconds between batch flushes
   
   # Thread pool configuration (optional)
   min_threads: 10     # Minimum number of threads in the pool

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.55.2
+  version: 0.60.1
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 0.5.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 0.5.3
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -177,6 +177,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: json_schemer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: It offers base classes and helpers for creating MCP applications, making
   it easier to integrate your Ruby/Rails application with the MCP standard
 email:
@@ -215,6 +229,7 @@ files:
 - lib/action_mcp/client/blueprint.rb
 - lib/action_mcp/client/catalog.rb
 - lib/action_mcp/client/collection.rb
+- lib/action_mcp/client/elicitation.rb
 - lib/action_mcp/client/json_rpc_handler.rb
 - lib/action_mcp/client/logging.rb
 - lib/action_mcp/client/messaging.rb
@@ -242,6 +257,7 @@ files:
 - lib/action_mcp/content/base.rb
 - lib/action_mcp/content/image.rb
 - lib/action_mcp/content/resource.rb
+- lib/action_mcp/content/resource_link.rb
 - lib/action_mcp/content/text.rb
 - lib/action_mcp/current.rb
 - lib/action_mcp/current_helpers.rb
@@ -275,6 +291,7 @@ files:
 - lib/action_mcp/server/base_messaging.rb
 - lib/action_mcp/server/capabilities.rb
 - lib/action_mcp/server/configuration.rb
+- lib/action_mcp/server/elicitation.rb
 - lib/action_mcp/server/error_aware.rb
 - lib/action_mcp/server/error_handling.rb
 - lib/action_mcp/server/handlers/prompt_handler.rb
@@ -294,7 +311,7 @@ files:
 - lib/action_mcp/server/session_store.rb
 - lib/action_mcp/server/session_store_factory.rb
 - lib/action_mcp/server/simple_pub_sub.rb
-- lib/action_mcp/server/solid_cable_adapter.rb
+- lib/action_mcp/server/solid_mcp_adapter.rb
 - lib/action_mcp/server/test_session_store.rb
 - lib/action_mcp/server/tools.rb
 - lib/action_mcp/server/transport_handler.rb
@@ -309,6 +326,7 @@ files:
 - lib/action_mcp/tool_response.rb
 - lib/action_mcp/tools_registry.rb
 - lib/action_mcp/transport.rb
+- lib/action_mcp/types/float_array_type.rb
 - lib/action_mcp/uri_ambiguity_checker.rb
 - lib/action_mcp/version.rb
 - lib/actionmcp.rb

data/lib/action_mcp/server/solid_cable_adapter.rb

@@ -1,221 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-require "concurrent/map"
-require "concurrent/array"
-require "concurrent/executor/thread_pool_executor"
-
-module ActionMCP
-  module Server
-    # Mock SolidCable::PubSub for testing
-    class MockSolidCablePubSub
-      attr_reader :subscriptions, :messages
-
-      def initialize(options = {})
-        @options = options
-        @subscriptions = Concurrent::Map.new
-        @messages = Concurrent::Array.new
-      end
-
-      def subscribe(channel, &block)
-        @subscriptions[channel] ||= Concurrent::Array.new
-        @subscriptions[channel] << block
-      end
-
-      def unsubscribe(channel)
-        @subscriptions.delete(channel)
-      end
-
-      def broadcast(channel, message)
-        @messages << { channel: channel, message: message }
-        callbacks = @subscriptions[channel] || []
-        callbacks.each { |callback| callback.call(message) }
-      end
-    end
-
-    # Adapter for SolidCable PubSub
-    class SolidCableAdapter
-      # Thread pool configuration
-      DEFAULT_MIN_THREADS = 5
-      DEFAULT_MAX_THREADS = 10
-      DEFAULT_MAX_QUEUE = 100
-      DEFAULT_THREAD_TIMEOUT = 60 # seconds
-
-      def initialize(options = {})
-        @options = options
-        @subscriptions = Concurrent::Map.new
-        @channels = Concurrent::Map.new
-        @channel_subscribed = Concurrent::Map.new # Track channel subscription status
-
-        # Initialize thread pool for callbacks
-        pool_options = {
-          min_threads: options["min_threads"] || DEFAULT_MIN_THREADS,
-          max_threads: options["max_threads"] || DEFAULT_MAX_THREADS,
-          max_queue: options["max_queue"] || DEFAULT_MAX_QUEUE,
-          fallback_policy: :caller_runs, # Execute in the caller's thread if queue is full
-          idletime: DEFAULT_THREAD_TIMEOUT
-        }
-        @thread_pool = Concurrent::ThreadPoolExecutor.new(pool_options)
-
-        # Configure SolidCable with options from mcp.yml
-        # The main option we care about is polling_interval
-        pubsub_options = {}
-
-        if @options["polling_interval"]
-          # Convert from ActiveSupport::Duration if needed (e.g., "0.1.seconds")
-          interval = @options["polling_interval"]
-          interval = interval.to_f if interval.respond_to?(:to_f)
-          pubsub_options[:polling_interval] = interval
-        end
-
-        # If there's a connects_to option, pass it along
-        pubsub_options[:connects_to] = @options["connects_to"] if @options["connects_to"]
-
-        # Use mock version for testing or real version in production
-        @solid_cable_pubsub = if defined?(SolidCable) && !testing?
-                                SolidCable::PubSub.new(pubsub_options)
-        else
-                                MockSolidCablePubSub.new(pubsub_options)
-        end
-      end
-
-      # Subscribe to a channel
-      # @param channel [String] The channel name
-      # @param message_callback [Proc] Callback for received messages
-      # @param success_callback [Proc] Callback for successful subscription
-      # @return [String] Subscription ID
-      def subscribe(channel, message_callback, success_callback = nil)
-        subscription_id = SecureRandom.uuid
-
-        @subscriptions[subscription_id] = {
-          channel: channel,
-          message_callback: message_callback
-        }
-
-        @channels[channel] ||= Concurrent::Array.new
-        @channels[channel] << subscription_id
-
-        # Subscribe to SolidCable only if we haven't already subscribed to this channel
-        unless subscribed_to_solid_cable?(channel)
-          @solid_cable_pubsub.subscribe(channel) do |message|
-            dispatch_message(channel, message)
-          end
-          @channel_subscribed[channel] = true
-        end
-
-        log_subscription_event(channel, "Subscribed", subscription_id)
-        success_callback&.call
-
-        subscription_id
-      end
-
-      # Unsubscribe from a channel
-      # @param channel [String] The channel name
-      # @param callback [Proc] Optional callback for unsubscribe completion
-      def unsubscribe(channel, callback = nil)
-        # Remove our subscriptions
-        subscription_ids = @channels[channel] || []
-        subscription_ids.each do |subscription_id|
-          @subscriptions.delete(subscription_id)
-        end
-
-        @channels.delete(channel)
-
-        # Only unsubscribe from SolidCable if we're actually subscribed
-        if subscribed_to_solid_cable?(channel)
-          @solid_cable_pubsub.unsubscribe(channel)
-          @channel_subscribed.delete(channel)
-        end
-
-        log_subscription_event(channel, "Unsubscribed")
-        callback&.call
-      end
-
-      # Broadcast a message to a channel
-      # @param channel [String] The channel name
-      # @param message [String] The message to broadcast
-      def broadcast(channel, message)
-        @solid_cable_pubsub.broadcast(channel, message)
-        log_broadcast_event(channel, message)
-      end
-
-      # Check if a channel has subscribers
-      # @param channel [String] The channel name
-      # @return [Boolean] True if channel has subscribers
-      def has_subscribers?(channel)
-        subscribers = @channels[channel]
-        return false unless subscribers
-
-        !subscribers.empty?
-      end
-
-      # Check if we're already subscribed to a channel
-      # @param channel [String] The channel name
-      # @return [Boolean] True if we're already subscribed
-      def subscribed_to?(channel)
-        channel_subs = @channels[channel]
-        return false if channel_subs.nil?
-
-        !channel_subs.empty?
-      end
-
-      # Shut down the thread pool gracefully
-      def shutdown
-        @thread_pool.shutdown
-        @thread_pool.wait_for_termination(5) # Wait up to 5 seconds for tasks to complete
-      end
-
-      private
-
-      # Check if we're in a testing environment
-      def testing?
-        defined?(Minitest) || ENV["RAILS_ENV"] == "test"
-      end
-
-      # Check if we're already subscribed to this channel in SolidCable
-      def subscribed_to_solid_cable?(channel)
-        @channel_subscribed[channel] == true
-      end
-
-      def dispatch_message(channel, message)
-        subscription_ids = @channels[channel] || []
-
-        subscription_ids.each do |subscription_id|
-          subscription = @subscriptions[subscription_id]
-          next unless subscription && subscription[:message_callback]
-
-          @thread_pool.post do
-            subscription[:message_callback].call(message)
-          rescue StandardError => e
-            log_error("Error in message callback: #{e.message}\n#{e.backtrace.join("\n")}")
-          end
-        end
-      end
-
-      def log_subscription_event(channel, action, subscription_id = nil)
-        return unless defined?(Rails) && Rails.respond_to?(:logger)
-
-        message = "SolidCableAdapter: #{action} channel=#{channel}"
-        message += " subscription_id=#{subscription_id}" if subscription_id
-
-        Rails.logger.debug(message)
-      end
-
-      def log_broadcast_event(channel, message)
-        return unless defined?(Rails) && Rails.respond_to?(:logger)
-
-        # Truncate the message for logging
-        truncated_message = message.to_s[0..100]
-        truncated_message += "..." if message.to_s.length > 100
-
-        Rails.logger.debug("SolidCableAdapter: Broadcasting to channel=#{channel} message=#{truncated_message}")
-      end
-
-      def log_error(message)
-        return unless defined?(Rails) && Rails.respond_to?(:logger)
-
-        Rails.logger.error("SolidCableAdapter: #{message}")
-      end
-    end
-  end
-end