actionmcp 0.14.0 → 0.16.0

data/lib/action_mcp/sampling_request.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  class SamplingRequest
+    class << self
+      attr_reader :default_messages, :default_system_prompt, :default_context,
+                  :default_model_hints, :default_intelligence_priority,
+                  :default_max_tokens, :default_temperature
+
+      def configure
+        yield self
+      end
+
+      def messages(messages = nil)
+        if messages
+          @default_messages = messages.map do |msg|
+            mutate_content(msg)
+          end
+        end
+        @default_messages ||= []
+      end
+
+      def system_prompt(prompt = nil)
+        @default_system_prompt = prompt if prompt
+        @default_system_prompt
+      end
+
+      def include_context(context = nil)
+        @default_context = context if context
+        @default_context
+      end
+
+      def model_hints(hints = nil)
+        @default_model_hints = hints if hints
+        @model_hints ||= []
+      end
+
+      def intelligence_priority(priority = nil)
+        @default_intelligence_priority = priority if priority
+        @intelligence_priority ||= 0.9
+      end
+
+      def max_tokens(tokens = nil)
+        @default_max_tokens = tokens if tokens
+        @max_tokens ||= 500
+      end
+
+      def temperature(temp = nil)
+        @default_temperature = temp if temp
+        @temperature ||= 0.7
+      end
+
+      private
+
+      def mutate_content(msg)
+        content = msg[:content]
+        if content.is_a?(ActionMCP::Content) || (content.respond_to?(:to_h) && !content.is_a?(Hash))
+          { role: msg[:role], content: content.to_h }
+        else
+          msg
+        end
+      end
+    end
+
+    attr_accessor :system_prompt, :model_hints, :intelligence_priority, :max_tokens, :temperature
+    attr_reader :messages, :context
+
+    def initialize
+      @messages = self.class.default_messages.dup
+      @system_prompt = self.class.default_system_prompt
+      @context = self.class.default_context
+      @model_hints = self.class.default_model_hints.dup
+      @intelligence_priority = self.class.default_intelligence_priority
+      @max_tokens = self.class.default_max_tokens
+      @temperature = self.class.default_temperature
+
+      yield self if block_given?
+    end
+
+    def messages=(value)
+      @messages = value.map do |msg|
+        self.class.send(:mutate_content, msg)
+      end
+    end
+
+    def include_context=(value)
+      @context = value
+    end
+
+    def add_message(content, role: "user")
+      if content.is_a?(Content::Base) || (content.respond_to?(:to_h) && !content.is_a?(Hash))
+        @messages << { role: role, content: content.to_h }
+      else
+        content = Content::Text.new(content).to_h if content.is_a?(String)
+        @messages << { role: role, content: content }
+      end
+    end
+
+    def to_h
+      {
+        messages: messages.map { |msg| { role: msg[:role], content: msg[:content] } },
+        systemPrompt: system_prompt,
+        includeContext: context,
+        modelPreferences: {
+          hints: model_hints.map { |name| { name: name } },
+          intelligencePriority: intelligence_priority
+        },
+        maxTokens: max_tokens,
+        temperature: temperature
+      }.compact
+    end
+  end
+end

data/lib/action_mcp/server.rb

@@ -1,9 +1,12 @@
+# 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
+    module_function
+
+    def server
       @server ||= ActionCable::Server::Base.new
     end
   end

data/lib/action_mcp/server_json_rpc_handler.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  # Handler for server-side requests (client -> server)
+  class ServerJsonRpcHandler < BaseJsonRpcHandler
+    def handle_initialize(id, params)
+      # Server-specific initialization
+      transport.send_capabilities(id, params)
+    end
+
+    def handle_specific_method(rpc_method, id, params)
+      case rpc_method
+      when %r{^prompts/}               # [SERVER] Prompt-related requests
+        process_prompts(rpc_method, id, params)
+      when %r{^resources/}             # [SERVER] Resource-related requests
+        process_resources(rpc_method, id, params)
+      when %r{^tools/}                 # [SERVER] Tool-related requests
+        process_tools(rpc_method, id, params)
+      when "completion/complete" # [SERVER] Completion requests
+        process_completion_complete(id, params)
+      else
+        Rails.logger.warn("Unknown server method: #{rpc_method}")
+      end
+    end
+    def handle_specific_notification(rpc_method, _params)
+      # Server-specific notifications would go here
+      case rpc_method
+      when "notifications/initialized"            # [SERVER] Initialization complete
+        puts "Initialized"
+        transport.initialize!
+      else
+        Rails.logger.warn("Unknown server notification: #{rpc_method}")
+      end
+    end
+
+    private
+
+    # All the server-specific methods below...
+
+    def process_completion_complete(id, params)
+      # Implementation as in original code
+      transport.send_jsonrpc_response(id, result: { completion: { values: [], total: 0, hasMore: false } })
+      case params["ref"]["type"]
+      when "ref/prompt"
+        # TODO: Implement completion
+      when "ref/resource"
+        # TODO: Implement completion
+      end
+    end
+
+    def process_prompts(rpc_method, id, params)
+      case rpc_method
+      when "prompts/get"              # [SERVER] Get specific prompt
+        transport.send_prompts_get(id, params["name"], params["arguments"])
+      when "prompts/list"             # [SERVER] List available prompts
+        transport.send_prompts_list(id)
+      else
+        Rails.logger.warn("Unknown prompts method: #{rpc_method}")
+      end
+    end
+
+    def process_resources(rpc_method, id, params)
+      case rpc_method
+      when "resources/list"           # [SERVER] List available resources
+        transport.send_resources_list(id)
+      when "resources/templates/list" # [SERVER] List resource templates
+        transport.send_resource_templates_list(id)
+      when "resources/read"           # [SERVER] Read resource content
+        transport.send_resource_read(id, params)
+      when "resources/subscribe"      # [SERVER] Subscribe to resource updates
+        transport.send_resource_subscribe(id, params["uri"])
+      when "resources/unsubscribe"    # [SERVER] Unsubscribe from resource updates
+        transport.send_resource_unsubscribe(id, params["uri"])
+      else
+        Rails.logger.warn("Unknown resources method: #{rpc_method}")
+      end
+    end
+
+    def process_tools(rpc_method, id, params)
+      case rpc_method
+      when "tools/list"               # [SERVER] List available tools
+        transport.send_tools_list(id)
+      when "tools/call"               # [SERVER] Call a tool
+        transport.send_tools_call(id, params&.dig("name"), params&.dig("arguments"))
+      else
+        Rails.logger.warn("Unknown tools method: #{rpc_method}")
+      end
+    end
+  end
+end

data/lib/action_mcp/test_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/testing/assertions"
 
 module ActionMCP
@@ -38,14 +40,16 @@ module ActionMCP
     # @param [Hash] expected_output
     # @param [ActionMCP::ToolResponse] result
     def assert_tool_output(expected_output, result)
-       assert_equal expected_output, result.to_h[:content], "Tool output did not match expected output #{expected_output} != #{result.to_h[:content]}"
+      assert_equal expected_output, result.to_h[:content],
+                   "Tool output did not match expected output #{expected_output} != #{result.to_h[:content]}"
     end
 
     # Asserts that the output of a prompt is equal to the expected output.
     # @param [Hash] expected_output
     # @param [ActionMCP::PromptResponse] result
     def assert_prompt_output(expected_output, result)
-      assert_equal expected_output, result.to_h[:messages], "Prompt output did not match expected output #{expected_output} != #{result.to_h[:messages]}"
+      assert_equal expected_output, result.to_h[:messages],
+                   "Prompt output did not match expected output #{expected_output} != #{result.to_h[:messages]}"
     end
   end
 end

data/lib/action_mcp/tool.rb

@@ -6,6 +6,7 @@ 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 < Capability
+    include ActionMCP::Callbacks
     # --------------------------------------------------------------------------
     # Class Attributes for Tool Metadata and Schema
     # --------------------------------------------------------------------------
@@ -40,6 +41,10 @@ module ActionMCP
 
     class << self
       alias default_capability_name default_tool_name
+
+      def type
+        :tool
+      end
     end
 
     # --------------------------------------------------------------------------
@@ -131,8 +136,10 @@ module ActionMCP
       # Check validations before proceeding
       if valid?
         begin
-          perform # Invoke the subclass-specific logic if valid
-        rescue => e
+          run_callbacks :perform do
+            perform # Invoke the subclass-specific logic if valid
+          end
+        rescue StandardError => e
           # Handle exceptions during execution
           @response.mark_as_error!(:internal_error, message: e.message)
         end
@@ -155,7 +162,9 @@ module ActionMCP
 
       errors_info = errors.any? ? ", errors: #{errors.full_messages}" : ""
 
-      "#<#{self.class.name} #{attributes_hash.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')}, #{response_info}#{errors_info}>"
+      "#<#{self.class.name} #{attributes_hash.map do |k, v|
+        "#{k}: #{v.inspect}"
+      end.join(', ')}, #{response_info}#{errors_info}>"
     end
 
     # Override render to collect Content objects

data/lib/action_mcp/tool_response.rb

@@ -5,6 +5,7 @@ module ActionMCP
   class ToolResponse
     include Enumerable
     attr_reader :contents, :is_error
+
     delegate :empty?, :size, :each, :find, :map, to: :contents
 
     def initialize
@@ -33,13 +34,13 @@ module ActionMCP
         JsonRpc::JsonRpcError.new(@symbol, message: @error_message, data: @error_data).to_h
       else
         {
-          content: @contents.map { |c| c.to_h }
+          content: @contents.map(&:to_h)
         }
       end
     end
 
     # Alias as_json to to_h for consistency
-    alias_method :as_json, :to_h
+    alias as_json to_h
 
     # Handle to_json directly
     def to_json(options = nil)

data/lib/action_mcp/transport/capabilities.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 module ActionMCP
   module Transport
     module Capabilities
       def send_capabilities(request_id, params = {})
+        # TODO fix this if client send incorrect params
+        # TODO refuse connection if protocol version is not supported
         @protocol_version = params["protocolVersion"]
         @client_info = params["clientInfo"]
         @client_capabilities = params["capabilities"]
@@ -9,7 +13,7 @@ module ActionMCP
         session.store_client_capabilities(@client_capabilities)
         session.set_protocol_version(@protocol_version)
         session.save
-        # TODO , if the server don't support the protocol version, send a response with error
+        # TODO: , if the server don't support the protocol version, send a response with error
         send_jsonrpc_response(request_id, result: session.server_capabilities_payload)
       end
     end

data/lib/action_mcp/transport/messaging.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionMCP
   module Transport
     module Messaging

data/lib/action_mcp/transport/prompts.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionMCP
   module Transport
     module Prompts

data/lib/action_mcp/transport/resources.rb

@@ -26,10 +26,8 @@ module ActionMCP
       # @example Output:
       #   # Sends: {"jsonrpc":"2.0","id":"req-456","result":{"resourceTemplates":[{"uriTemplate":"db://{table}","name":"Database Table"}]}}
       def send_resource_templates_list(request_id)
-        templates = ActionMCP::ResourceTemplatesRegistry.resource_templates.values.map do |template|
-          template.to_h
-        end
-        # TODO add pagination support
+        templates = ActionMCP::ResourceTemplatesRegistry.resource_templates.values.map(&:to_h)
+        # TODO: add pagination support
         # TODO add autocomplete
         log_resource_templates
         send_jsonrpc_response(request_id, result: { resourceTemplates: templates })
@@ -47,9 +45,9 @@ module ActionMCP
       # @example Output:
       #   # Sends: {"jsonrpc":"2.0","id":"req-789","result":{"contents":[{"uri":"file:///example.txt","text":"Example content"}]}}
       def send_resource_read(id, params)
-        if  (template = ResourceTemplatesRegistry.find_template_for_uri(params[:uri]))
+        if (template = ResourceTemplatesRegistry.find_template_for_uri(params[:uri]))
           record = template.process(params[:uri])
-          if (resource = record.fetch)
+          if (resource = record.resolve)
             # if resource is a array or a collection, return each item then it ok
             # else wrap it in a array
             resource = [ resource ] unless resource.respond_to?(:each)
@@ -63,6 +61,25 @@ module ActionMCP
         end
       end
 
+      def send_resource_subscribe(id, uri)
+        session.resource_subscribe(uri)
+        send_jsonrpc_response(id, result: {})
+      end
+
+      def send_resource_unsubscribe(id, uri)
+        session.resource_unsubscribe(uri)
+        send_jsonrpc_response(id, result: {})
+      end
+
+      # Client logging
+      def set_client_logging_level(id, level)
+        # Store the client's preferred log level
+        @client_log_level = level
+        send_jsonrpc_response(id, result: {})
+      end
+
+      private
+
       # Log all registered resource templates
       #
       # @example Input:

data/lib/action_mcp/transport/roots.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Transport
+    module Roots
+      def send_roots_list(id)
+        send_jsonrpc_response(id, result: { roots: [] })
+      end
+    end
+  end
+end

data/lib/action_mcp/transport/sampling.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Transport
+    module Sampling
+      # @param [String] id
+      # @param [SamplingRequest] request
+      def send_sampling_create_message(id, request)
+        params = request.is_a?(SamplingRequest) ? request.to_h : request
+        send_jsonrpc_request(id, "sampling/createMessage", params)
+      end
+    end
+  end
+end

data/lib/action_mcp/transport/sse_client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "faraday"
 require "uri"
 
@@ -64,7 +66,7 @@ module ActionMCP
 
         if error
           log_error(error)
-          raise ConnectionError.new(error)
+          raise ConnectionError, error
         end
 
         # If we have the endpoint, consider the connection successful
@@ -86,7 +88,7 @@ module ActionMCP
         end
 
         validate_post_endpoint
-        log_debug("\e[34m" + "--> #{json_rpc}" + "\e[0m")
+        log_debug("\e[34m--> #{json_rpc}\e[0m")
         send_http_request(json_rpc)
       end
 
@@ -131,8 +133,6 @@ module ActionMCP
         @endpoint_mutex.synchronize { @endpoint_received }
       end
 
-      private
-
       # The listen_sse method should NOT mark connection as successful at the end
       def listen_sse
         log_info("Starting SSE listener...")
@@ -142,7 +142,7 @@ module ActionMCP
             req.headers["Accept"] = "text/event-stream"
             req.headers["Cache-Control"] = "no-cache"
 
-            req.options.on_data = Proc.new do |chunk, bytes|
+            req.options.on_data = proc do |chunk, bytes|
               handle_sse_data(chunk, bytes)
             end
           end
@@ -151,7 +151,7 @@ module ActionMCP
           # as the SSE connection stays open
         rescue Faraday::ConnectionFailed => e
           handle_connection_error(format_connection_error(e))
-        rescue => e
+        rescue StandardError => e
           handle_connection_error("Unexpected error: #{e.message}")
         end
       end
@@ -203,7 +203,6 @@ module ActionMCP
         process_buffer while @buffer.include?("\n")
       end
 
-
       def process_buffer
         line, _sep, rest = @buffer.partition("\n")
         @buffer = rest
@@ -241,9 +240,7 @@ module ActionMCP
         end
 
         # If no "data:" prefix was found, treat the entire event as data
-        unless has_data_prefix
-          event_data[:data] = lines.join("\n")
-        end
+        event_data[:data] = lines.join("\n") unless has_data_prefix
         event_data
       end
 
@@ -284,15 +281,14 @@ module ActionMCP
       def send_http_request(json_rpc)
         response = @conn.post(@post_url,
                               json_rpc,
-                              { "Content-Type" => "application/json" }
-        )
+                              { "Content-Type" => "application/json" })
         handle_http_response(response)
       end
 
       def handle_http_response(response)
-        unless response.success?
-          log_error("HTTP POST failed: #{response.status} - #{response.body}")
-        end
+        return if response.success?
+
+        log_error("HTTP POST failed: #{response.status} - #{response.body}")
       end
 
       def cleanup_sse_thread

data/lib/action_mcp/transport/stdio_client.rb

@@ -45,17 +45,17 @@ module ActionMCP
 
       # 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
+        return if @received_server_message
+
+        @received_server_message = true
+        log_info("Received first server message")
+
+        # Send initial capabilities if not already sent
+        return if @capabilities_sent
+
+        log_info("Server is ready, sending initial capabilities...")
+        send_initial_capabilities
+        @capabilities_sent = true
       end
 
       private
@@ -78,9 +78,7 @@ module ActionMCP
             log_info(line)
 
             # Check stderr for server messages
-            if line.include?("MCP Server") || line.include?("running on stdio")
-              mark_ready_and_send_capabilities
-            end
+            mark_ready_and_send_capabilities if line.include?("MCP Server") || line.include?("running on stdio")
           end
         end
 

data/lib/action_mcp/transport/tools.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionMCP
   module Transport
     module Tools

data/lib/action_mcp/transport/transport_base.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ActionMCP
   module Transport
     class TransportBase
       attr_reader :logger, :client_capabilities, :server_capabilities
 
-      def initialize(logger: Logger.new(STDOUT))
+      def initialize(logger: Logger.new($stdout))
         @logger = logger
         @on_message = nil
         @on_error = nil
@@ -43,14 +45,13 @@ module ActionMCP
       end
 
       def handle_initialize_response(response)
-        unless @server_capabilities
+        return if @server_capabilities
 
-          if response.result
-            @server_capabilities = response.result["capabilities"]
-            send_initialized_notification
-          else
-            log_error("Server initialization failed: #{response.error}")
-          end
+        if response.result
+          @server_capabilities = response.result["capabilities"]
+          send_initialized_notification
+        else
+          log_error("Server initialization failed: #{response.error}")
         end
       end
 
@@ -65,24 +66,24 @@ module ActionMCP
           response = nil
 
           if msg_hash.key?("jsonrpc")
-            if msg_hash.key?("id")
-              response = JsonRpc::Response.new(**msg_hash.slice("id", "result", "error").symbolize_keys)
+            response = if msg_hash.key?("id")
+                         JsonRpc::Response.new(**msg_hash.slice("id", "result", "error").symbolize_keys)
             else
-              response = JsonRpc::Notification.new(**msg_hash.slice("method", "params").symbolize_keys)
+                         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
+          elsif response
+            @on_message&.call(response)
           end
         rescue MultiJson::ParseError => e
           log_error("JSON parse error: #{e} (raw: #{raw})")
-          @on_error&.call(e) if @on_error
+          @on_error&.call(e)
         rescue StandardError => e
           log_error("Error handling message: #{e} (raw: #{raw})")
-          @on_error&.call(e) if @on_error
+          @on_error&.call(e)
         end
       end
 

data/lib/action_mcp/transport.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionMCP
   module Transport
   end

data/lib/action_mcp/transport_handler.rb

@@ -3,6 +3,7 @@
 module ActionMCP
   class TransportHandler
     attr_reader :session
+
     delegate :initialize!, :initialized?, to: :session
     delegate :read, :write, to: :session
     include Logging
@@ -13,6 +14,8 @@ module ActionMCP
     include Transport::Prompts
     include Transport::Resources
     include Transport::Notifications
+    include Transport::Sampling
+    include Transport::Roots
 
     # @param [ActionMCP::Session] session
     def initialize(session)

data/lib/action_mcp/version.rb

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