actionmcp 0.50.13 → 0.51.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8cbc049b43ac92baf337a6700c1a31f3dc7a9a5bc6c63a245d845b26f40a6a4
-  data.tar.gz: e116ae134611daf77d0db8955325c4f3318ab27b7bec45ce77b1f4bdebdbc413
+  metadata.gz: 88b1f1dba04f05f96a9cf1c4ab928412400cb0a796d6635277924e57aa91a3c6
+  data.tar.gz: 163a43c7d4e3e247ba6f1084250e9452e9f36ee0e2ba2ee4a1d6fe67ca95f147
 SHA512:
-  metadata.gz: 0ca8d760b8758d6325da76b10ef9b94e76312538c1a0d4765a793944746f3f4b83bed4a843b9e0de6a5c10a4878e2cece3157386a056750fc9fe6d57543054b5
-  data.tar.gz: '0692acfc6b64ee7c3bb7047cc863dd2976e7aca7bb6c19e39a146ced044e1136c71364598f02b5cff9a3af803114a647692005150d758957c0db427366bed185'
+  metadata.gz: fae52dbb988f73cdcc4fa4678b12d352cdb151f1111c753a1210c37169b0b2d04dc53dbeafc092cd9dea6e6e5e2397672a7a1252982425f726f546427c52c327
+  data.tar.gz: 613a305bd349a425d6f7169566b160eeda391870a20b8f997d01b587e558ef50ca005947a5482d24db5c4846a53e136f00301ad9f648f0b0c5d92c7a58b998f6

data/app/models/action_mcp/session.rb

@@ -171,7 +171,11 @@ module ActionMCP
       )
 
       # Maintain cache limit by removing oldest events if needed
-      sse_events.order(event_id: :asc).limit(sse_events.count - max_events).destroy_all if sse_events.count > max_events
+      count = sse_events.count
+      excess = count - max_events
+      if excess.positive?
+        sse_events.order(event_id: :asc).limit(excess).delete_all
+      end
 
       event
     end

data/lib/action_mcp/client/base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "transport"
+
 module ActionMCP
   module Client
     # Base client class containing common MCP functionality
@@ -12,25 +14,20 @@ module ActionMCP
       include Roots
       include Logging
 
-      attr_reader :logger, :type,
+      attr_reader :logger, :transport,
                   :connection_error, :server,
                   :server_capabilities, :session,
                   :catalog, :blueprint,
                   :prompt_book, :toolbox
 
-      delegate :initialized?, to: :session
+      delegate :connected?, :ready?, to: :transport
 
-      def initialize(logger: ActionMCP.logger)
+      def initialize(transport:, logger: ActionMCP.logger, **options)
         @logger = logger
-        @connected = false
-        @session = Session.from_client.new(
-          protocol_version: PROTOCOL_VERSION,
-          client_info: client_info,
-          client_capabilities: client_capabilities
-        )
+        @transport = transport
+        @session = nil  # Session will be created/loaded based on server response
+        @session_id = options[:session_id]  # Optional session ID for resumption
         @server_capabilities = nil
-        @message_callback = nil
-        @error_callback = nil
         @connection_error = nil
         @initialized = false
 
@@ -42,148 +39,157 @@ module ActionMCP
         @prompt_book = PromptBook.new([], self)
         # Tool objects
         @toolbox = Toolbox.new([], self)
-      end
 
-      def connected?
-        @connected
+        setup_transport_callbacks
       end
 
-      # Connect to the MCP server, if something went wrong at initialization
+      # Connect to the MCP server
       def connect
-        return true if @connected
+        return true if connected?
 
         begin
-          log_debug("Connecting to MCP server...")
+          log_debug("Connecting to MCP server via #{transport.class.name}...")
           @connection_error = nil
 
-          # Start transport with proper error handling
-          success = start_transport
-
+          success = @transport.connect
           unless success
-            log_error("Failed to establish connection to MCP server")
+            log_error("Failed to establish transport connection")
             return false
           end
 
-          @connected = true
           log_debug("Connected to MCP server")
-
-          # Create handler only if it doesn't exist yet
-          @json_rpc_handler ||= JsonRpcHandler.new(session, self)
-
-          # Clear any existing message callback and set a new one
-          @message_callback = lambda do |response|
-            @json_rpc_handler.call(response)
-          end
-
           true
         rescue StandardError => e
           @connection_error = e.message
           log_error("Failed to connect to MCP server: #{e.message}")
-          @error_callback&.call(e)
           false
         end
       end
 
       # Disconnect from the MCP server
       def disconnect
-        return true unless @connected
+        return true unless connected?
 
         begin
-          stop_transport
-          @connected = false
+          @transport.disconnect
           log_debug("Disconnected from MCP server")
           true
         rescue StandardError => e
           log_error("Error disconnecting from MCP server: #{e.message}")
-          @error_callback&.call(e)
           false
         end
       end
 
-      # Set a callback for incoming messages
-      def on_message(&block)
-        @message_callback = block
-      end
-
-      # Set a callback for errors
-      def on_error(&block)
-        @error_callback = block
-      end
-
       # Send a request to the MCP server
       def write_message(payload)
-        unless @connected
-          log_error("Cannot send request - not connected")
+        unless ready?
+          log_error("Cannot send request - transport not ready")
           return false
         end
 
         begin
-          session.write(payload)
+          # Only write to session if it exists (after initialization)
+          session.write(payload) if session
           data = payload.to_json unless payload.is_a?(String)
-          send_message(data)
+          @transport.send_message(data)
           true
         rescue StandardError => e
           log_error("Failed to send request: #{e.message}")
-          @error_callback&.call(e)
           false
         end
       end
 
-      # Methods to be implemented by subclasses
-      def start_transport
-        raise NotImplementedError, "#{self.class} must implement #start_transport"
-      end
-
-      def stop_transport
-        raise NotImplementedError, "#{self.class} must implement #stop_transport"
-      end
-
-      def send_message(json)
-        raise NotImplementedError, "#{self.class} must implement #send_message"
-      end
-
-      def ready?
-        raise NotImplementedError, "#{self.class} must implement #ready?"
-      end
-
       def server=(server)
         @server = if server.is_a?(Client::Server)
                     server
         else
                     Client::Server.new(server)
         end
-        session.server_capabilities = server.capabilities
-        session.server_info = server.server_info
-        session.save
+
+        # Only update session if it exists
+        if @session
+          @session.server_capabilities = server.capabilities
+          @session.server_info = server.server_info
+          @session.save
+        end
+      end
+
+      def initialized?
+        @initialized && @session&.initialized?
       end
 
       def inspect
-        "#<#{self.class.name} server: #{server}, client_name: #{client_info[:name]}, client_version: #{client_info[:version]}, capabilities: #{client_capabilities} , connected: #{connected?}, initialized: #{initialized?}, session: #{session.id}>"
+        session_info = @session ? "session: #{@session.id}" : "session: none"
+        "#<#{self.class.name} transport: #{transport.class.name}, server: #{server}, client_name: #{client_info[:name]}, client_version: #{client_info[:version]}, capabilities: #{client_capabilities}, connected: #{connected?}, initialized: #{initialized?}, #{session_info}>"
       end
 
       protected
 
+      def setup_transport_callbacks
+        # Create JSON-RPC handler
+        @json_rpc_handler = JsonRpcHandler.new(session, self)
+
+        # Set up transport callbacks
+        @transport.on_message do |message|
+          handle_raw_message(message)
+        end
+
+        @transport.on_error do |error|
+          handle_transport_error(error)
+        end
+
+        @transport.on_connect do
+          handle_transport_connect
+        end
+
+        @transport.on_disconnect do
+          handle_transport_disconnect
+        end
+      end
+
       def handle_raw_message(raw)
-        @message_callback&.call(raw)
+        @json_rpc_handler.call(raw)
       rescue MultiJson::ParseError => e
         log_error("JSON parse error: #{e} (raw: #{raw})")
-        @error_callback&.call(e)
       rescue StandardError => e
         log_error("Error handling message: #{e} (raw: #{raw})")
-        @error_callback&.call(e)
+      end
+
+      def handle_transport_error(error)
+        @connection_error = error.message
+        log_error("Transport error: #{error.message}")
+      end
+
+      def handle_transport_connect
+        log_debug("Transport connected")
+        # Send initial capabilities after connection
+        send_initial_capabilities
+      end
+
+      def handle_transport_disconnect
+        log_debug("Transport disconnected")
       end
 
       def send_initial_capabilities
         log_debug("Sending client capabilities")
-        # We have contact! Let's send our CV to the recruiter.
-        # We persist the session object to the database
-        session.save
+
+        # If we have a session_id, we're trying to resume
+        if @session_id
+          log_debug("Attempting to resume session: #{@session_id}")
+        end
+
         params = {
-          protocolVersion: session.protocol_version,
-          capabilities: session.client_capabilities,
-          clientInfo: session.client_info
+          protocolVersion: PROTOCOL_VERSION,
+          capabilities: client_capabilities,
+          clientInfo: client_info
         }
-        send_jsonrpc_request("initialize", params: params, id: session.id)
+
+        # Include session_id if we're trying to resume
+        params[:sessionId] = @session_id if @session_id
+
+        # Use a unique request ID (not session ID since we don't have one yet)
+        request_id = SecureRandom.uuid
+        send_jsonrpc_request("initialize", params: params, id: request_id)
       end
 
       def client_capabilities

data/lib/action_mcp/client/json_rpc_handler.rb

@@ -70,13 +70,16 @@ module ActionMCP
       end
 
       def process_response(id, result)
-        if transport.id == id
-          ## This initializes the transport
-          client.server = Client::Server.new(result)
+        # Check if this is a response to an initialize request
+        # We need to check the actual request method, not just compare IDs
+        request = client.session ? transport.messages.requests.find_by(jsonrpc_id: id) : nil
+
+        # If no session yet, this might be the initialize response
+        if !client.session && result["serverInfo"]
+          handle_initialize_response(id, result)
           return send_initialized_notification
         end
 
-        request = transport.messages.requests.find_by(jsonrpc_id: id)
         return unless request
 
         # Mark the request as acknowledged
@@ -113,8 +116,42 @@ module ActionMCP
         puts "\e[31mUnknown error: #{id} #{error}\e[0m"
       end
 
+      def handle_initialize_response(request_id, result)
+        # Session ID comes from HTTP headers, not the response body
+        # The transport should have already extracted it
+        session_id = transport.instance_variable_get(:@session_id)
+
+        if session_id.nil?
+          client.log_error("No session ID received from server")
+          return
+        end
+
+        # Check if we're resuming an existing session
+        if client.instance_variable_get(:@session_id) && session_id == client.instance_variable_get(:@session_id)
+          # We're resuming an existing session
+          client.instance_variable_set(:@session, ActionMCP::Session.find(session_id))
+          client.log_info("Resumed existing session: #{session_id}")
+        else
+          # Create a new session with the server-provided ID
+          client.instance_variable_set(:@session, ActionMCP::Session.from_client.new(
+            id: session_id,
+            protocol_version: result["protocolVersion"] || PROTOCOL_VERSION,
+            client_info: client.client_info,
+            client_capabilities: client.client_capabilities,
+            server_info: result["serverInfo"],
+            server_capabilities: result["capabilities"]
+          ))
+          client.session.save
+          client.log_info("Created new session: #{session_id}")
+        end
+
+        # Set the server info
+        client.server = Client::Server.new(result)
+        client.instance_variable_set(:@initialized, true)
+      end
+
       def send_initialized_notification
-        transport.initialize!
+        transport.initialize! if transport.respond_to?(:initialize!)
         client.send_jsonrpc_notification("notifications/initialized")
       end
     end

data/lib/action_mcp/client/session_store.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    # Abstract interface for session storage
+    module SessionStore
+      # Load session data by ID
+      def load_session(session_id)
+        raise NotImplementedError, "#{self.class} must implement #load_session"
+      end
+
+      # Save session data
+      def save_session(session_id, session_data)
+        raise NotImplementedError, "#{self.class} must implement #save_session"
+      end
+
+      # Delete session
+      def delete_session(session_id)
+        raise NotImplementedError, "#{self.class} must implement #delete_session"
+      end
+
+      # Check if session exists
+      def session_exists?(session_id)
+        raise NotImplementedError, "#{self.class} must implement #session_exists?"
+      end
+
+      # Update specific session attributes
+      def update_session(session_id, attributes)
+        session_data = load_session(session_id)
+        return nil unless session_data
+
+        session_data.merge!(attributes)
+        save_session(session_id, session_data)
+        session_data
+      end
+    end
+
+    # In-memory session store for development/testing
+    class MemorySessionStore
+      include SessionStore
+
+      def initialize
+        @sessions = {}
+        @mutex = Mutex.new
+      end
+
+      def load_session(session_id)
+        @mutex.synchronize { @sessions[session_id] }
+      end
+
+      def save_session(session_id, session_data)
+        @mutex.synchronize { @sessions[session_id] = session_data.dup }
+      end
+
+      def delete_session(session_id)
+        @mutex.synchronize { @sessions.delete(session_id) }
+      end
+
+      def session_exists?(session_id)
+        @mutex.synchronize { @sessions.key?(session_id) }
+      end
+
+      def clear_all
+        @mutex.synchronize { @sessions.clear }
+      end
+
+      def session_count
+        @mutex.synchronize { @sessions.size }
+      end
+    end
+
+    # ActiveRecord-backed session store for production
+    class ActiveRecordSessionStore
+      include SessionStore
+
+      def load_session(session_id)
+        session = ActionMCP::Session.find_by(id: session_id)
+        return nil unless session
+
+        {
+          id: session.id,
+          protocol_version: session.protocol_version,
+          client_info: session.client_info,
+          client_capabilities: session.client_capabilities,
+          server_info: session.server_info,
+          server_capabilities: session.server_capabilities,
+          last_event_id: session.last_event_id,
+          session_data: session.session_data || {},
+          created_at: session.created_at,
+          updated_at: session.updated_at
+        }
+      end
+
+      def save_session(session_id, session_data)
+        session = ActionMCP::Session.find_or_initialize_by(id: session_id)
+
+        session.assign_attributes(
+          protocol_version: session_data[:protocol_version],
+          client_info: session_data[:client_info],
+          client_capabilities: session_data[:client_capabilities],
+          server_info: session_data[:server_info],
+          server_capabilities: session_data[:server_capabilities],
+          last_event_id: session_data[:last_event_id],
+          session_data: session_data[:session_data] || {}
+        )
+
+        session.save!
+        session_data
+      end
+
+      def delete_session(session_id)
+        ActionMCP::Session.find_by(id: session_id)&.destroy
+      end
+
+      def session_exists?(session_id)
+        ActionMCP::Session.exists?(id: session_id)
+      end
+
+      def cleanup_expired_sessions(older_than: 24.hours.ago)
+        ActionMCP::Session.where("updated_at < ?", older_than).delete_all
+      end
+    end
+
+    # Factory for creating session stores
+    class SessionStoreFactory
+      def self.create(type = nil, **options)
+        type ||= Rails.env.production? ? :active_record : :memory
+
+        case type.to_sym
+        when :memory
+          MemorySessionStore.new
+        when :active_record
+          ActiveRecordSessionStore.new
+        else
+          raise ArgumentError, "Unknown session store type: #{type}"
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/client/streamable_http_transport.rb

@@ -0,0 +1,291 @@
+# 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
+
+      def initialize(url, session_store:, session_id: nil, **options)
+        super(url, session_store: session_store, **options)
+        @session_id = session_id
+        @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_connected(true)
+        set_ready(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)
+        unless ready?
+          raise ConnectionError, "Transport not ready"
+        end
+
+        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
+        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
+        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..-1].strip
+          elsif line.start_with?("data:")
+            data_lines << line[5..-1].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
+        if response.headers["mcp-session-id"]
+          @session_id = response.headers["mcp-session-id"]
+        end
+
+        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)
+        begin
+          message = MultiJson.load(response.body)
+          handle_message(message)
+        rescue MultiJson::ParseError => e
+          log_error("Failed to parse JSON response: #{e}")
+        end
+      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}"
+        if response.body && !response.body.empty?
+          error_msg << " - #{response.body}"
+        end
+        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/transport.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    # Base transport interface for MCP client connections
+    module Transport
+      # Called when transport should establish connection
+      def connect
+        raise NotImplementedError, "#{self.class} must implement #connect"
+      end
+
+      # Called when transport should close connection
+      def disconnect
+        raise NotImplementedError, "#{self.class} must implement #disconnect"
+      end
+
+      # Send a message through the transport
+      def send_message(message)
+        raise NotImplementedError, "#{self.class} must implement #send_message"
+      end
+
+      # Check if transport is ready to send/receive
+      def ready?
+        raise NotImplementedError, "#{self.class} must implement #ready?"
+      end
+
+      # Check if transport is connected
+      def connected?
+        raise NotImplementedError, "#{self.class} must implement #connected?"
+      end
+
+      # Set callback for received messages
+      def on_message(&block)
+        @message_callback = block
+      end
+
+      # Set callback for errors
+      def on_error(&block)
+        @error_callback = block
+      end
+
+      # Set callback for connection events
+      def on_connect(&block)
+        @connect_callback = block
+      end
+
+      # Set callback for disconnection events
+      def on_disconnect(&block)
+        @disconnect_callback = block
+      end
+
+      protected
+
+      def handle_message(message)
+        @message_callback&.call(message)
+      end
+
+      def handle_error(error)
+        @error_callback&.call(error)
+      end
+
+      def handle_connect
+        @connect_callback&.call
+      end
+
+      def handle_disconnect
+        @disconnect_callback&.call
+      end
+    end
+
+    # Base class for transport implementations
+    class TransportBase
+      include Transport
+      include Logging
+
+      attr_reader :url, :options, :session_store
+
+      def initialize(url, session_store:, logger: ActionMCP.logger, **options)
+        @url = url
+        @session_store = session_store
+        @logger = logger
+        @options = options
+        @connected = false
+        @ready = false
+      end
+
+      def connected?
+        @connected
+      end
+
+      def ready?
+        @ready
+      end
+
+      protected
+
+      def set_connected(state)
+        @connected = state
+        state ? handle_connect : handle_disconnect
+      end
+
+      def set_ready(state)
+        @ready = state
+      end
+    end
+  end
+end

data/lib/action_mcp/client.rb

@@ -1,24 +1,64 @@
 # frozen_string_literal: true
 
+require_relative "client/transport"
+require_relative "client/session_store"
+require_relative "client/streamable_http_transport"
+
 module ActionMCP
   # Creates a client appropriate for the given endpoint.
   #
   # @param endpoint [String] The endpoint to connect to (URL).
+  # @param transport [Symbol] The transport type to use (:streamable_http, :sse for legacy)
+  # @param session_store [Symbol] The session store type (:memory, :active_record)
+  # @param session_id [String] Optional session ID for resuming connections
   # @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] An instance of SSEClient for HTTP(S) endpoints.
+  # @return [Client::Base] An instance of the appropriate client.
   #
-  # @example
+  # @example Basic usage
   #   client = ActionMCP.create_client("http://127.0.0.1:3001/action_mcp")
   #   client.connect
-  def self.create_client(endpoint, logger: Logger.new($stdout), **options)
+  #
+  # @example With specific transport and session store
+  #   client = ActionMCP.create_client(
+  #     "http://127.0.0.1:3001/action_mcp",
+  #     transport: :streamable_http,
+  #     session_store: :active_record,
+  #     session_id: "existing-session-123"
+  #   )
+  #
+  # @example Memory-based for development
+  #   client = ActionMCP.create_client(
+  #     "http://127.0.0.1:3001/action_mcp",
+  #     session_store: :memory
+  #   )
+  def self.create_client(endpoint, transport: :streamable_http, session_store: nil, session_id: nil, logger: Logger.new($stdout), **options)
     unless endpoint =~ %r{\Ahttps?://}
       raise ArgumentError, "Only HTTP(S) endpoints are supported. STDIO and other transports are not supported."
     end
 
-    logger.info("Creating SSE client for endpoint: #{endpoint}")
-    Client::SSEClient.new(endpoint, logger: logger, **options)
+    # Create session store
+    store = Client::SessionStoreFactory.create(session_store, **options)
+
+    # Create transport
+    transport_instance = create_transport(transport, endpoint, session_store: store, session_id: session_id, logger: logger, **options)
+
+    logger.info("Creating #{transport} client for endpoint: #{endpoint}")
+    # Pass session_id to the client
+    Client::Base.new(transport: transport_instance, logger: logger, session_id: session_id, **options)
+  end
+
+  private_class_method def self.create_transport(type, endpoint, **options)
+    case type.to_sym
+    when :streamable_http
+      Client::StreamableHttpTransport.new(endpoint, **options)
+    when :sse
+      # Legacy SSE transport (wrapped for compatibility)
+      Client::LegacySSETransport.new(endpoint, **options)
+    else
+      raise ArgumentError, "Unknown transport type: #{type}"
+    end
   end
 
   module Client

data/lib/action_mcp/server/capabilities.rb

@@ -13,6 +13,7 @@ module ActionMCP
         client_protocol_version = params["protocolVersion"]
         client_info = params["clientInfo"]
         client_capabilities = params["capabilities"]
+        session_id = params["sessionId"]
 
         unless client_protocol_version.is_a?(String) && client_protocol_version.present?
           return send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'protocolVersion'")
@@ -32,6 +33,28 @@ module ActionMCP
           return send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'capabilities'")
         end
 
+        # Handle session resumption if sessionId provided
+        if session_id
+          existing_session = ActionMCP::Session.find_by(id: session_id)
+          if existing_session && existing_session.initialized?
+            # Resume existing session - update transport reference
+            transport.instance_variable_set(:@session, existing_session)
+            Rails.logger.info("Resuming existing session: #{session_id}")
+
+            # Return existing session info
+            capabilities_payload = existing_session.server_capabilities_payload
+            capabilities_payload[:protocolVersion] = if ActionMCP.configuration.vibed_ignore_version
+                                                       PROTOCOL_VERSION
+            else
+                                                       client_protocol_version
+            end
+            return send_jsonrpc_response(request_id, result: capabilities_payload)
+          else
+            Rails.logger.warn("Session #{session_id} not found or not initialized, creating new session")
+          end
+        end
+
+        # Create new session if not resuming
         session.store_client_info(client_info)
         session.store_client_capabilities(client_capabilities)
         session.set_protocol_version(client_protocol_version)

data/lib/action_mcp/version.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.50.13
+  version: 0.51.0
 platform: ruby
 authors:
 - Abdelkader Boudih
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-17 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -137,9 +136,12 @@ files:
 - lib/action_mcp/client/resources.rb
 - lib/action_mcp/client/roots.rb
 - lib/action_mcp/client/server.rb
+- lib/action_mcp/client/session_store.rb
 - lib/action_mcp/client/sse_client.rb
+- lib/action_mcp/client/streamable_http_transport.rb
 - lib/action_mcp/client/toolbox.rb
 - lib/action_mcp/client/tools.rb
+- lib/action_mcp/client/transport.rb
 - lib/action_mcp/configuration.rb
 - lib/action_mcp/console_detector.rb
 - lib/action_mcp/content.rb
@@ -220,7 +222,6 @@ metadata:
   source_code_uri: https://github.com/seuros/action_mcp
   changelog_uri: https://github.com/seuros/action_mcp/blob/master/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -235,8 +236,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Provides essential tooling for building Model Context Protocol (MCP) capable
   servers