actionmcp 0.102.0 → 0.104.0

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

data/lib/action_mcp/client/toolbox.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Toolbox
-    #
-    # A collection that manages and provides access to tools from the server.
-    # This class stores tool definitions along with their input schemas and
-    # provides methods for retrieving, filtering, and accessing tools.
-    #
-    # Example usage:
-    #   tools_data = client.list_tools # Returns array of tool definitions
-    #   toolbox = Toolbox.new(tools_data)
-    #
-    #   # Access a specific tool by name
-    #   weather_tool = toolbox.find("weather_forecast")
-    #
-    #   # Get all tools matching a criteria
-    #   calculation_tools = toolbox.filter { |t| t.name.include?("calculate") }
-    #
-    class Toolbox < Collection
-      # Initialize a new Toolbox with tool definitions
-      #
-      # @param tools [Array<Hash>] Array of tool definition hashes, each containing
-      #   name, description, and inputSchema keys
-      def initialize(tools, client)
-        super(tools, client)
-        self.tools = @collection_data
-        @load_method = :list_tools
-      end
-
-      # Find a tool by name
-      #
-      # @param name [String] Name of the tool to find
-      # @return [Tool, nil] The tool with the given name, or nil if not found
-      def find(name)
-        all.find { |tool| tool.name == name }
-      end
-
-      # Filter tools based on a given block
-      #
-      # @yield [tool] Block that determines whether to include a tool
-      # @yieldparam tool [Tool] A tool from the collection
-      # @yieldreturn [Boolean] true to include the tool, false to exclude it
-      # @return [Array<Tool>] Tools that match the filter criteria
-      def filter(&block)
-        all.select(&block)
-      end
-
-      # Get a list of all tool names
-      #
-      # @return [Array<String>] Names of all tools in the collection
-      def names
-        all.map(&:name)
-      end
-
-      # Number of tools in the collection
-      #
-      # @return [Integer] The number of tools
-      def size
-        all.size
-      end
-
-      # Check if the collection contains a tool with the given name
-      #
-      # @param name [String] The tool name to check for
-      # @return [Boolean] true if a tool with the name exists
-      def contains?(name)
-        all.any? { |tool| tool.name == name }
-      end
-
-      # Get tools by category or type
-      #
-      # @param keyword [String] Keyword to search for in tool names and descriptions
-      # @return [Array<Tool>] Tools containing the keyword
-      def search(keyword)
-        all.select do |tool|
-          tool.name.include?(keyword) ||
-            tool.description&.downcase&.include?(keyword.downcase)
-        end
-      end
-
-      # Generate a hash representation of all tools in the collection based on provider format
-      #
-      # @param provider [Symbol] The provider format to use (:claude, :openai, or :default)
-      # @return [Hash] Hash containing all tools formatted for the specified provider
-      def to_h(provider = :default)
-        case provider
-        when :claude
-          # Claude format
-          { "tools" => all.map(&:to_claude_h) }
-        when :openai
-          # OpenAI format
-          { "tools" => all.map(&:to_openai_h) }
-        else
-          # Default format (same as original)
-          { "tools" => all.map(&:to_h) }
-        end
-      end
-
-      def tools=(tools)
-        @collection_data = tools.map { |tool_data| Tool.new(tool_data) }
-      end
-
-      # Internal Tool class to represent individual tools
-      class Tool
-        attr_reader :name, :description, :input_schema, :annotations
-
-        # Initialize a new Tool instance
-        #
-        # @param data [Hash] Tool definition hash containing name, description, and inputSchema
-        #  and optionally annotations
-        def initialize(data)
-          @name = data["name"]
-          @description = data["description"]
-          @input_schema = data["inputSchema"] || {}
-          @annotations = data["annotations"] || {}
-        end
-
-        # Get all required properties for this tool
-        #
-        # @return [Array<String>] Array of required property names
-        def required_properties
-          @input_schema["required"] || []
-        end
-
-        # Get all properties for this tool
-        #
-        # @return [Hash] Hash of property definitions
-        def properties
-          @input_schema["properties"] || {}
-        end
-
-        # Check if the tool requires a specific property
-        #
-        # @param name [String] Name of the property to check
-        # @return [Boolean] true if the property is required
-        def requires?(name)
-          required_properties.include?(name)
-        end
-
-        # Check if the tool has a specific property
-        #
-        # @param name [String] Name of the property to check
-        # @return [Boolean] true if the property exists
-        def has_property?(name)
-          properties.key?(name)
-        end
-
-        # Get property details by name
-        #
-        # @param name [String] Name of the property
-        # @return [Hash, nil] Property details or nil if not found
-        def property(name)
-          properties[name]
-        end
-
-        # Generate a hash representation of the tool (default format)
-        #
-        # @return [Hash] Hash containing tool details
-        def to_h
-          {
-            "name" => @name,
-            "description" => @description,
-            "inputSchema" => @input_schema,
-            "annotations" => @annotations
-          }
-        end
-
-        # Generate a hash representation of the tool in Claude format
-        #
-        # @return [Hash] Hash containing tool details formatted for Claude
-        def to_claude_h
-          {
-            "name" => @name,
-            "description" => @description,
-            "input_schema" => @input_schema.transform_keys { |k| k == "inputSchema" ? "input_schema" : k },
-            "annotations" => @annotations
-          }
-        end
-
-        # Generate a hash representation of the tool in OpenAI format
-        #
-        # @return [Hash] Hash containing tool details formatted for OpenAI
-        def to_openai_h
-          {
-            "type" => "function",
-            "function" => {
-              "name" => @name,
-              "description" => @description,
-              "parameters" => @input_schema,
-              "annotations" => @annotations
-            }
-          }
-        end
-      end
-    end
-  end
-end

data/lib/action_mcp/client/tools.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    module Tools
-      # List all available tools from the server
-      # @param params [Hash] Optional parameters for pagination
-      # @option params [String] :cursor Pagination cursor for fetching next page
-      # @option params [Integer] :limit Maximum number of items to return
-      # @return [String] Request ID for tracking the request
-      def list_tools(params = {})
-        request_id = SecureRandom.uuid_v7
-
-        # Send request with pagination parameters if provided
-        request_params = {}
-        request_params[:cursor] = params[:cursor] if params[:cursor]
-        request_params[:limit] = params[:limit] if params[:limit]
-
-        send_jsonrpc_request("tools/list",
-                             params: request_params.empty? ? nil : request_params,
-                             id: request_id)
-
-        # Return request ID for timeout tracking
-        request_id
-      end
-
-      # Call a specific tool on the server
-      # @param name [String] Name of the tool to call
-      # @param arguments [Hash] Arguments to pass to the tool
-      # @return [String] Request ID for tracking the request
-      def call_tool(name, arguments)
-        request_id = SecureRandom.uuid_v7
-
-        # Send request
-        send_jsonrpc_request("tools/call",
-                             params: {
-                               name: name,
-                               arguments: arguments
-                             },
-                             id: request_id)
-
-        # Return request ID for tracking the request
-        request_id
-      end
-    end
-  end
-end