actionmcp 0.20.0 → 0.22.0

data/lib/action_mcp/json_rpc_handler.rb

@@ -1,229 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  class JsonRpcHandler
-    delegate :initialize!, :initialized?, to: :transport
-    delegate :write, :read, to: :transport
-    attr_reader :transport
-
-    # @param transport [ActionMCP::TransportHandler]
-    def initialize(transport)
-      @transport = transport
-    end
-
-    # Process a single line of input.
-    # @param line [String, Hash]
-    def call(line)
-      request = if line.is_a?(String)
-                  line.strip!
-                  return if line.empty?
-
-                  begin
-                    MultiJson.load(line)
-                  rescue MultiJson::ParseError => e
-                    Rails.logger.error("Failed to parse JSON: #{e.message}")
-                    return
-                  end
-      else
-                  line
-      end
-      process_request(request)
-    end
-
-    private
-
-    # @param request [Hash]
-    def process_request(request)
-      unless request["jsonrpc"] == "2.0"
-        puts "Invalid request: #{request}"
-        return
-      end
-      read(request)
-      return if request["error"]
-      return if request["result"] == {} # Probably a pong
-
-      rpc_method = request["method"]
-      id = request["id"]
-      params = request["params"]
-
-      # Common methods (both directions)
-      case rpc_method
-      when "initialize"                # [SERVER] Client initializing the connection
-        transport.send_capabilities(id, params)
-      when "ping"                      # [BOTH] Client ping
-        transport.send_pong(id)
-
-        # Methods that servers must implement (client → server)
-      when %r{^prompts/}               # [SERVER] Prompt-related requests
-        process_prompts(rpc_method, id, params)
-      when %r{^resources/}             # [SERVER] Resource-related requests
-        process_resources(rpc_method, id, params)
-      when %r{^tools/}                 # [SERVER] Tool-related requests
-        process_tools(rpc_method, id, params)
-      when "completion/complete" # [SERVER] Completion requests
-        process_completion_complete(id, params)
-
-        # Methods that clients must implement (server → client)
-      when "client/setLoggingLevel" # [CLIENT] Server configuring client logging
-        process_client_logging(id, params)
-      when %r{^roots/}                 # [CLIENT] Roots management
-        process_roots(rpc_method, id, params)
-      when %r{^sampling/}              # [CLIENT] Sampling requests
-        process_sampling(rpc_method, id, params)
-
-        # Notifications (can go both ways)
-      when %r{^notifications/}
-        puts "\e[31mProcessing notifications\e[0m"
-        process_notifications(rpc_method, params)
-      else
-        puts "\e[31mUnknown method: #{rpc_method} #{request}\e[0m"
-      end
-    end
-
-    # @param rpc_method [String]
-    def process_notifications(rpc_method, params)
-      case rpc_method
-      when "notifications/initialized"            # [SERVER] Client initialization complete
-        puts "\e[31mInitialized\e[0m"
-        transport.initialize!
-      when "notifications/cancelled"              # [BOTH] Request cancellation
-        puts "\e[31m Request #{params['requestId']} cancelled: #{params['reason']}\e[0m"
-        # we don't need to do anything here
-      when "notifications/resources/updated" # [CLIENT] Resource update notification
-        puts "\e[31m Resource #{params['uri']} was updated\e[0m"
-        # Handle resource update notification
-      when "notifications/tools/list_changed" # [CLIENT] Tool list change notification
-        puts "\e[31m Tool list has changed\e[0m"
-        # Handle tool list change notification
-      when "notifications/prompts/list_changed" # [CLIENT] Prompt list change notification
-        puts "\e[31m Prompt list has changed\e[0m"
-        # Handle prompt list change notification
-      when "notifications/resources/list_changed" # [CLIENT] Resource list change notification
-        puts "\e[31m Resource list has changed\e[0m"
-        # Handle resource list change notification
-      else
-        Rails.logger.warn("Unknown notifications method: #{rpc_method}")
-      end
-    end
-
-    # Server methods (client → server)
-
-    # @param id [String]
-    # @param params [Hash]
-    # @example {
-    #     "ref": {
-    #       "type": "ref/prompt",
-    #       "name": "code_review"
-    #     },
-    #     "argument": {
-    #       "name": "language",
-    #       "value": "py"
-    #     }
-    #   }
-    # @return [Hash]
-    # @example {
-    #     "completion": {
-    #       "values": ["python", "pytorch", "pyside"],
-    #       "total": 10,
-    #       "hasMore": true
-    #     }
-    #   }
-    def process_completion_complete(id, params)
-      # TODO: Not Implemented, but to remove the error message in the inspector
-      transport.send_jsonrpc_response(id, result: { completion: { values: [], total: 0, hasMore: false } })
-      case params["ref"]["type"]
-      when "ref/prompt"
-        # TODO: Implement completion
-      when "ref/resource"
-        # TODO: Implement completion
-      end
-    end
-
-    # @param rpc_method [String]
-    # @param id [String]
-    # @param params [Hash]
-    def process_prompts(rpc_method, id, params)
-      case rpc_method
-      when "prompts/get"              # [SERVER] Get specific prompt
-        transport.send_prompts_get(id, params["name"], params["arguments"])
-      when "prompts/list"             # [SERVER] List available prompts
-        transport.send_prompts_list(id)
-      else
-        Rails.logger.warn("Unknown prompts method: #{rpc_method}")
-      end
-    end
-
-    # @param rpc_method [String]
-    # @param id [String]
-    # @param params [Hash]
-    def process_resources(rpc_method, id, params)
-      case rpc_method
-      when "resources/list"           # [SERVER] List available resources
-        transport.send_resources_list(id)
-      when "resources/templates/list" # [SERVER] List resource templates
-        transport.send_resource_templates_list(id)
-      when "resources/read"           # [SERVER] Read resource content
-        transport.send_resource_read(id, params)
-      when "resources/subscribe"      # [SERVER] Subscribe to resource updates
-        transport.send_resource_subscribe(id, params["uri"])
-      when "resources/unsubscribe"    # [SERVER] Unsubscribe from resource updates
-        transport.send_resource_unsubscribe(id, params["uri"])
-      else
-        Rails.logger.warn("Unknown resources method: #{rpc_method}")
-      end
-    end
-
-    # @param rpc_method [String]
-    # @param id [String]
-    # @param params [Hash]
-    def process_tools(rpc_method, id, params)
-      case rpc_method
-      when "tools/list"               # [SERVER] List available tools
-        transport.send_tools_list(id)
-      when "tools/call"               # [SERVER] Call a tool
-        transport.send_tools_call(id, params&.dig("name"), params&.dig("arguments"))
-      else
-        Rails.logger.warn("Unknown tools method: #{rpc_method}")
-      end
-    end
-
-    # Client methods (server → client)
-
-    # @param id [String]
-    # @param params [Hash]
-    def process_client_logging(id, params)
-      level = params["level"]
-      transport.set_client_logging_level(id, level)
-    end
-
-    # @param rpc_method [String]
-    # @param id [String]
-    # @param params [Hash]
-    def process_roots(rpc_method, id, params)
-      case rpc_method
-      when "roots/list"               # [CLIENT] List available roots
-        transport.send_roots_list(id)
-      when "roots/add"                # [CLIENT] Add a root
-        transport.send_roots_add(id, params["uri"], params["name"])
-      when "roots/remove"             # [CLIENT] Remove a root
-        transport.send_roots_remove(id, params["uri"])
-      else
-        Rails.logger.warn("Unknown roots method: #{rpc_method}")
-      end
-    end
-
-    # @param rpc_method [String]
-    # @param id [String]
-    # @param params [Hash]
-    def process_sampling(rpc_method, id, params)
-      case rpc_method
-      when "sampling/createMessage" # [CLIENT] Create a message using AI
-        # @param id [String]
-        # @param params [SamplingRequest]
-        transport.send_sampling_create_message(id, params)
-      else
-        Rails.logger.warn("Unknown sampling method: #{rpc_method}")
-      end
-    end
-  end
-end

data/lib/action_mcp/sampling_request.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  class SamplingRequest
-    class << self
-      attr_reader :default_messages, :default_system_prompt, :default_context,
-                  :default_model_hints, :default_intelligence_priority,
-                  :default_max_tokens, :default_temperature
-
-      def configure
-        yield self
-      end
-
-      def messages(messages = nil)
-        if messages
-          @default_messages = messages.map do |msg|
-            mutate_content(msg)
-          end
-        end
-        @default_messages ||= []
-      end
-
-      def system_prompt(prompt = nil)
-        @default_system_prompt = prompt if prompt
-        @default_system_prompt
-      end
-
-      def include_context(context = nil)
-        @default_context = context if context
-        @default_context
-      end
-
-      def model_hints(hints = nil)
-        @default_model_hints = hints if hints
-        @model_hints ||= []
-      end
-
-      def intelligence_priority(priority = nil)
-        @default_intelligence_priority = priority if priority
-        @intelligence_priority ||= 0.9
-      end
-
-      def max_tokens(tokens = nil)
-        @default_max_tokens = tokens if tokens
-        @max_tokens ||= 500
-      end
-
-      def temperature(temp = nil)
-        @default_temperature = temp if temp
-        @temperature ||= 0.7
-      end
-
-      private
-
-      def mutate_content(msg)
-        content = msg[:content]
-        if content.is_a?(ActionMCP::Content) || (content.respond_to?(:to_h) && !content.is_a?(Hash))
-          { role: msg[:role], content: content.to_h }
-        else
-          msg
-        end
-      end
-    end
-
-    attr_accessor :system_prompt, :model_hints, :intelligence_priority, :max_tokens, :temperature
-    attr_reader :messages, :context
-
-    def initialize
-      @messages = self.class.default_messages.dup
-      @system_prompt = self.class.default_system_prompt
-      @context = self.class.default_context
-      @model_hints = self.class.default_model_hints.dup
-      @intelligence_priority = self.class.default_intelligence_priority
-      @max_tokens = self.class.default_max_tokens
-      @temperature = self.class.default_temperature
-
-      yield self if block_given?
-    end
-
-    def messages=(value)
-      @messages = value.map do |msg|
-        self.class.send(:mutate_content, msg)
-      end
-    end
-
-    def include_context=(value)
-      @context = value
-    end
-
-    def add_message(content, role: "user")
-      if content.is_a?(Content::Base) || (content.respond_to?(:to_h) && !content.is_a?(Hash))
-        @messages << { role: role, content: content.to_h }
-      else
-        content = Content::Text.new(content).to_h if content.is_a?(String)
-        @messages << { role: role, content: content }
-      end
-    end
-
-    def to_h
-      {
-        messages: messages.map { |msg| { role: msg[:role], content: msg[:content] } },
-        systemPrompt: system_prompt,
-        includeContext: context,
-        modelPreferences: {
-          hints: model_hints.map { |name| { name: name } },
-          intelligencePriority: intelligence_priority
-        },
-        maxTokens: max_tokens,
-        temperature: temperature
-      }.compact
-    end
-  end
-end

data/lib/action_mcp/server_json_rpc_handler.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  # Handler for server-side requests (client -> server)
-  class ServerJsonRpcHandler < BaseJsonRpcHandler
-    def handle_initialize(id, params)
-      # Server-specific initialization
-      transport.send_capabilities(id, params)
-    end
-
-    def handle_specific_method(rpc_method, id, params)
-      case rpc_method
-      when %r{^prompts/}               # [SERVER] Prompt-related requests
-        process_prompts(rpc_method, id, params)
-      when %r{^resources/}             # [SERVER] Resource-related requests
-        process_resources(rpc_method, id, params)
-      when %r{^tools/}                 # [SERVER] Tool-related requests
-        process_tools(rpc_method, id, params)
-      when "completion/complete" # [SERVER] Completion requests
-        process_completion_complete(id, params)
-      else
-        Rails.logger.warn("Unknown server method: #{rpc_method}")
-      end
-    end
-    def handle_specific_notification(rpc_method, _params)
-      # Server-specific notifications would go here
-      case rpc_method
-      when "notifications/initialized"            # [SERVER] Initialization complete
-        puts "Initialized"
-        transport.initialize!
-      else
-        Rails.logger.warn("Unknown server notification: #{rpc_method}")
-      end
-    end
-
-    private
-
-    # All the server-specific methods below...
-
-    def process_completion_complete(id, params)
-      # Implementation as in original code
-      transport.send_jsonrpc_response(id, result: { completion: { values: [], total: 0, hasMore: false } })
-      case params["ref"]["type"]
-      when "ref/prompt"
-        # TODO: Implement completion
-      when "ref/resource"
-        # TODO: Implement completion
-      end
-    end
-
-    def process_prompts(rpc_method, id, params)
-      case rpc_method
-      when "prompts/get"              # [SERVER] Get specific prompt
-        transport.send_prompts_get(id, params["name"], params["arguments"])
-      when "prompts/list"             # [SERVER] List available prompts
-        transport.send_prompts_list(id)
-      else
-        Rails.logger.warn("Unknown prompts method: #{rpc_method}")
-      end
-    end
-
-    def process_resources(rpc_method, id, params)
-      case rpc_method
-      when "resources/list"           # [SERVER] List available resources
-        transport.send_resources_list(id)
-      when "resources/templates/list" # [SERVER] List resource templates
-        transport.send_resource_templates_list(id)
-      when "resources/read"           # [SERVER] Read resource content
-        transport.send_resource_read(id, params)
-      when "resources/subscribe"      # [SERVER] Subscribe to resource updates
-        transport.send_resource_subscribe(id, params["uri"])
-      when "resources/unsubscribe"    # [SERVER] Unsubscribe from resource updates
-        transport.send_resource_unsubscribe(id, params["uri"])
-      else
-        Rails.logger.warn("Unknown resources method: #{rpc_method}")
-      end
-    end
-
-    def process_tools(rpc_method, id, params)
-      case rpc_method
-      when "tools/list"               # [SERVER] List available tools
-        transport.send_tools_list(id)
-      when "tools/call"               # [SERVER] Call a tool
-        transport.send_tools_call(id, params&.dig("name"), params&.dig("arguments"))
-      else
-        Rails.logger.warn("Unknown tools method: #{rpc_method}")
-      end
-    end
-  end
-end

data/lib/action_mcp/transport/transport_base.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Transport
-    class TransportBase
-      attr_reader :logger, :client_capabilities, :server_capabilities
-
-      def initialize(logger: Logger.new($stdout))
-        @logger = logger
-        @on_message = nil
-        @on_error = nil
-        @client_capabilities = default_capabilities
-        @server_capabilities = nil
-        @initialize_request_id = SecureRandom.hex(6)
-        @initialization_sent = false
-      end
-
-      def on_message(&block)
-        @on_message = block
-      end
-
-      def on_error(&block)
-        @on_error = block
-      end
-
-      def send_initial_capabilities
-        return if @initialization_sent
-
-        log_info("Sending client capabilities: #{@client_capabilities}")
-
-        request = JsonRpc::Request.new(
-          id: @initialize_request_id,
-          method: "initialize",
-          params: {
-            protocolVersion: PROTOCOL_VERSION,
-            capabilities: @client_capabilities,
-            clientInfo: {
-              name: user_agent,
-              version: ActionMCP.gem_version.to_s
-            }
-          }
-        )
-        @initialization_sent = true
-        send_message(request.to_json)
-      end
-
-      def handle_initialize_response(response)
-        return if @server_capabilities
-
-        if response.result
-          @server_capabilities = response.result["capabilities"]
-          send_initialized_notification
-        else
-          log_error("Server initialization failed: #{response.error}")
-        end
-      end
-
-      protected
-
-      def handle_raw_message(raw)
-        # Debug - log all raw messages
-        log_debug("\e[31m<-- #{raw}\e[0m")
-
-        begin
-          msg_hash = MultiJson.load(raw)
-          response = nil
-
-          if msg_hash.key?("jsonrpc")
-            response = if msg_hash.key?("id")
-                         JsonRpc::Response.new(**msg_hash.slice("id", "result", "error").symbolize_keys)
-            else
-                         JsonRpc::Notification.new(**msg_hash.slice("method", "params").symbolize_keys)
-            end
-          end
-          # Check if this is a response to our initialize request
-          if response && @initialize_request_id && response.id == @initialize_request_id
-            handle_initialize_response(response)
-          elsif response
-            @on_message&.call(response)
-          end
-        rescue MultiJson::ParseError => e
-          log_error("JSON parse error: #{e} (raw: #{raw})")
-          @on_error&.call(e)
-        rescue StandardError => e
-          log_error("Error handling message: #{e} (raw: #{raw})")
-          @on_error&.call(e)
-        end
-      end
-
-      # Send the initialized notification to the server
-      def send_initialized_notification
-        notification = JsonRpc::Notification.new(
-          method: "initialized"
-        )
-
-        logger.info("Sent initialized notification to server")
-        send_message(notification)
-      end
-
-      def default_capabilities
-        {
-          # Base client capabilities
-          # roots: {}, # Remove from now.
-        }
-      end
-
-      def log_debug(message)
-        @logger.debug("[#{log_prefix}] #{message}")
-      end
-
-      def log_info(message)
-        @logger.info("[#{log_prefix}] #{message}")
-      end
-
-      def log_error(message)
-        @logger.error("[#{log_prefix}] #{message}")
-      end
-
-      private
-
-      def log_prefix
-        self.class.name.split("::").last
-      end
-    end
-  end
-end

data/lib/action_mcp/transport_handler.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  class TransportHandler
-    attr_reader :session
-
-    delegate :initialize!, :initialized?, to: :session
-    delegate :read, :write, to: :session
-    include Logging
-
-    include Transport::Messaging
-    include Transport::Capabilities
-    include Transport::Tools
-    include Transport::Prompts
-    include Transport::Resources
-    include Transport::Notifications
-    include Transport::Sampling
-    include Transport::Roots
-
-    # @param [ActionMCP::Session] session
-    def initialize(session)
-      @session = session
-    end
-
-    def send_pong(request_id)
-      send_jsonrpc_response(request_id, result: {})
-    end
-
-    private
-
-    def write_message(data)
-      session.write(data)
-    end
-
-    def format_registry_items(registry)
-      registry.map { |item| item.klass.to_h }
-    end
-  end
-end