actionmcp 0.19.1 → 0.22.0

data/lib/action_mcp/base_json_rpc_handler.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  # Base handler for common functionality
-  class BaseJsonRpcHandler
-    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 = parse_request(line)
-      return unless request
-
-      process_request(request)
-    end
-
-    protected
-
-    def parse_request(line)
-      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}")
-          nil
-        end
-      else
-        line
-      end
-    end
-
-    # @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 "ping"                      # [BOTH] Ping message
-        transport.send_pong(id)
-      when "initialize"                # [BOTH] Initialization
-        handle_initialize(id, params)
-      when %r{^notifications/}
-        process_common_notifications(rpc_method, params)
-      else
-        handle_specific_method(rpc_method, id, params)
-      end
-    end
-
-    # Override in subclasses
-    def handle_initialize(id, params)
-      raise NotImplementedError, "Subclasses must implement #handle_initialize"
-    end
-
-    # Override in subclasses
-    def handle_specific_method(rpc_method, id, params)
-      raise NotImplementedError, "Subclasses must implement #handle_specific_method"
-    end
-
-    def process_common_notifications(rpc_method, params)
-      case rpc_method
-      when "notifications/initialized"            # [BOTH] Initialization complete
-        puts "Initialized"
-        transport.initialize!
-      when "notifications/cancelled"              # [BOTH] Request cancellation
-        puts "Request #{params['requestId']} cancelled: #{params['reason']}"
-        # Handle cancellation
-      else
-        handle_specific_notification(rpc_method, params)
-      end
-    end
-
-    # Override in subclasses
-    def handle_specific_notification(rpc_method, params)
-      raise NotImplementedError, "Subclasses must implement #handle_specific_notification"
-    end
-  end
-end

data/lib/action_mcp/client_json_rpc_handler.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  # Handler for client-side requests (server -> client)
-  class ClientJsonRpcHandler < BaseJsonRpcHandler
-    def handle_initialize(id, params)
-      # Client-specific initialization
-      transport.send_client_capabilities(id, params)
-    end
-
-    def handle_specific_method(rpc_method, id, params)
-      case rpc_method
-      when "client/setLoggingLevel" # [CLIENT] Server configuring client logging
-        transport.set_client_logging_level(id, params["level"])
-      when %r{^roots/}                 # [CLIENT] Roots management
-        process_roots(rpc_method, id, params)
-      when %r{^sampling/}              # [CLIENT] Sampling requests
-        process_sampling(rpc_method, id, params)
-      else
-        Rails.logger.warn("Unknown client method: #{rpc_method}")
-      end
-    end
-
-    def handle_specific_notification(rpc_method, params)
-      case rpc_method
-      when "notifications/resources/updated" # [CLIENT] Resource update notification
-        puts "Resource #{params['uri']} was updated"
-        # Handle resource update notification
-      when "notifications/tools/list_changed" # [CLIENT] Tool list change notification
-        puts "Tool list has changed"
-        # Handle tool list change notification
-      when "notifications/prompts/list_changed" # [CLIENT] Prompt list change notification
-        puts "Prompt list has changed"
-        # Handle prompt list change notification
-      when "notifications/resources/list_changed" # [CLIENT] Resource list change notification
-        puts "Resource list has changed"
-        # Handle resource list change notification
-      else
-        Rails.logger.warn("Unknown client notification: #{rpc_method}")
-      end
-    end
-
-    private
-
-    # @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)
-      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
-        transport.send_sampling_create_message(id, params)
-      else
-        Rails.logger.warn("Unknown sampling method: #{rpc_method}")
-      end
-    end
-  end
-end

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