actionmcp 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51df9fa26245d233eebbbf193729618ee8c0f8cc7aa6c680d1a2daac97b9a19e
-  data.tar.gz: b3b898d71781a538ee1826c64294018494e4824a0971768adadcb516be2dd2df
+  metadata.gz: 60e4539fb902676529e53c949552d94deee59d23c4bade8b0f7cbd65f639fc23
+  data.tar.gz: 3bd3d5c01abbaf88f0e45e348f81ffe3aa3170c748e22a198c025af3e0fef146
 SHA512:
-  metadata.gz: a5304f933ec4c0b4e97ca263c2c6833a380dd99ae3beca60e00709c71dbe921024e9572bf1a2ba38e69729d8c8d7728c6d1ab2d3e854cdbfc720c8c494fb59fc
-  data.tar.gz: c79eac91747d34080ae55326d41005e0a71e2ab940abbb858f35e6601797e6ea923f0e4a21bf718456a0a3a6688a05c833ec41e5717d03bd6fcf4eaff2aa554b
+  metadata.gz: aa892c898a93934af62ab31f729602696b522516d041f2951e11b64bd02f375419c552b2e481b1743dc95632ba31092c5f8358e12001e2a26c47af1dfb57d334
+  data.tar.gz: dcb0d1ea6dedf6e845dc6279b58158007bc950687cdb8ceb8c1a1457f8280a8aa8c4a10f4f1cf1d8da54f7b4a26952dd62753ab2786654c4d0e15d7b0c8ab379

data/README.md

@@ -86,6 +86,7 @@ ActionMCP includes Rails generators to help you quickly set up your MCP server c
 You can generate the base classes for your MCP Prompt and Tool using the following command:
 
 ```bash
+bin/rails action_mcp:install:migrations  # to copy the migrations
 bin/rails generate action_mcp:install 
 ```
 

data/app/controllers/action_mcp/application_controller.rb

@@ -0,0 +1,13 @@
+module ActionMCP
+  class ApplicationController < ActionController::Metal
+    abstract!
+    ActionController::API.without_modules(:StrongParameters, :ParamsWrapper).each do |left|
+      include left
+    end
+    include Engine.routes.url_helpers
+
+    def session_key
+      @session_key = "action_mcp-sessions-#{session_id}"
+    end
+  end
+end

data/app/controllers/action_mcp/messages_controller.rb

@@ -0,0 +1,41 @@
+module ActionMCP
+  class MessagesController < ApplicationController
+    # @route POST / (sse_in)
+    def create
+      begin
+        handle_post_message(clean_params, response)
+      rescue => e
+        head :internal_server_error
+      end
+      head response.status
+    end
+
+    private
+
+    def transport_handler
+      TransportHandler.new(mcp_session)
+    end
+
+    def json_rpc_handler
+      @json_rpc_handler ||= ActionMCP::JsonRpcHandler.new(transport_handler)
+    end
+
+    def handle_post_message(params, response)
+      json_rpc_handler.call(params)
+
+      response.status = :accepted
+    rescue StandardError => e
+      puts "Error: #{e.message}"
+      puts e.backtrace.join("\n")
+      response.status = :bad_request
+    end
+
+    def mcp_session
+      Session.find(params[:session_id])
+    end
+
+    def clean_params
+      params.slice(:id, :method, :jsonrpc, :params, :result, :error)
+    end
+  end
+end

data/app/controllers/action_mcp/sse_controller.rb

@@ -0,0 +1,131 @@
+module ActionMCP
+  class SSEController < ApplicationController
+    HEARTBEAT_INTERVAL = 30 # TODO: The frequency of pings SHOULD be configurable
+    INITIALIZATION_TIMEOUT = 2
+    include ActionController::Live
+
+    # @route GET /sse (sse_out)
+    def events
+      # Set headers first
+      response.headers["X-Accel-Buffering"] = "no"
+      response.headers["Content-Type"] = "text/event-stream"
+      response.headers["Cache-Control"] = "no-cache"
+      response.headers["Connection"] = "keep-alive"
+
+      # Now start streaming - send endpoint
+      send_endpoint_event(sse_in_url)
+
+      begin
+        # Start listener and process messages via the transport
+        listener = SSEListener.new(mcp_session)
+        if listener.start do |message|
+          # Send with proper SSE formatting
+          sse = SSE.new(response.stream)
+          sse.write(message)
+        end
+
+          # Heartbeat loop
+          until response.stream.closed?
+            sleep HEARTBEAT_INTERVAL
+            mcp_session.send_ping!
+          end
+        else
+          Rails.logger.error "Listener failed to activate for session: #{session_id}"
+          raise "Failed to establish subscription"
+        end
+      rescue ActionController::Live::ClientDisconnected, IOError => e
+        Rails.logger.debug "SSE: Expected disconnection: #{e.message}"
+      rescue => e
+        Rails.logger.error "SSE: Unexpected error: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
+      ensure
+        listener.stop
+        response.stream.close
+        Rails.logger.debug "SSE: Connection closed for session: #{session_id}"
+      end
+    end
+
+    private
+
+    def send_endpoint_event(messages_url)
+      endpoint = "#{messages_url}?session_id=#{session_id}"
+      SSE.new(response.stream,
+              event: "endpoint")
+         .write(endpoint)
+    end
+
+    def default_url_options
+      { host: request.host, port: request.port }
+    end
+
+    def mcp_session
+      @mcp_session ||= Session.create
+    end
+
+    def session_id
+      @session_id ||= mcp_session.id
+    end
+  end
+
+  class SSEListener
+    attr_reader :session_key, :adapter
+    delegate :session_key, :adapter, to: :@session
+
+    # @param session [ActionMCP::Session]
+    def initialize(session)
+      @session = session
+      @stopped = false
+      @subscription_active = false
+    end
+
+    # Start listening using ActionCable's adapter
+    def start(&callback)
+      Rails.logger.debug "Starting listener for channel: #{session_key}"
+
+      # Set up success callback
+      success_callback = -> {
+        Rails.logger.debug "Successfully subscribed to channel: #{session_key}"
+        @subscription_active = true
+      }
+
+      # Set up message callback with detailed debugging
+      message_callback = ->(raw_message) {
+        begin
+          # Try to parse the message if it's JSON
+          message = MultiJson.load(raw_message)
+
+          # Send the message to the callback
+          callback.call(message) if callback && !@stopped
+        rescue => e
+          # Still try to send the raw message as a fallback
+          callback.call(raw_message) if callback && !@stopped
+        end
+      }
+
+      # Subscribe using the ActionCable adapter
+      adapter.subscribe(session_key, message_callback, success_callback)
+
+      # Give some time for the subscription to be established
+      sleep 0.5
+
+      @subscription_active
+    end
+
+    def stop
+      Rails.logger.debug "Stopping listener for: #{session_key}"
+      @stopped = true
+
+      # Unsubscribe using the correct method signature
+      begin
+        # Create a dummy callback that matches the one we provided in start
+        @session.close!
+        Rails.logger.debug "Unsubscribed from: #{session_key}"
+      rescue => e
+        Rails.logger.error "Error unsubscribing from #{session_key}: #{e.message}"
+      end
+    end
+
+    def active?
+      @subscription_active
+    end
+  end
+end

data/app/models/action_mcp/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/action_mcp/session/message.rb

@@ -0,0 +1,91 @@
+module ActionMCP
+  class Session::Message < ApplicationRecord
+    belongs_to :session,
+               class_name: "ActionMCP::Session",
+               inverse_of: :messages,
+               counter_cache: true
+
+    delegate :adapter,
+             :role,
+             :session_key,
+             to: :session
+
+    # Virtual attribute for data
+    attr_reader :data
+
+    after_create_commit :broadcast_message, if: :outgoing_message?
+
+    # @param payload [String, Hash]
+    def data=(payload)
+      @data = payload
+
+      # Store original version and attempt to determine type
+      if payload.is_a?(String)
+        self.message_text = payload
+
+        begin
+          parsed_json = MultiJson.load(payload)
+          self.message_json = parsed_json
+          process_json_content(parsed_json)
+        rescue MultiJson::ParseError
+          # Not valid JSON, just store as text
+          self.message_type = "text"
+        end
+      else
+        # Handle Hash or other JSON-serializable input
+        self.message_json = payload
+        self.message_text = MultiJson.dump(payload)
+        process_json_content(payload)
+      end
+    end
+
+    def data
+      message_json.presence || message_text
+    end
+
+    # Helper method to check if message is a particular type
+    def request?
+      message_type == "request"
+    end
+
+    def notification?
+      message_type == "notification"
+    end
+
+    def response?
+      message_type == "response"
+    end
+
+    private
+
+    def outgoing_message?
+      direction != role
+    end
+
+    def broadcast_message
+      adapter.broadcast(session_key, data.to_json)
+    end
+
+    def process_json_content(content)
+      # Determine message type based on JSON-RPC spec
+      if content.is_a?(Hash) && content["jsonrpc"] == "2.0"
+        if content.key?("id") && content.key?("method")
+          self.message_type = "request"
+          self.jsonrpc_id = content["id"]
+        elsif content.key?("method") && !content.key?("id")
+          self.message_type = "notification"
+        elsif content.key?("id") && content.key?("result")
+          self.message_type = "response"
+          self.jsonrpc_id = content["id"]
+        elsif content.key?("id") && content.key?("error")
+          self.message_type = "error"
+          self.jsonrpc_id = content["id"]
+        else
+          self.message_type = "invalid_jsonrpc"
+        end
+      else
+        self.message_type = "non_jsonrpc_json"
+      end
+    end
+  end
+end

data/app/models/action_mcp/session.rb

@@ -0,0 +1,109 @@
+module ActionMCP
+  class Session < ApplicationRecord
+    attribute :id, :string, default: -> { SecureRandom.hex(6) }
+    has_many :messages,
+             class_name: "ActionMCP::Session::Message",
+             foreign_key: "session_id",
+             dependent: :destroy,
+             inverse_of: :session
+
+    scope :pre_initialize, -> { where(status: "pre_initialize") }
+    scope :closed, -> { where(status: "closed") }
+    scope :without_messages, -> { includes(:messages).where(action_mcp_session_messages: { id: nil }) }
+
+    before_create :set_server_info
+    before_create :set_server_capabilities
+
+    validates :protocol_version, inclusion: { in: [ PROTOCOL_VERSION ] }, allow_nil: true
+
+    def close!
+      adapter.unsubscribe(session_key, _)
+      update!(status: "closed", ended_at: Time.zone.now)
+    end
+
+    def write(data)
+      if data.is_a?(JsonRpc::Request) || data.is_a?(JsonRpc::Response) || data.is_a?(JsonRpc::Notification)
+        data = data.to_json
+      end
+      if data.is_a?(Hash)
+        data = MultiJson.dump(data)
+      end
+
+      messages.create!(data: data, direction: writer_role)
+    end
+
+    def read(data)
+      puts "\e[33m[#{role}] #{data}\e[0m"
+      messages.create!(data: data, direction: role)
+    end
+
+    def session_key
+      "action_mcp:session:#{id}"
+    end
+
+    def adapter
+      @adapter ||= ActionMCP::Server.server.pubsub
+    end
+
+    def set_protocol_version(version)
+      update(protocol_version: version)
+    end
+
+    def store_client_info(info)
+      self.client_info = info
+    end
+
+    def store_client_capabilities(capabilities)
+      self.client_capabilities = capabilities
+    end
+
+    def server_capabilities_payload
+      {
+        protocolVersion: PROTOCOL_VERSION,
+        serverInfo: server_info,
+        capabilities: server_capabilities
+      }
+    end
+
+    def initialize!
+      # update the session initialized to true if client_capabilities are present
+      update!(initialized: true,
+              status: "initialized"
+      ) if client_capabilities.present?
+    end
+
+    def message_flow
+      messages.order(created_at: :asc).map do |message|
+        {
+          direction: message.direction,
+          data: message.data,
+          type: message.message_type
+        }
+      end
+    end
+
+    def send_ping!
+      write(JsonRpc::Request.new(id: Time.now.to_i, method: "ping"))
+    end
+
+    private
+
+    # if this session is from a server, the writer is the client
+    def writer_role
+      role == "server" ? "client" : "server"
+    end
+
+    # This will keep the version and name of the server when this session was created
+    def set_server_info
+      self.server_info = {
+        name: ActionMCP.configuration.name,
+        version: ActionMCP.configuration.version
+      }
+    end
+
+    # This can be overridden by the application in future versions
+    def set_server_capabilities
+      self.server_capabilities ||= ActionMCP.configuration.capabilities
+    end
+  end
+end

data/app/models/action_mcp.rb

@@ -0,0 +1,5 @@
+module ActionMCP
+  def self.table_name_prefix
+    "action_mcp_"
+  end
+end

data/config/routes.rb

@@ -0,0 +1,4 @@
+ActionMCP::Engine.routes.draw do
+  get "/", to: "sse#events", as: :sse_out
+  post "/", to: "messages#create", as: :sse_in
+end

data/lib/action_mcp/configuration.rb

@@ -45,7 +45,7 @@ module ActionMCP
       capabilities[:logging] = {} if @logging_enabled
       # capabilities[:resources] = { subscribe: @resources_subscribe,
       #                              listChanged: @list_changed }.compact
-      { capabilities: capabilities }
+      capabilities
     end
   end
 

data/lib/action_mcp/json_rpc_handler.rb

@@ -2,13 +2,17 @@
 
 module ActionMCP
   class JsonRpcHandler
+    delegate :initialize!, :initialized?, to: :transport
+    delegate :write, :read, to: :transport
     attr_reader :transport
 
+    # @param transport [ActionMCP::TransportHandler]
     def initialize(transport)
       @transport = transport
     end
 
     # Process a single line of input.
+    # @param line [String, Hash]
     def call(line)
       request = if line.is_a?(String)
                   line.strip!
@@ -28,11 +32,16 @@ module ActionMCP
 
     private
 
+    # @param request [Hash]
     def process_request(request)
-       unless request["jsonrpc"] == "2.0"
-         puts "Invalid request: #{request}"
-         return
-       end
+      unless request["jsonrpc"] == "2.0"
+        puts "Invalid request: #{request}"
+        return
+      end
+      read(request)
+      return if request["error"]
+      return if request["result"] == {} # Probably a pong
+
       method = request["method"]
       id = request["id"]
       params = request["params"]
@@ -45,42 +54,80 @@ module ActionMCP
         transport.send_pong(id)
       when /^notifications\//
         puts "\e[31mProcessing notifications\e[0m"
-        process_notifications(method, id, params)
+        process_notifications(method)
       when /^prompts\//
         process_prompts(method, id, params)
       when /^resources\//
         process_resources(method, id, params)
       when /^tools\//
         process_tools(method, id, params)
+      when "completion/complete"
+        process_completion_complete(id, params)
       else
-        puts "\e[31mUnknown method: #{method}\e[0m"
-        Rails.logger.warn("Unknown method: #{method}")
+        puts "\e[31mUnknown method: #{method} #{request}\e[0m"
       end
     end
 
-    def process_notifications(method, _id, _params)
-      case method
+    # @param rpc_method [String]
+    def process_notifications(rpc_method)
+      case rpc_method
       when "notifications/initialized"
         puts "\e[31mInitialized\e[0m"
-        transport.initialized!
+        transport.initialize!
       else
-        Rails.logger.warn("Unknown notifications method: #{method}")
+        Rails.logger.warn("Unknown notifications method: #{rpc_method}")
       end
     end
 
-    def process_prompts(method, id, params)
-      case method
+    # @param id [String]
+    # @param params [Hash]
+    # @example {
+    #     "ref": {
+    #       "type": "ref/prompt",
+    #       "name": "code_review"
+    #     },
+    #     "argument": {
+    #       "name": "language",
+    #       "value": "py"
+    #     }
+    #   }
+    # @return [Hash]
+    # @example {
+    #     "completion": {
+    #       "values": ["python", "pytorch", "pyside"],
+    #       "total": 10,
+    #       "hasMore": true
+    #     }
+    #   }
+    def process_completion_complete(id, params)
+      case params["ref"]["type"]
+      when "ref/prompt"
+        # TODO: Implement completion
+      when "ref/resource"
+        # TODO: Implement completion
+      end
+    end
+
+    # @param rpc_method [String]
+    # @param id [String]
+    # @param params [Hash]
+    def process_prompts(rpc_method, id, params)
+      case rpc_method
       when "prompts/get"
-        transport.send_prompts_get(id, params&.dig("name"), params&.dig("arguments"))
+        transport.send_prompts_get(id, params["name"], params["arguments"])
       when "prompts/list"
         transport.send_prompts_list(id)
       else
-        Rails.logger.warn("Unknown prompts method: #{method}")
+        Rails.logger.warn("Unknown prompts method: #{rpc_method}")
       end
     end
 
-    def process_resources(method, id, params)
-      case method
+    # @param rpc_method [String]
+    # @param id [String]
+    # @param params [Hash]
+    # Not implemented
+    def process_resources(rpc_method, id, params)
+      case rpc_method
       when "resources/list"
         transport.send_resources_list(id)
       when "resources/templates/list"
@@ -88,18 +135,18 @@ module ActionMCP
       when "resources/read"
         transport.send_resource_read(id, params)
       else
-        Rails.logger.warn("Unknown resources method: #{method}")
+        Rails.logger.warn("Unknown resources method: #{rpc_method}")
       end
     end
 
-    def process_tools(method, id, params)
-      case method
+    def process_tools(rpc_method, id, params)
+      case rpc_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}")
+        Rails.logger.warn("Unknown tools method: #{rpc_method}")
       end
     end
   end

data/lib/action_mcp/prompt.rb

@@ -26,8 +26,9 @@ module ActionMCP
     def self.default_prompt_name
       name.demodulize.underscore.sub(/_prompt$/, "")
     end
+
     class << self
-    alias default_capability_name default_prompt_name
+      alias default_capability_name default_prompt_name
     end
 
     # ---------------------------------------------------
@@ -39,21 +40,26 @@ module ActionMCP
     # @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.
+    # @param enum [Array<String>] The list of allowed values for the argument.
     # @return [void]
-    def self.argument(arg_name, description: "", required: false, default: nil)
+    # Argument DSL
+    def self.argument(arg_name, description: "", required: false, default: nil, enum: nil)
       arg_def = {
         name: arg_name.to_s,
         description: description,
         required: required,
-        default: default
+        default: default,
+        enum: enum
       }
       self._argument_definitions += [ arg_def ]
 
       # Register the attribute so it's recognized by ActiveModel
       attribute arg_name, :string, default: default
-      return unless required
+      validates arg_name, presence: true if required
 
-      validates arg_name, presence: true
+      if enum.present?
+        validates arg_name, inclusion: { in: enum }
+      end
     end
 
     # Returns the list of argument definitions.

data/lib/action_mcp/transport/capabilities.rb

@@ -5,16 +5,12 @@ module ActionMCP
         @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)
+        session.store_client_info(@client_info)
+        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
+        send_jsonrpc_response(request_id, result: session.server_capabilities_payload)
       end
     end
   end

data/lib/action_mcp/transport/messaging.rb

@@ -3,17 +3,17 @@ module ActionMCP
     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)
+        write_message(request)
       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)
+        write_message(response)
       end
 
       def send_jsonrpc_notification(method, params = nil)
         notification = JsonRpc::Notification.new(method: method, params: params)
-        write_message(notification.to_json)
+        write_message(notification)
       end
     end
   end

data/lib/action_mcp/transport_handler.rb

@@ -2,6 +2,9 @@
 
 module ActionMCP
   class TransportHandler
+    attr_reader :session
+    delegate :initialize!, :initialized?, to: :session
+    delegate :read, :write, to: :session
     include Logging
 
     include Transport::Capabilities
@@ -10,41 +13,20 @@ module ActionMCP
     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")
+    # @param [ActionMCP::Session] session
+    def initialize(session)
+      @session = session
     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")
+      session.write(data)
     end
 
     def format_registry_items(registry)

data/lib/action_mcp/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Abdelkader Boudih
 bindir: exe
 cert_chain: []
-date: 2025-03-11 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -105,6 +105,14 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- app/controllers/action_mcp/application_controller.rb
+- app/controllers/action_mcp/messages_controller.rb
+- app/controllers/action_mcp/sse_controller.rb
+- app/models/action_mcp.rb
+- app/models/action_mcp/application_record.rb
+- app/models/action_mcp/session.rb
+- app/models/action_mcp/session/message.rb
+- config/routes.rb
 - exe/actionmcp_cli
 - lib/action_mcp.rb
 - lib/action_mcp/capability.rb