actionmcp 0.102.0 → 0.104.0

data/lib/action_mcp/client/transport.rb

@@ -1,137 +0,0 @@
-# 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
-
-      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
-
-      # Logging methods for transport classes
-      def log_debug(message)
-        @logger.debug("[ActionMCP::#{self.class.name.split('::').last}] #{message}")
-      end
-
-      def log_info(message)
-        @logger.info("[ActionMCP::#{self.class.name.split('::').last}] #{message}")
-      end
-
-      def log_error(message)
-        @logger.error("[ActionMCP::#{self.class.name.split('::').last}] #{message}")
-      end
-
-      private
-
-      def handle_connect
-        @connect_callback&.call
-      end
-
-      def handle_disconnect
-        @disconnect_callback&.call
-      end
-
-      def handle_error(error)
-        @error_callback&.call(error)
-      end
-
-      def handle_message(message)
-        @message_callback&.call(message)
-      end
-    end
-  end
-end

data/lib/action_mcp/client/volatile_session_store.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Volatile session store for development (data lost on restart)
-    class VolatileSessionStore
-      include SessionStore
-
-      def initialize
-        @sessions = Concurrent::Hash.new
-      end
-
-      def load_session(session_id)
-        @sessions[session_id]
-      end
-
-      def save_session(session_id, session_data)
-        @sessions[session_id] = session_data.dup
-      end
-
-      def delete_session(session_id)
-        @sessions.delete(session_id)
-      end
-
-      def session_exists?(session_id)
-        @sessions.key?(session_id)
-      end
-
-      def clear_all
-        @sessions.clear
-      end
-
-      def session_count
-        @sessions.size
-      end
-    end
-  end
-end

data/lib/action_mcp/client.rb

@@ -1,71 +0,0 @@
-# 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 protocol_version [String] The MCP protocol version to use (defaults to ActionMCP::DEFAULT_PROTOCOL_VERSION)
-  # @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::Base] An instance of the appropriate client.
-  #
-  # @example Basic usage
-  #   client = ActionMCP.create_client("http://127.0.0.1:3001/action_mcp")
-  #   client.connect
-  #
-  # @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,
-                         protocol_version: 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
-
-    # 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,
-                                                               protocol_version: protocol_version, logger: logger, **options)
-
-    logger.info("Creating #{transport} client for endpoint: #{endpoint}")
-    # Pass session_id and protocol_version to the client
-    Client::Base.new(transport: transport_instance, logger: logger, session_id: session_id,
-                     protocol_version: protocol_version, **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::StreamableClient.new(endpoint, **options)
-    else
-      raise ArgumentError, "Unknown transport type: #{type}"
-    end
-  end
-
-  module Client
-  end
-end