actionmcp 0.102.0 → 0.103.0

data/lib/action_mcp/client/streamable_client.rb

@@ -1,264 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # MCP client using Server-Sent Events (SSE) transport
-    class StreamableClient < Base
-      # Define a custom error class for connection issues
-      class ConnectionError < StandardError; end
-
-      SSE_TIMEOUT = 10
-      ENDPOINT_TIMEOUT = 5 # Seconds
-
-      attr_reader :base_url, :sse_path, :post_url, :session
-
-      def initialize(url, connect: true, logger: ActionMCP.logger, **_options)
-        gem "faraday", ">= 2.0"
-        require "faraday"
-        require "uri"
-        super(logger: logger)
-        @type = :sse
-        setup_connection(url)
-        @buffer = +""
-        @stop_requested = false
-        @endpoint_received = false
-        @endpoint_mutex = Mutex.new
-        @endpoint_condition = ConditionVariable.new
-        @connection_mutex = Mutex.new
-        @connection_condition = ConditionVariable.new
-
-        self.connect if connect
-      end
-
-      protected
-
-      def start_transport
-        log_debug("Connecting to #{@base_url}#{@sse_path}...")
-        @stop_requested = false
-
-        # Reset connection state before starting
-        @connection_mutex.synchronize do
-          @connected = false
-          @connection_error = nil
-        end
-
-        # Start connection thread
-        @sse_thread = Thread.new { listen_sse }
-
-        # Wait for endpoint
-        wait_for_endpoint
-      end
-
-      def stop_transport
-        log_debug("Stopping SSE connection...")
-        @stop_requested = true
-        cleanup_sse_thread
-      end
-
-      def send_message(json_rpc)
-        response = @conn.post(post_url,
-                              json_rpc,
-                              { "Content-Type" => "application/json" })
-        response.success?
-      end
-
-      def ready?
-        endpoint_ready?
-      end
-
-      private
-
-      def setup_connection(url)
-        uri = URI.parse(url)
-        @base_url = "#{uri.scheme}://#{uri.host}:#{uri.port}"
-        @sse_path = uri.path
-
-        @conn = Faraday.new(url: @base_url) do |f|
-          f.headers["User-Agent"] = user_agent
-          f.options.timeout = nil # No read timeout
-          f.options.open_timeout = SSE_TIMEOUT # Connection timeout
-
-          # Use Net::HTTP adapter explicitly as it works well with streaming
-          f.adapter :net_http do |http|
-            http.read_timeout = nil # No read timeout at adapter level too
-            http.open_timeout = SSE_TIMEOUT # Connection timeout
-          end
-        end
-
-        @post_url = nil
-      end
-
-      def wait_for_endpoint
-        success = false
-        error = nil
-
-        @endpoint_mutex.synchronize do
-          unless @endpoint_received
-            # Wait with timeout for endpoint
-            timeout = @endpoint_condition.wait(@endpoint_mutex, ENDPOINT_TIMEOUT)
-
-            # Handle timeout
-            unless timeout || @endpoint_received
-              error = "Timeout waiting for MCP endpoint (#{ENDPOINT_TIMEOUT} seconds)"
-            end
-          end
-
-          success = @endpoint_received
-        end
-
-        if error
-          log_error(error)
-          raise ConnectionError, error
-        end
-
-        # If we have the endpoint, consider the connection successful
-        if success
-          @connection_mutex.synchronize do
-            @connected = true
-            @connection_condition.broadcast
-          end
-        end
-
-        success
-      end
-
-      def endpoint_ready?
-        @endpoint_mutex.synchronize { @endpoint_received }
-      end
-
-      def listen_sse
-        log_debug("Starting SSE listener...")
-
-        begin
-          @conn.get(@sse_path) do |req|
-            req.headers["Accept"] = "text/event-stream"
-            req.headers["Cache-Control"] = "no-cache"
-
-            req.options.on_data = proc do |chunk, bytes|
-              handle_sse_data(chunk, bytes)
-            end
-          end
-
-          # This should never be reached during normal operation
-          # as the SSE connection stays open
-        rescue Faraday::ConnectionFailed => e
-          handle_connection_error(format_connection_error(e))
-        end
-      end
-
-      def format_connection_error(error)
-        if error.message.include?("Connection refused")
-          "Connection refused - server at #{@base_url} is not running or not accepting connections"
-        else
-          "Connection failed: #{error.message}"
-        end
-      end
-
-      def connection_error=(message)
-        @connection_mutex.synchronize do
-          @connection_error = message
-          @connection_condition.broadcast
-        end
-      end
-
-      def handle_connection_error(message)
-        log_error("SSE connection failed: #{message}")
-        self.connection_error = message
-        @connected = false
-        @error_callback&.call(StandardError.new(message))
-      end
-
-      def handle_sse_data(chunk, _overall_bytes)
-        process_chunk(chunk)
-        throw :halt if @stop_requested
-      end
-
-      def process_chunk(chunk)
-        @buffer << chunk
-        # If the buffer does not contain a newline but appears to be a complete JSON object,
-        # flush it as a complete event.
-        if @buffer.strip.match?(/^\{.*\}$/)
-          (@current_event ||= []) << @buffer.strip
-          @buffer = +""
-          return handle_complete_event
-        end
-        process_buffer while @buffer.include?("\n")
-      end
-
-      def process_buffer
-        line, _sep, rest = @buffer.partition("\n")
-        @buffer = rest
-
-        if line.strip.empty?
-          handle_complete_event
-        else
-          (@current_event ||= []) << line.strip
-        end
-      end
-
-      def handle_complete_event
-        return unless @current_event
-
-        handle_event(@current_event)
-        @current_event = nil
-      end
-
-      def handle_event(lines)
-        event_data = parse_event(lines)
-        process_event(event_data)
-      end
-
-      def parse_event(lines)
-        event_data = { type: "message", data: +"" }
-        has_data_prefix = false
-
-        lines.each do |line|
-          if line.start_with?("event:")
-            event_data[:type] = line.split(":", 2)[1].strip
-          elsif line.start_with?("data:")
-            has_data_prefix = true
-            event_data[:data] << line.split(":", 2)[1].strip
-          end
-        end
-
-        # If no "data:" prefix was found, treat the entire event as data
-        event_data[:data] = lines.join("\n") unless has_data_prefix
-        event_data
-      end
-
-      def process_event(event_data)
-        case event_data[:type]
-        when "endpoint" then set_post_endpoint(event_data[:data])
-        when "message" then handle_raw_message(event_data[:data])
-        else log_error("Unknown event type: #{event_data[:type]}")
-        end
-      end
-
-      def set_post_endpoint(endpoint_path)
-        @post_url = build_post_url(endpoint_path)
-        log_debug("Received POST endpoint: #{post_url}")
-
-        # Signal that we have received the endpoint
-        @endpoint_mutex.synchronize do
-          @endpoint_received = true
-          @endpoint_condition.broadcast
-        end
-
-        # Now that we have the endpoint, send initial capabilities
-        send_initial_capabilities
-      end
-
-      def build_post_url(endpoint_path)
-        URI.join(@base_url, endpoint_path).to_s
-      rescue StandardError
-        "#{@base_url}#{endpoint_path}"
-      end
-
-      def cleanup_sse_thread
-        return unless @sse_thread
-
-        @sse_thread.join(SSE_TIMEOUT) || @sse_thread.kill
-      end
-    end
-  end
-end

data/lib/action_mcp/client/streamable_http_transport.rb

@@ -1,306 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "transport"
-require_relative "session_store"
-
-module ActionMCP
-  module Client
-    # StreamableHTTP transport implementation following MCP specification
-    class StreamableHttpTransport < TransportBase
-      class ConnectionError < StandardError; end
-      class AuthenticationError < StandardError; end
-
-      SSE_TIMEOUT = 10
-      ENDPOINT_TIMEOUT = 5
-
-      attr_reader :session_id, :last_event_id, :protocol_version
-
-      def initialize(url, session_store:, session_id: nil, protocol_version: nil, **options)
-        super(url, session_store: session_store, **options)
-        @session_id = session_id
-        @protocol_version = protocol_version || ActionMCP::DEFAULT_PROTOCOL_VERSION
-        @negotiated_protocol_version = nil
-        @last_event_id = nil
-        @buffer = +""
-        @current_event = nil
-        @reconnect_attempts = 0
-        @max_reconnect_attempts = options[:max_reconnect_attempts] || 3
-        @reconnect_delay = options[:reconnect_delay] || 1.0
-
-        setup_http_client
-      end
-
-      def connect
-        log_debug("Connecting via StreamableHTTP to #{@url}")
-
-        # Load session if session_id provided
-        load_session_state if @session_id
-
-        # Start SSE stream if server supports it
-        start_sse_stream
-
-        # Set ready first, then connected (so transport is ready when on_connect fires)
-        set_ready(true)
-        set_connected(true)
-        log_debug("StreamableHTTP connection established")
-        true
-      rescue StandardError => e
-        handle_error(e)
-        false
-      end
-
-      def disconnect
-        return true unless connected?
-
-        log_debug("Disconnecting StreamableHTTP")
-        stop_sse_stream
-        save_session_state if @session_id
-        set_connected(false)
-        set_ready(false)
-        true
-      rescue StandardError => e
-        handle_error(e)
-        false
-      end
-
-      def send_message(message)
-        raise ConnectionError, "Transport not ready" unless ready?
-
-        headers = build_post_headers
-        json_data = message.is_a?(String) ? message : message.to_json
-
-        log_debug("Sending message via POST")
-        response = @http_client.post(@url, json_data, headers)
-
-        handle_post_response(response, message)
-        true
-      rescue StandardError => e
-        handle_error(e)
-        false
-      end
-
-      private
-
-      def setup_http_client
-        require "faraday"
-        @http_client = Faraday.new do |f|
-          f.headers["User-Agent"] = user_agent
-          f.options.timeout = nil # No read timeout for SSE
-          f.options.open_timeout = SSE_TIMEOUT
-          f.adapter :net_http
-        end
-      end
-
-      def build_get_headers
-        headers = {
-          "Accept" => "text/event-stream",
-          "Cache-Control" => "no-cache"
-        }
-        headers["mcp-session-id"] = @session_id if @session_id
-        headers["Last-Event-ID"] = @last_event_id if @last_event_id
-
-        # Add MCP-Protocol-Version header for GET requests when we have a negotiated version
-        headers["MCP-Protocol-Version"] = @negotiated_protocol_version if @negotiated_protocol_version
-
-        log_debug("Final GET headers: #{headers}")
-        headers
-      end
-
-      def build_post_headers
-        headers = {
-          "Content-Type" => "application/json",
-          "Accept" => "application/json, text/event-stream"
-        }
-        headers["mcp-session-id"] = @session_id if @session_id
-
-        # Add MCP-Protocol-Version header as per 2025-06-18 spec
-        # Only include when we have a negotiated version from previous handshake
-        headers["MCP-Protocol-Version"] = @negotiated_protocol_version if @negotiated_protocol_version
-
-        log_debug("Final POST headers: #{headers}")
-        headers
-      end
-
-      def start_sse_stream
-        log_debug("Starting SSE stream")
-        @sse_thread = Thread.new { run_sse_stream }
-      end
-
-      def stop_sse_stream
-        return unless @sse_thread
-
-        log_debug("Stopping SSE stream")
-        @stop_requested = true
-        @sse_thread.kill if @sse_thread.alive?
-        @sse_thread = nil
-        @stop_requested = false
-      end
-
-      def run_sse_stream
-        headers = build_get_headers
-
-        @http_client.get(@url, nil, headers) do |req|
-          req.options.on_data = proc do |chunk, _bytes|
-            break if @stop_requested
-
-            process_sse_chunk(chunk)
-          end
-        end
-      rescue StandardError => e
-        handle_sse_error(e)
-      end
-
-      def process_sse_chunk(chunk)
-        @buffer << chunk
-        process_complete_events while @buffer.include?("\n\n")
-      end
-
-      def process_complete_events
-        event_data, _separator, rest = @buffer.partition("\n\n")
-        @buffer = rest
-
-        return if event_data.strip.empty?
-
-        parse_sse_event(event_data)
-      end
-
-      def parse_sse_event(event_data)
-        lines = event_data.split("\n")
-        event_id = nil
-        data_lines = []
-
-        lines.each do |line|
-          if line.start_with?("id:")
-            event_id = line[3..].strip
-          elsif line.start_with?("data:")
-            data_lines << line[5..].strip
-          end
-        end
-
-        return if data_lines.empty?
-
-        @last_event_id = event_id if event_id
-
-        begin
-          message_data = data_lines.join("\n")
-          message = MultiJson.load(message_data)
-          handle_message(message)
-        rescue MultiJson::ParseError => e
-          log_error("Failed to parse SSE message: #{e}")
-        end
-      end
-
-      def handle_post_response(response, _original_message)
-        # Extract session ID from response headers
-        @session_id = response.headers["mcp-session-id"] if response.headers["mcp-session-id"]
-
-        case response.status
-        when 200
-          handle_success_response(response)
-        when 202
-          # Accepted - message received, no immediate response
-          log_debug("Message accepted (202)")
-        when 401
-          raise AuthenticationError, "Authentication required"
-        when 405
-          # Method not allowed - server doesn't support this operation
-          log_debug("Server returned 405 - operation not supported")
-        else
-          handle_error_response(response)
-        end
-      end
-
-      def handle_success_response(response)
-        content_type = response.headers["content-type"]
-
-        if content_type&.include?("application/json")
-          # Direct JSON response
-          handle_json_response(response)
-        elsif content_type&.include?("text/event-stream")
-          # SSE response stream
-          handle_sse_response_stream(response)
-        end
-      end
-
-      def handle_json_response(response)
-        message = MultiJson.load(response.body)
-
-        # Check if this is an initialize response to capture negotiated protocol version
-        if message.is_a?(Hash) && message["result"] && message["result"]["protocolVersion"]
-          @negotiated_protocol_version = message["result"]["protocolVersion"]
-          log_debug("Negotiated protocol version: #{@negotiated_protocol_version}")
-        end
-
-        handle_message(message)
-      rescue MultiJson::ParseError => e
-        log_error("Failed to parse JSON response: #{e}")
-      end
-
-      def handle_sse_response_stream(response)
-        # Handle SSE stream from POST response
-        response.body.each_line do |line|
-          process_sse_chunk(line)
-        end
-      end
-
-      def handle_error_response(response)
-        error_msg = +"HTTP #{response.status}: #{response.reason_phrase}"
-        error_msg << " - #{response.body}" if response.body && !response.body.empty?
-        raise ConnectionError, error_msg
-      end
-
-      def handle_sse_error(error)
-        log_error("SSE stream error: #{error.message}")
-
-        if should_reconnect?
-          schedule_reconnect
-        else
-          handle_error(error)
-        end
-      end
-
-      def should_reconnect?
-        connected? && @reconnect_attempts < @max_reconnect_attempts
-      end
-
-      def schedule_reconnect
-        @reconnect_attempts += 1
-        delay = @reconnect_delay * @reconnect_attempts
-
-        log_debug("Scheduling SSE reconnect in #{delay}s (attempt #{@reconnect_attempts})")
-
-        Thread.new do
-          sleep(delay)
-          start_sse_stream unless @stop_requested
-        end
-      end
-
-      def load_session_state
-        session_data = @session_store.load_session(@session_id)
-        return unless session_data
-
-        @last_event_id = session_data[:last_event_id]
-        log_debug("Loaded session state: last_event_id=#{@last_event_id}")
-      end
-
-      def save_session_state
-        return unless @session_id
-
-        session_data = {
-          id: @session_id,
-          last_event_id: @last_event_id,
-          session_data: {},
-          protocol_version: @protocol_version
-        }
-
-        @session_store.save_session(@session_id, session_data)
-        log_debug("Saved session state")
-      end
-
-
-      def user_agent
-        "ActionMCP-StreamableHTTP/#{ActionMCP.gem_version}"
-      end
-    end
-  end
-end

data/lib/action_mcp/client/test_session_store.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Test session store that tracks all operations for assertions
-    class TestSessionStore < VolatileSessionStore
-      attr_reader :operations, :saved_sessions, :loaded_sessions,
-                  :deleted_sessions, :updated_sessions
-
-      def initialize
-        super
-        @operations = Concurrent::Array.new
-        @saved_sessions = Concurrent::Array.new
-        @loaded_sessions = Concurrent::Array.new
-        @deleted_sessions = Concurrent::Array.new
-        @updated_sessions = Concurrent::Array.new
-      end
-
-      def load_session(session_id)
-        session = super
-        @operations << { type: :load, session_id: session_id, found: !session.nil? }
-        @loaded_sessions << session_id if session
-        session
-      end
-
-      def save_session(session_id, session_data)
-        super
-        @operations << { type: :save, session_id: session_id, data: session_data }
-        @saved_sessions << session_id
-      end
-
-      def delete_session(session_id)
-        result = super
-        @operations << { type: :delete, session_id: session_id }
-        @deleted_sessions << session_id
-        result
-      end
-
-      def update_session(session_id, attributes)
-        result = super
-        @operations << { type: :update, session_id: session_id, attributes: attributes }
-        @updated_sessions << session_id if result
-        result
-      end
-
-      # Test helper methods
-      def session_saved?(session_id)
-        @saved_sessions.include?(session_id)
-      end
-
-      def session_loaded?(session_id)
-        @loaded_sessions.include?(session_id)
-      end
-
-      def session_deleted?(session_id)
-        @deleted_sessions.include?(session_id)
-      end
-
-      def session_updated?(session_id)
-        @updated_sessions.include?(session_id)
-      end
-
-      def operation_count(type = nil)
-        if type
-          @operations.count { |op| op[:type] == type }
-        else
-          @operations.size
-        end
-      end
-
-      def last_saved_data(session_id)
-        @operations.reverse.find { |op| op[:type] == :save && op[:session_id] == session_id }&.dig(:data)
-      end
-
-      def reset_tracking!
-        @operations.clear
-        @saved_sessions.clear
-        @loaded_sessions.clear
-        @deleted_sessions.clear
-        @updated_sessions.clear
-      end
-    end
-  end
-end