actionmcp 0.32.1 → 0.50.0

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