vector_mcp 0.3.3 → 0.4.0

data/lib/vector_mcp/transport/sse/message_handler.rb

@@ -1,166 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module VectorMCP
-  module Transport
-    class SSE
-      # Handles JSON-RPC message processing for POST requests.
-      # Processes incoming messages and sends responses via SSE streams.
-      class MessageHandler
-        # Initializes a new message handler.
-        #
-        # @param server [VectorMCP::Server] The MCP server instance
-        # @param session [VectorMCP::Session] The server session
-        # @param logger [Logger] Logger instance for debugging
-        def initialize(server, session, logger)
-          @server = server
-          @session = session
-          @logger = logger
-        end
-
-        # Handles a POST message request from a client.
-        #
-        # @param env [Hash] Rack environment hash
-        # @param client_conn [ClientConnection] The client connection
-        # @return [Array] Rack response triplet
-        def handle_post_message(env, client_conn)
-          request_body = read_request_body(env)
-          return error_response(nil, -32_600, "Request body is empty") if request_body.nil? || request_body.empty?
-
-          message = parse_json_message(request_body, client_conn)
-          return message if message.is_a?(Array) # Error response
-
-          process_message(message, client_conn)
-        rescue VectorMCP::ProtocolError => e
-          @logger.error { "Protocol error for client #{client_conn.session_id}: #{e.message}" }
-          request_id = e.request_id || message&.dig("id")
-          enqueue_error_response(client_conn, request_id, e.code, e.message, e.details)
-          error_response(request_id, e.code, e.message, e.details)
-        rescue StandardError => e
-          @logger.error { "Unexpected error for client #{client_conn.session_id}: #{e.message}\n#{e.backtrace.join("\n")}" }
-          request_id = message&.dig("id")
-          enqueue_error_response(client_conn, request_id, -32_603, "Internal server error")
-          error_response(request_id, -32_603, "Internal server error")
-        end
-
-        private
-
-        # Reads the request body from the Rack environment.
-        #
-        # @param env [Hash] Rack environment
-        # @return [String, nil] Request body as string
-        def read_request_body(env)
-          input = env["rack.input"]
-          return nil unless input
-
-          body = input.read
-          input.rewind if input.respond_to?(:rewind)
-          body
-        end
-
-        # Parses JSON message from request body.
-        #
-        # @param body_str [String] JSON string from request body
-        # @param client_conn [ClientConnection] Client connection for error handling
-        # @return [Hash, Array] Parsed message or error response triplet
-        def parse_json_message(body_str, client_conn)
-          JSON.parse(body_str)
-        rescue JSON::ParserError => e
-          @logger.error { "JSON parse error for client #{client_conn.session_id}: #{e.message}" }
-          malformed_id = VectorMCP::Util.extract_id_from_invalid_json(body_str)
-          enqueue_error_response(client_conn, malformed_id, -32_700, "Parse error")
-          error_response(malformed_id, -32_700, "Parse error")
-        end
-
-        # Processes a valid JSON-RPC message.
-        #
-        # @param message [Hash] Parsed JSON-RPC message
-        # @param client_conn [ClientConnection] Client connection
-        # @return [Array] Rack response triplet
-        def process_message(message, client_conn)
-          # Handle the message through the server
-          response_data = @server.handle_message(message, @session, client_conn.session_id)
-
-          # If it's a request (has id), send response via SSE
-          if message["id"]
-            enqueue_success_response(client_conn, message["id"], response_data)
-          else
-            @logger.debug { "Processed notification for client #{client_conn.session_id}" }
-          end
-
-          # Always return 202 Accepted for valid POST messages
-          success_response(message["id"])
-        end
-
-        # Enqueues a successful response to the client's SSE stream.
-        #
-        # @param client_conn [ClientConnection] Client connection
-        # @param request_id [String, Integer] Original request ID
-        # @param result [Object] Response result data
-        def enqueue_success_response(client_conn, request_id, result)
-          response = {
-            jsonrpc: "2.0",
-            id: request_id,
-            result: result
-          }
-          StreamManager.enqueue_message(client_conn, response)
-        end
-
-        # Enqueues an error response to the client's SSE stream.
-        #
-        # @param client_conn [ClientConnection] Client connection
-        # @param request_id [String, Integer, nil] Original request ID
-        # @param code [Integer] Error code
-        # @param message [String] Error message
-        # @param data [Object, nil] Additional error data
-        def enqueue_error_response(client_conn, request_id, code, message, data = nil)
-          error_payload = { code: code, message: message }
-          error_payload[:data] = data if data
-
-          error_response = {
-            jsonrpc: "2.0",
-            id: request_id,
-            error: error_payload
-          }
-          StreamManager.enqueue_message(client_conn, error_response)
-        end
-
-        # Creates a successful HTTP response for the POST request.
-        #
-        # @param request_id [String, Integer, nil] Request ID
-        # @return [Array] Rack response triplet
-        def success_response(request_id)
-          body = { status: "accepted", id: request_id }.to_json
-          [202, { "Content-Type" => "application/json" }, [body]]
-        end
-
-        # Creates an error HTTP response for the POST request.
-        #
-        # @param id [String, Integer, nil] Request ID
-        # @param code [Integer] Error code
-        # @param message [String] Error message
-        # @param data [Object, nil] Additional error data
-        # @return [Array] Rack response triplet
-        def error_response(id, code, message, data = nil)
-          status = case code
-                   when -32_700, -32_600, -32_602 then 400 # Parse, Invalid Request, Invalid Params
-                   when -32_601, -32_001 then 404 # Method Not Found, Not Found
-                   else 500 # Internal Error, Server Error
-                   end
-
-          error_payload = { code: code, message: message }
-          error_payload[:data] = data if data
-
-          body = {
-            jsonrpc: "2.0",
-            id: id,
-            error: error_payload
-          }.to_json
-
-          [status, { "Content-Type" => "application/json" }, [body]]
-        end
-      end
-    end
-  end
-end

data/lib/vector_mcp/transport/sse/puma_config.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module VectorMCP
-  module Transport
-    class SSE
-      # Configures Puma server for production-ready SSE transport.
-      # Handles server setup, threading, and resource management.
-      class PumaConfig
-        attr_reader :host, :port, :logger
-
-        # Initializes Puma configuration.
-        #
-        # @param host [String] Host to bind to
-        # @param port [Integer] Port to listen on
-        # @param logger [Logger] Logger instance
-        def initialize(host, port, logger)
-          @host = host
-          @port = port
-          @logger = logger
-        end
-
-        # Configures a Puma server instance.
-        #
-        # @param server [Puma::Server] The Puma server to configure
-        def configure(server)
-          server.add_tcp_listener(host, port)
-
-          # Configure threading for production use
-          configure_threading(server)
-
-          # Set up server options
-          configure_server_options(server)
-
-          logger.debug { "Puma server configured for #{host}:#{port}" }
-        end
-
-        private
-
-        # Configures threading parameters for optimal performance.
-        #
-        # @param server [Puma::Server] The Puma server
-        def configure_threading(server)
-          # Set thread pool size based on CPU cores and expected load
-          min_threads = 2
-          max_threads = [4, Etc.nprocessors * 2].max
-
-          # Puma 6.x does not expose min_threads= and max_threads= as public API.
-          # Thread pool sizing should be set via Puma DSL/config before server creation.
-          # For legacy compatibility, set if possible, otherwise log a warning.
-          if server.respond_to?(:min_threads=) && server.respond_to?(:max_threads=)
-            server.min_threads = min_threads
-            server.max_threads = max_threads
-            logger.debug { "Puma configured with #{min_threads}-#{max_threads} threads" }
-          else
-            logger.warn { "Puma::Server does not support direct thread pool sizing; set threads via Puma config DSL before server creation." }
-          end
-        end
-
-        # Configures server-specific options.
-        #
-        # @param server [Puma::Server] The Puma server
-        def configure_server_options(server)
-          # Set server-specific options for SSE handling
-          server.leak_stack_on_error = false if server.respond_to?(:leak_stack_on_error=)
-
-          # Configure timeouts appropriate for SSE connections
-          # SSE connections should be long-lived, so we set generous timeouts
-          if server.respond_to?(:first_data_timeout=)
-            server.first_data_timeout = 30 # 30 seconds to send first data
-          end
-
-          logger.debug { "Puma server options configured for SSE transport" }
-        end
-      end
-    end
-  end
-end

data/lib/vector_mcp/transport/sse/stream_manager.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module VectorMCP
-  module Transport
-    class SSE
-      # Manages Server-Sent Events streaming for client connections.
-      # Handles creation of streaming responses and message broadcasting.
-      class StreamManager
-        class << self
-          # Creates an SSE streaming response body for a client connection.
-          #
-          # @param client_conn [ClientConnection] The client connection to stream to
-          # @param endpoint_url [String] The URL for the client to POST messages to
-          # @param logger [Logger] Logger instance for debugging
-          # @return [Enumerator] Rack-compatible streaming response body
-          def create_sse_stream(client_conn, endpoint_url, logger)
-            Enumerator.new do |yielder|
-              # Send initial endpoint event
-              yielder << format_sse_event("endpoint", endpoint_url)
-              logger.debug { "Sent endpoint event to client #{client_conn.session_id}: #{endpoint_url}" }
-
-              # Start streaming thread for this client
-              client_conn.stream_thread = Thread.new do
-                stream_messages_to_client(client_conn, yielder, logger)
-              end
-
-              # Keep the connection alive by yielding from the streaming thread
-              client_conn.stream_thread.join
-            rescue StandardError => e
-              logger.error { "Error in SSE stream for client #{client_conn.session_id}: #{e.message}\n#{e.backtrace.join("\n")}" }
-            ensure
-              logger.debug { "SSE stream ended for client #{client_conn.session_id}" }
-              client_conn.close
-            end
-          end
-
-          # Enqueues a message to a specific client connection.
-          #
-          # @param client_conn [ClientConnection] The target client connection
-          # @param message [Hash] The JSON-RPC message to send
-          # @return [Boolean] true if message was enqueued successfully
-          def enqueue_message(client_conn, message)
-            return false unless client_conn && !client_conn.closed?
-
-            client_conn.enqueue_message(message)
-          end
-
-          private
-
-          # Streams messages from a client's queue to the SSE connection.
-          # This method runs in a dedicated thread per client.
-          #
-          # @param client_conn [ClientConnection] The client connection
-          # @param yielder [Enumerator::Yielder] The response yielder
-          # @param logger [Logger] Logger instance
-          def stream_messages_to_client(client_conn, yielder, logger)
-            logger.debug { "Starting message streaming thread for client #{client_conn.session_id}" }
-
-            loop do
-              message = client_conn.dequeue_message
-              break if message.nil? # Queue closed or connection closed
-
-              begin
-                json_message = message.to_json
-                sse_data = format_sse_event("message", json_message)
-                yielder << sse_data
-
-                logger.debug { "Streamed message to client #{client_conn.session_id}: #{json_message}" }
-              rescue StandardError => e
-                logger.error { "Error streaming message to client #{client_conn.session_id}: #{e.message}" }
-                break
-              end
-            end
-
-            logger.debug { "Message streaming thread ended for client #{client_conn.session_id}" }
-          rescue StandardError => e
-            logger.error { "Fatal error in streaming thread for client #{client_conn.session_id}: #{e.message}\n#{e.backtrace.join("\n")}" }
-          end
-
-          # Formats data as a Server-Sent Event.
-          #
-          # @param event [String] The event type
-          # @param data [String] The event data
-          # @return [String] Properly formatted SSE event
-          def format_sse_event(event, data)
-            "event: #{event}\ndata: #{data}\n\n"
-          end
-        end
-      end
-    end
-  end
-end