actionmcp 0.33.0 → 0.50.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49bbf32664efb30dff032e7ab8ff3e76d972016cc7cf1a1a966c61cc507d7680
-  data.tar.gz: 61182b5e6367ecbbe7db4446a8da8a7ae756dd164e6b302a99f5583be64b3c8c
+  metadata.gz: 6673ed8cefa0458b617bcb9ceb865c4aef47a5448752cbe230dc950afea1941f
+  data.tar.gz: 68b8c888e2983cea309cd9498d1bde1887025d37058deabeb1b844c0ae3213d8
 SHA512:
-  metadata.gz: c2eac5bcb5a430ae67223000f3741f15acf4d6e1fbdd9d9f240640768d4da6e9b62d2ca0ec303be327ae818f1af86ad458b22e30fed6312cb710d02710532b8c
-  data.tar.gz: a39eb66c2dd002fd821c2db65b3f848c2a68e5d219d46efb0736d5501572235021be2d188cffd6783a14d8e0704737f313f9f225c2542c2d5ca047af08b9193e
+  metadata.gz: 1493f47a18bcc5892c84efcfd51840b50cb6d69c9834c0d114cdaa8fe4a7f040d2ac9d84aec06a9599f25135e797bf85e056c7f602571fe6c47f07928e3c6aa9
+  data.tar.gz: a4d9cf8658e976d05d8330b9349d143cdf49abc281e974d40f9b70d11592ec619d1e55b47f74c5e6e94865d05a7d8c8fae363e1d98d1bed738fa7be2ee5c4ff2

data/README.md

@@ -1,6 +1,10 @@
 # ActionMCP
 
-**ActionMCP** is a Ruby gem that provides essential tooling for building Model Context Protocol (MCP) capable servers in Ruby on Rails applications.
+**ActionMCP** is a Ruby gem focused on providing Model Context Protocol (MCP) capability to Ruby on Rails applications, specifically as a server.
+
+ActionMCP is designed for production Rails environments and does **not** support STDIO transport. STDIO is not included because it is not production-ready and is only suitable for desktop or script-based use cases. Instead, ActionMCP is built for robust, network-based deployments.
+
+The client functionality in ActionMCP is intended to connect to remote MCP servers, not to local processes via STDIO.
 
 It offers base classes and helpers for creating MCP applications, making it easier to integrate your Ruby/Rails application with the MCP standard.
 
@@ -16,8 +20,9 @@ MCP allows AI systems to plug into various resources in a consistent, secure way
 
 This means an AI (like an LLM) can request information or actions from your application through a well-defined protocol, and your app can provide context or perform tasks for the AI in return.
 
-**ActionMCP** is targeted at developers building MCP-enabled applications.
-It simplifies the process of integrating Ruby and Rails apps with the MCP standard by providing a set of base classes and an easy-to-use server interface.
+**ActionMCP** is targeted at developers building MCP-enabled Rails applications. It simplifies the process of integrating Ruby and Rails apps with the MCP standard by providing a set of base classes and an easy-to-use server interface.
+
+> **Note:** STDIO transport is not supported in ActionMCP. This gem is focused on production-ready, network-based deployments. STDIO is only suitable for desktop or script-based experimentation and is intentionally excluded.
 
 Instead of implementing MCP support from scratch, you can subclass and configure the provided **Prompt**, **Tool**, and **ResourceTemplate** classes to expose your app's functionality to LLMs. 
 
@@ -25,6 +30,8 @@ ActionMCP handles the underlying MCP message format and routing, so you can adhe
 
 In short, ActionMCP helps you build an MCP server (the component that exposes capabilities to AI) more quickly and with fewer mistakes.
 
+> **Client connections:** The client part of ActionMCP is meant to connect to remote MCP servers only. Connecting to local processes (such as via STDIO) is not supported.
+
 ## Installation
 
 To start using ActionMCP, add it to your project:

data/app/controllers/action_mcp/unified_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActionMCP
-  # Handles the unified MCP endpoint for the 2025-03-26 specification.
+  # Implements the MCP endpoints according to the 2025-03-26 specification.
   # Supports GET for server-initiated SSE streams, POST for client messages
   # (responding with JSON or SSE), and optionally DELETE for session termination.
   class UnifiedController < MCPController

data/config/routes.rb

@@ -2,14 +2,9 @@
 
 ActionMCP::Engine.routes.draw do
   get "/up", to: "/rails/health#show", as: :action_mcp_health_check
-  # --- Routes for 2024-11-05 Spec (HTTP+SSE) ---
-  # Kept for backward compatibility
-  get "/", to: "sse#events", as: :sse_out
-  post "/", to: "messages#create", as: :sse_in, defaults: { format: "json" }
 
-  # --- Routes for 2025-03-26 Spec (Streamable HTTP) ---
-  mcp_endpoint = ActionMCP.configuration.mcp_endpoint_path
-  get mcp_endpoint, to: "unified#show", as: :mcp_get
-  post mcp_endpoint, to: "unified#create", as: :mcp_post
-  delete mcp_endpoint, to: "unified#destroy", as: :mcp_delete
+  # MCP 2025-03-26 Spec routes
+  get "/", to: "unified#show", as: :mcp_get
+  post "/", to: "unified#create", as: :mcp_post
+  delete "/", to: "unified#destroy", as: :mcp_delete
 end

data/db/migrate/20250512154359_consolidated_migration.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+class ConsolidatedMigration < ActiveRecord::Migration[8.0]
+  def change
+    # Only create tables if they don't exist to avoid deleting existing data
+
+    # Create sessions table
+    unless table_exists?(:action_mcp_sessions)
+      create_table :action_mcp_sessions, id: :string do |t|
+        t.string :role, null: false, default: 'server', comment: 'The role of the session'
+        t.string :status, null: false, default: 'pre_initialize'
+        t.datetime :ended_at, comment: 'The time the session ended'
+        t.string :protocol_version
+        t.jsonb :server_capabilities, comment: 'The capabilities of the server'
+        t.jsonb :client_capabilities, comment: 'The capabilities of the client'
+        t.jsonb :server_info, comment: 'The information about the server'
+        t.jsonb :client_info, comment: 'The information about the client'
+        t.boolean :initialized, null: false, default: false
+        t.integer :messages_count, null: false, default: 0
+        t.integer :sse_event_counter, default: 0, null: false
+        t.jsonb :tool_registry, default: []
+        t.jsonb :prompt_registry, default: []
+        t.jsonb :resource_registry, default: []
+        t.timestamps
+      end
+    end
+
+    # Create session messages table
+    unless table_exists?(:action_mcp_session_messages)
+      create_table :action_mcp_session_messages do |t|
+        t.references :session, null: false,
+                    foreign_key: { to_table: :action_mcp_sessions,
+                                  on_delete: :cascade,
+                                  on_update: :cascade,
+                                  name: 'fk_action_mcp_session_messages_session_id' }, type: :string
+        t.string :direction, null: false, comment: 'The message recipient', default: 'client'
+        t.string :message_type, null: false, comment: 'The type of the message'
+        t.string :jsonrpc_id
+        t.jsonb :message_json
+        t.boolean :is_ping, default: false, null: false, comment: 'Whether the message is a ping'
+        t.boolean :request_acknowledged, default: false, null: false
+        t.boolean :request_cancelled, null: false, default: false
+        t.timestamps
+      end
+    end
+
+    # Create session subscriptions table
+    unless table_exists?(:action_mcp_session_subscriptions)
+      create_table :action_mcp_session_subscriptions do |t|
+        t.references :session,
+                    null: false,
+                    foreign_key: { to_table: :action_mcp_sessions, on_delete: :cascade },
+                    type: :string
+        t.string :uri, null: false
+        t.datetime :last_notification_at
+        t.timestamps
+      end
+    end
+
+    # Create session resources table
+    unless table_exists?(:action_mcp_session_resources)
+      create_table :action_mcp_session_resources do |t|
+        t.references :session,
+                    null: false,
+                    foreign_key: { to_table: :action_mcp_sessions, on_delete: :cascade },
+                    type: :string
+        t.string :uri, null: false
+        t.string :name
+        t.text :description
+        t.string :mime_type, null: false
+        t.boolean :created_by_tool, default: false
+        t.datetime :last_accessed_at
+        t.json :metadata
+        t.timestamps
+      end
+    end
+
+    # Create SSE events table
+    unless table_exists?(:action_mcp_sse_events)
+      create_table :action_mcp_sse_events do |t|
+        t.references :session, null: false, foreign_key: { to_table: :action_mcp_sessions }, index: true, type: :string
+        t.integer :event_id, null: false
+        t.text :data, null: false
+        t.timestamps
+
+        # Index for efficiently retrieving events after a given ID for a specific session
+        t.index [ :session_id, :event_id ], unique: true
+        t.index :created_at # For cleanup of old events
+      end
+    end
+
+    # Add missing columns to existing tables if they exist
+
+    # For action_mcp_sessions
+    if table_exists?(:action_mcp_sessions)
+      unless column_exists?(:action_mcp_sessions, :sse_event_counter)
+        add_column :action_mcp_sessions, :sse_event_counter, :integer, default: 0, null: false
+      end
+
+      unless column_exists?(:action_mcp_sessions, :tool_registry)
+        add_column :action_mcp_sessions, :tool_registry, :jsonb, default: []
+      end
+
+      unless column_exists?(:action_mcp_sessions, :prompt_registry)
+        add_column :action_mcp_sessions, :prompt_registry, :jsonb, default: []
+      end
+
+      unless column_exists?(:action_mcp_sessions, :resource_registry)
+        add_column :action_mcp_sessions, :resource_registry, :jsonb, default: []
+      end
+    end
+
+    # For action_mcp_session_messages
+    if table_exists?(:action_mcp_session_messages)
+      unless column_exists?(:action_mcp_session_messages, :is_ping)
+        add_column :action_mcp_session_messages, :is_ping, :boolean, default: false, null: false, comment: 'Whether the message is a ping'
+      end
+
+      unless column_exists?(:action_mcp_session_messages, :request_acknowledged)
+        add_column :action_mcp_session_messages, :request_acknowledged, :boolean, default: false, null: false
+      end
+
+      unless column_exists?(:action_mcp_session_messages, :request_cancelled)
+        add_column :action_mcp_session_messages, :request_cancelled, :boolean, null: false, default: false
+      end
+
+      if column_exists?(:action_mcp_session_messages, :message_text)
+        remove_column :action_mcp_session_messages, :message_text
+      end
+
+      if column_exists?(:action_mcp_session_messages, :direction)
+        change_column_comment :action_mcp_session_messages, :direction, 'The message recipient'
+      end
+    end
+  end
+
+  private
+
+  def table_exists?(table_name)
+    ActionMCP::ApplicationRecord.connection.table_exists?(table_name)
+  end
+
+  def column_exists?(table_name, column_name)
+    ActionMCP::ApplicationRecord.connection.column_exists?(table_name, column_name)
+  end
+end

data/exe/actionmcp_cli

@@ -24,6 +24,8 @@ end
 # Parse command-line arguments
 parser = OptionParser.new do |opts|
   opts.banner = 'Usage: mcp_client ENDPOINT [options]'
+  opts.separator ''
+  opts.separator 'ENDPOINT must be an HTTP(S) URL (e.g., http://localhost:3000/action_mcp)'
   opts.on('-l', '--log-level LEVEL', 'Set log level (DEBUG, INFO, WARN, ERROR)') do |l|
     options[:logging_level] = l.upcase
     logger.level = begin
@@ -53,6 +55,11 @@ if endpoint.nil?
   exit 1
 end
 
+unless endpoint =~ %r{\Ahttps?://}
+  puts "Error: Only HTTP(S) endpoints are supported. STDIO/command endpoints are not allowed."
+  exit 1
+end
+
 # Function to generate a unique request ID
 def generate_request_id
   SecureRandom.uuid
@@ -129,7 +136,7 @@ def print_help
   puts 'Otherwise, enter a raw JSON-RPC request to send directly'
 end
 
-# Initialize and start the client
+# Initialize and start the client (only HTTP(S) endpoints are supported)
 client = ActionMCP.create_client(endpoint, logger: logger)
 
 # Start the transport

data/lib/action_mcp/client.rb

@@ -3,27 +3,21 @@
 module ActionMCP
   # Creates a client appropriate for the given endpoint.
   #
-  # @param endpoint [String] The endpoint to connect to (URL or command).
+  # @param endpoint [String] The endpoint to connect to (URL).
   # @param logger [Logger] The logger to use. Default is Logger.new($stdout).
   # @param options [Hash] Additional options to pass to the client constructor.
   #
-  # @return [Client::SSEClient, Client::StdioClient] An instance of either SSEClient or StdioClient
-  #   depending on the format of the endpoint.
+  # @return [Client::SSEClient] An instance of SSEClient for HTTP(S) endpoints.
   #
   # @example
   #   client = ActionMCP.create_client("http://127.0.0.1:3001/action_mcp")
   #   client.connect
-  #
-  # @example
-  #   client = ActionMCP.create_client("some_command")
-  #   client.execute
   def self.create_client(endpoint, logger: Logger.new($stdout), **options)
     if endpoint =~ %r{\Ahttps?://}
       logger.info("Creating SSE client for endpoint: #{endpoint}")
       Client::SSEClient.new(endpoint, logger: logger, **options)
     else
-      logger.info("Creating STDIO client for command: #{endpoint}")
-      Client::StdioClient.new(endpoint, logger: logger, **options)
+      raise ArgumentError, "Only HTTP(S) endpoints are supported. STDIO and other transports are not supported."
     end
   end
 

data/lib/action_mcp/configuration.rb

@@ -22,8 +22,7 @@ module ActionMCP
                   :logging_level,
                   :active_profile,
                   :profiles,
-                  # --- New Transport Options ---
-                  :mcp_endpoint_path,
+                  # --- Transport Options ---
                   :sse_heartbeat_interval,
                   :post_response_preference, # :json or :sse
                   :protocol_version,
@@ -40,10 +39,9 @@ module ActionMCP
       @active_profile = :primary
       @profiles = default_profiles
 
-      @mcp_endpoint_path = "/mcp"
       @sse_heartbeat_interval = 30
       @post_response_preference = :json
-      @protocol_version = "2024-11-05"
+      @protocol_version = "2025-03-26"
 
       # Resumability defaults
       @enable_sse_resumability = true

data/lib/action_mcp/engine.rb

@@ -21,7 +21,7 @@ module ActionMCP
       ActionMCP::ResourceTemplate.registered_templates.clear
     end
 
-    config.middleware.use JSONRPC_Rails::Middleware::Validator, [ ActionMCP.configuration.mcp_endpoint_path ]
+    config.middleware.use JSONRPC_Rails::Middleware::Validator, [ "/" ]
 
     # Load MCP profiles during initialization
     initializer "action_mcp.load_profiles" do

data/lib/action_mcp/tool.rb

@@ -60,14 +60,10 @@ module ActionMCP
         annotate(:readOnly, enabled)
       end
 
-      # Return annotations based on protocol version
+      # Return annotations for the tool
       def annotations_for_protocol(protocol_version = nil)
-        # Only include annotations for 2025+ protocols
-        if protocol_version.nil? || protocol_version == "2024-11-05"
-          {}
-        else
-          _annotations
-        end
+        # Always include annotations now that we only support 2025+
+        _annotations
       end
     end
 

data/lib/action_mcp/version.rb

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

data/lib/action_mcp.rb

@@ -34,11 +34,25 @@ module ActionMCP
   require_relative "action_mcp/version"
   require_relative "action_mcp/client"
   include Logging
-  PROTOCOL_VERSION = "2024-11-05"  # Default version
-  CURRENT_VERSION = "2025-03-26"   # Current version for the /mcp endpoint
-  SUPPORTED_VERSIONS = %w[2024-11-05 2025-03-26].freeze
+  PROTOCOL_VERSION = "2025-03-26"  # Default version
+  CURRENT_VERSION = "2025-03-26"   # Current version
+  SUPPORTED_VERSIONS = %w[2025-03-26].freeze
   class << self
-    delegate :server, to: "ActionMCP::Server"
+    # Returns a Rack-compatible application for serving MCP requests
+    # This makes ActionMCP.server work similar to ActionCable.server
+    # @return [#call] A Rack application that can be used with `run ActionMCP.server`
+    def server
+      @server ||= begin
+        # Initialize the actual server for PubSub.
+        # The return value is intentionally discarded as only the side effects are needed.
+        Server.server
+
+        # Return the Engine as the Rack application
+        # The Engine will handle routing to the UnifiedController
+        Engine
+      end
+    end
+
     # Returns the configuration instance.
     #
     # @return [Configuration] the configuration instance

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.33.0
+  version: 0.50.1
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -106,8 +106,6 @@ files:
 - README.md
 - Rakefile
 - app/controllers/action_mcp/mcp_controller.rb
-- app/controllers/action_mcp/messages_controller.rb
-- app/controllers/action_mcp/sse_controller.rb
 - app/controllers/action_mcp/unified_controller.rb
 - app/models/action_mcp.rb
 - app/models/action_mcp/application_record.rb
@@ -119,14 +117,7 @@ files:
 - app/models/concerns/mcp_console_helpers.rb
 - app/models/concerns/mcp_message_inspect.rb
 - config/routes.rb
-- db/migrate/20250308122801_create_action_mcp_sessions.rb
-- db/migrate/20250314230152_add_is_ping_to_session_message.rb
-- db/migrate/20250316005021_create_action_mcp_session_subscriptions.rb
-- db/migrate/20250316005649_create_action_mcp_session_resources.rb
-- db/migrate/20250324203409_remove_session_message_text.rb
-- db/migrate/20250327124131_add_sse_event_counter_to_action_mcp_sessions.rb
-- db/migrate/20250329120300_add_registries_to_sessions.rb
-- db/migrate/20250329150312_create_action_mcp_sse_events.rb
+- db/migrate/20250512154359_consolidated_migration.rb
 - exe/actionmcp_cli
 - lib/action_mcp.rb
 - lib/action_mcp/base_response.rb
@@ -147,7 +138,6 @@ files:
 - lib/action_mcp/client/roots.rb
 - lib/action_mcp/client/server.rb
 - lib/action_mcp/client/sse_client.rb
-- lib/action_mcp/client/stdio_client.rb
 - lib/action_mcp/client/toolbox.rb
 - lib/action_mcp/client/tools.rb
 - lib/action_mcp/configuration.rb

data/app/controllers/action_mcp/messages_controller.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  class MessagesController < MCPController
-    REQUIRED_PROTOCOL_VERSION = "2024-11-05"
-
-    include Instrumentation::ControllerRuntime
-
-    # @route POST / (sse_in)
-    def create
-      handle_post_message(params, response)
-      head response.status
-    end
-
-    private
-
-    def transport_handler
-      Server::TransportHandler.new(mcp_session)
-    end
-
-    def json_rpc_handler
-      @json_rpc_handler ||= Server::JsonRpcHandler.new(transport_handler)
-    end
-
-    def handle_post_message(params, response)
-      filtered_params = filter_jsonrpc_params(params)
-      json_rpc_handler.call(filtered_params)
-      response.status = :accepted
-    rescue StandardError => _e
-      response.status = :bad_request
-    end
-
-    def mcp_session
-      @mcp_session ||= Session.find_or_create_by(id: params[:session_id])
-    end
-
-    def filter_jsonrpc_params(params)
-      # Valid JSON-RPC keys (both request and response)
-      valid_keys = %w[jsonrpc method params id result error]
-
-      params.to_h.slice(*valid_keys)
-    end
-  end
-end

data/app/controllers/action_mcp/sse_controller.rb

@@ -1,179 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  class SSEController < MCPController
-    REQUIRED_PROTOCOL_VERSION = "2024-11-05"
-
-    HEARTBEAT_INTERVAL = 30 # in seconds
-    INITIAL_CONNECTION_TIMEOUT = 5 # in seconds
-    include ActionController::Live
-
-    # @route GET /sse (sse_out)
-    def events
-      # Set headers for SSE
-      response.headers["X-Accel-Buffering"] = "no"
-      response.headers["Content-Type"] = "text/event-stream"
-      response.headers["Cache-Control"] = "no-cache"
-      response.headers["Connection"] = "keep-alive"
-
-      # Send the endpoint URL to the client
-      send_endpoint_event(sse_in_url)
-
-      Rails.logger.info "SSE: Starting connection for session: #{session_id}"
-
-      # Use Concurrent primitives for state management
-      message_received = Concurrent::AtomicBoolean.new
-      connection_active = Concurrent::AtomicBoolean.new
-      connection_active.make_true
-
-      begin
-        # Create SSE instance
-        sse = SSE.new(response.stream)
-
-        # Start the connection monitor using a proper scheduled task
-        timeout_task = Concurrent::ScheduledTask.execute(INITIAL_CONNECTION_TIMEOUT) do
-          unless message_received.true?
-            Rails.logger.warn "No message received within #{INITIAL_CONNECTION_TIMEOUT} seconds, closing connection for session: #{session_id}"
-            error = build_timeout_error
-            # Safely write error and close the stream
-            Concurrent::Promise.execute do
-              begin
-                sse.write(error)
-              rescue StandardError
-                nil
-              end
-              begin
-                response.stream.close
-              rescue StandardError
-                nil
-              end
-              connection_active.make_false
-            end
-          end
-        end
-
-        # Initialize the listener
-        listener = SSEListener.new(mcp_session)
-        listener_started = listener.start do |message|
-          message_received.make_true
-          sse.write(message)
-        end
-
-        unless listener_started
-          Rails.logger.error "Listener failed to activate for session: #{session_id}"
-          error = build_listener_error
-          sse.write(error)
-          connection_active.make_false
-          return
-        end
-
-        # Create a thread-safe flag to track if we should continue sending heartbeats
-        heartbeat_active = Concurrent::AtomicBoolean.new(true)
-
-        # Setup recurring heartbeat using ScheduledTask with proper cancellation
-        heartbeat_task = nil
-        heartbeat_sender = lambda do
-          if connection_active.true? && !response.stream.closed?
-            begin
-              # Try to send heartbeat with a controlled execution time
-              future = Concurrent::Promises.future do
-                ping_request = JSON_RPC::Request.new(
-                  id: SecureRandom.uuid_v7, # Generate a unique ID for each ping
-                  method: "ping"
-                ).to_h
-                sse.write(ping_request)
-              end
-
-              # Wait for the heartbeat with timeout
-              future.value(5) # 5 second timeout
-
-              # Schedule the next heartbeat if this one succeeded
-              if heartbeat_active.true?
-                heartbeat_task = Concurrent::ScheduledTask.execute(HEARTBEAT_INTERVAL, &heartbeat_sender)
-              end
-            rescue Concurrent::TimeoutError
-              Rails.logger.warn "SSE: Heartbeat timed out, closing connection"
-              connection_active.make_false
-            rescue StandardError => e
-              Rails.logger.debug "SSE: Heartbeat error: #{e.message}"
-              connection_active.make_false
-            end
-          else
-            heartbeat_active.make_false
-          end
-        end
-
-        # Start the first heartbeat
-        heartbeat_task = Concurrent::ScheduledTask.execute(HEARTBEAT_INTERVAL, &heartbeat_sender)
-
-        # Wait for connection to be closed or cancelled
-        sleep 0.1 while connection_active.true? && !response.stream.closed?
-      rescue ActionController::Live::ClientDisconnected, IOError => e
-        Rails.logger.debug "SSE: Client disconnected: #{e.message}"
-      rescue StandardError => e
-        Rails.logger.error "SSE: Unexpected error: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
-      ensure
-        # Clean up resources
-        timeout_task&.cancel
-        heartbeat_active&.make_false  # Signal to stop scheduling new heartbeats
-        heartbeat_task&.cancel        # Cancel any pending heartbeat task
-        listener&.stop
-        begin
-          mcp_session.close!
-        rescue StandardError
-          nil
-        end
-        begin
-          response.stream.close
-        rescue StandardError
-          nil
-        end
-
-        Rails.logger.debug "SSE: Connection cleaned up for session: #{session_id}"
-      end
-    end
-
-    private
-
-    def build_timeout_error
-      JSON_RPC::Response.new(
-        id: SecureRandom.uuid_v7,
-        error: JSON_RPC::JsonRpcError.new(
-          :server_error,
-          message: "No message received within initial connection timeout"
-        ).to_h
-      ).to_h
-    end
-
-    def build_listener_error
-      JSON_RPC::Response.new(
-        id: SecureRandom.uuid_v7,
-        error: JSON_RPC::JsonRpcError.new(
-          :server_error,
-          message: "Failed to establish server connection"
-        ).to_h
-      ).to_h
-    end
-
-    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.new
-    end
-
-    def session_id
-      mcp_session.id
-    end
-
-    def cache_key
-      mcp_session.session_key
-    end
-  end
-end

data/db/migrate/20250308122801_create_action_mcp_sessions.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-class CreateActionMCPSessions < ActiveRecord::Migration[8.0]
-  def change
-    create_table :action_mcp_sessions, id: :string do |t|
-      t.string :role, null: false, default: 'server', comment: 'The role of the session'
-      t.string :status, null: false, default: 'pre_initialize'
-      t.datetime :ended_at, comment: 'The time the session ended'
-      t.string :protocol_version
-      t.jsonb :server_capabilities, comment: 'The capabilities of the server'
-      t.jsonb :client_capabilities, comment: 'The capabilities of the client'
-      t.jsonb :server_info, comment: 'The information about the server'
-      t.jsonb :client_info, comment: 'The information about the client'
-      t.boolean :initialized, null: false, default: false
-      t.integer :messages_count, null: false, default: 0
-      t.timestamps
-    end
-
-    create_table :action_mcp_session_messages do |t|
-      t.references :session, null: false, foreign_key: { to_table: :action_mcp_sessions,
-                                                         on_delete: :cascade,
-                                                         on_update: :cascade,
-                                                         name: 'fk_action_mcp_session_messages_session_id' }, type: :string
-      t.string :direction, null: false, comment: 'The session direction', default: 'client'
-      t.string :message_type, null: false, comment: 'The type of the message'
-      t.string :jsonrpc_id
-      t.string :message_text
-      t.jsonb :message_json
-      t.timestamps
-    end
-  end
-end

data/db/migrate/20250314230152_add_is_ping_to_session_message.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-class AddIsPingToSessionMessage < ActiveRecord::Migration[8.0]
-  def change
-    add_column :action_mcp_session_messages, :is_ping, :boolean, default: false, null: false
-    add_column :action_mcp_session_messages, :ping_acknowledged, :boolean, default: false, null: false
-  end
-end

data/db/migrate/20250316005021_create_action_mcp_session_subscriptions.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-class CreateActionMCPSessionSubscriptions < ActiveRecord::Migration[8.0]
-  def change
-    create_table :action_mcp_session_subscriptions do |t|
-      t.references :session,
-                   null: false,
-                   foreign_key: { to_table: :action_mcp_sessions, on_delete: :cascade },
-                   type: :string
-      t.string :uri, null: false
-      t.datetime :last_notification_at
-
-      t.timestamps
-    end
-  end
-end

data/db/migrate/20250316005649_create_action_mcp_session_resources.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-class CreateActionMCPSessionResources < ActiveRecord::Migration[8.0]
-  def change
-    create_table :action_mcp_session_resources do |t|
-      t.references :session,
-                   null: false,
-                   foreign_key: { to_table: :action_mcp_sessions, on_delete: :cascade },
-                   type: :string
-      t.string :uri, null: false
-      t.string :name
-      t.text :description
-      t.string :mime_type, null: false
-      t.boolean :created_by_tool, default: false
-      t.datetime :last_accessed_at
-      t.json :metadata
-
-      t.timestamps
-    end
-    change_column_comment :action_mcp_session_messages, :direction, 'The message recipient'
-    change_column_comment :action_mcp_session_messages, :is_ping, 'Whether the message is a ping'
-    rename_column :action_mcp_session_messages, :ping_acknowledged, :request_acknowledged
-    add_column :action_mcp_session_messages, :request_cancelled, :boolean, null: false, default: false
-  end
-end

data/db/migrate/20250324203409_remove_session_message_text.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-class RemoveSessionMessageText < ActiveRecord::Migration[8.0]
-  def up
-    remove_column :action_mcp_session_messages, :message_text
-  end
-end

data/db/migrate/20250327124131_add_sse_event_counter_to_action_mcp_sessions.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-class AddSSEEventCounterToActionMCPSessions < ActiveRecord::Migration[8.0]
-  def change
-    add_column :action_mcp_sessions, :sse_event_counter, :integer, default: 0, null: false
-  end
-end

data/db/migrate/20250329120300_add_registries_to_sessions.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class AddRegistriesToSessions < ActiveRecord::Migration[8.0]
-  def change
-    add_column :action_mcp_sessions, :tool_registry, :jsonb, default: []
-    add_column :action_mcp_sessions, :prompt_registry, :jsonb, default: []
-    add_column :action_mcp_sessions, :resource_registry, :jsonb, default: []
-  end
-end

data/db/migrate/20250329150312_create_action_mcp_sse_events.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-class CreateActionMCPSSEEvents < ActiveRecord::Migration[8.0]
-  def change
-    create_table :action_mcp_sse_events do |t|
-      t.references :session, null: false, foreign_key: { to_table: :action_mcp_sessions }, index: true, type: :string
-      t.integer :event_id, null: false
-      t.text :data, null: false
-      t.timestamps
-
-      # Index for efficiently retrieving events after a given ID for a specific session
-      t.index [ :session_id, :event_id ], unique: true
-      t.index :created_at # For cleanup of old events
-    end
-  end
-end

data/lib/action_mcp/client/stdio_client.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-
-module ActionMCP
-  module Client
-    # MCP client using Standard I/O (STDIO) transport, Not tested for now
-    class StdioClient < Base
-      def initialize(command, logger: ActionMCP.logger, **_options)
-        super(logger: logger)
-        @type = :stdio
-        @command = command
-        @threads_started = false
-        @received_server_message = false
-        @capabilities_sent = false
-      end
-
-      protected
-
-      def start_transport
-        setup_stdio_process
-        start_output_threads
-
-        # Just log that connection is established but don't send capabilities yet
-        if @threads_started && @wait_thr.alive?
-          log_debug("STDIO connection established")
-          true
-        else
-          log_debug("Failed to start STDIO threads or process is not alive")
-          false
-        end
-      end
-
-      def stop_transport
-        cleanup_resources
-      end
-
-      def send_message(json)
-        log_debug("\e[34m--> #{json}\e[0m")
-        @stdin.puts("#{json}\n\n")
-      end
-
-      def ready?
-        @received_server_message
-      end
-
-      private
-
-      def setup_stdio_process
-        @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(@command)
-      end
-
-      def start_output_threads
-        @stdout_thread = Thread.new do
-          @stdout.each_line do |line|
-            line = line.chomp
-            # Mark ready and send capabilities when we get any stdout
-            mark_ready_and_send_capabilities
-
-            # Continue with normal message handling
-            handle_raw_message(line)
-          end
-        end
-
-        @stderr_thread = Thread.new do
-          @stderr.each_line do |line|
-            line = line.chomp
-
-            # Check stderr for server messages
-            mark_ready_and_send_capabilities if line.include?("MCP Server") || line.include?("running on stdio")
-          end
-        end
-
-        @threads_started = true
-      end
-
-      # Mark the client as ready and send initial capabilities if not already sent
-      def mark_ready_and_send_capabilities
-        return if @received_server_message
-
-        @received_server_message = true
-        log_debug("Received first server message")
-
-        # Send initial capabilities if not already sent
-        return if @capabilities_sent
-
-        log_debug("Server is ready, sending initial capabilities...")
-        send_initial_capabilities
-        @capabilities_sent = true
-      end
-
-      def cleanup_resources
-        @stdin.close
-        wait_for_server_exit
-        cleanup_threads
-      end
-
-      def wait_for_server_exit
-        @wait_thr.join(0.5)
-        kill_server if @wait_thr.alive?
-      end
-
-      def kill_server
-        Process.kill("TERM", @wait_thr.pid)
-      rescue StandardError => e
-        log_error("Failed to kill server process: #{e}")
-      end
-
-      def cleanup_threads
-        @stdout_thread&.kill
-        @stderr_thread&.kill
-      end
-    end
-  end
-end