ask-mcp 0.1.0

data/lib/ask/mcp/client.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Ask
+  module MCP
+    class Client
+      PROTOCOL_VERSION = "0.1.0"
+
+      attr_reader :transport, :capabilities, :server_info
+
+      def initialize(transport, options = {})
+        @transport = transport
+        @options = options
+        @capabilities = {}
+        @server_info = {}
+        @tools_cache = nil
+        @resources_cache = nil
+        @prompts_cache = nil
+        @pending_requests = {}
+        @pending_mutex = Mutex.new
+        @pending_condition = ConditionVariable.new
+        @next_id = 0
+        @initialized = false
+      end
+
+      def start
+        @transport.on_message { |message| handle_message(message) }
+        @transport.start
+        initialize_session
+        self
+      end
+
+      def stop
+        @transport.stop
+        @initialized = false
+      end
+
+      def tools
+        return @tools_cache if @tools_cache && !@options[:no_cache]
+
+        response = send_request("tools/list")
+        tools = (response[:tools] || []).map { |t| Tool.from_h(t) }
+        @tools_cache = index_by_name(tools)
+      end
+
+      def resources
+        return @resources_cache if @resources_cache && !@options[:no_cache]
+
+        response = send_request("resources/list")
+        resources = (response[:resources] || []).map { |r| Resource.from_h(r) }
+        @resources_cache = index_by_uri(resources)
+      end
+
+      def prompts
+        return @prompts_cache if @prompts_cache && !@options[:no_cache]
+
+        response = send_request("prompts/list")
+        prompts = (response[:prompts] || []).map { |p| Prompt.from_h(p) }
+        @prompts_cache = index_by_name(prompts)
+      end
+
+      def call_tool(name, arguments = {})
+        if @options[:validate] && @tools_cache
+          tool = @tools_cache[name]
+          if tool && tool.input_schema && !tool.input_schema.empty?
+            Validator.new(tool.input_schema).validate!(arguments)
+          end
+        end
+        response = send_request("tools/call", name: name, arguments: arguments)
+        response[:content] || response
+      end
+
+      def read_resource(uri)
+        response = send_request("resources/read", uri: uri)
+        response[:contents] || response
+      end
+
+      def get_prompt(name, arguments = {})
+        response = send_request("prompts/get", name: name, arguments: arguments)
+        response[:messages] || response
+      end
+
+      def initialized?
+        @initialized
+      end
+
+      private
+
+      def next_id
+        @pending_mutex.synchronize do
+          @next_id += 1
+        end
+      end
+
+      def initialize_session
+        response = send_request_raw("initialize", {
+          protocolVersion: PROTOCOL_VERSION,
+          capabilities: @options[:client_capabilities] || {},
+          clientInfo: {
+            name: "ask-mcp",
+            version: Ask::MCP::VERSION
+          }
+        })
+
+        unless response.success?
+          raise ProtocolError, "Initialize failed: #{response.error[:message]}"
+        end
+
+        result = response.result
+        @server_info = result[:serverInfo] || {}
+        @capabilities = result[:capabilities] || {}
+
+        send_notification("notifications/initialized")
+        @initialized = true
+
+        @tools_cache = nil
+        @resources_cache = nil
+        @prompts_cache = nil
+      end
+
+      def send_request(method, params = {})
+        response = send_request_raw(method, params)
+        raise ProtocolError, "Request failed: #{response.error[:message]}" unless response.success?
+        response.result
+      end
+
+      def send_request_raw(method, params = {})
+        request = Native::Messages::Request.new(method:, params:, id: next_id)
+        wait_for_response(request)
+      end
+
+      def send_notification(method, params = {})
+        notification = Native::Messages::Notification.new(method:, params:)
+        @transport.send(notification)
+      end
+
+      def wait_for_response(request)
+        # Register the pending request BEFORE sending to avoid race
+        @pending_mutex.synchronize do
+          @pending_requests[request.id] = true
+        end
+
+        @transport.send(request)
+
+        timeout = @options[:timeout] || 60
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+
+        @pending_mutex.synchronize do
+          loop do
+            val = @pending_requests[request.id]
+            if val.is_a?(Native::Messages::Response)
+              @pending_requests.delete(request.id)
+              return val
+            end
+
+            remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            if remaining <= 0
+              @pending_requests.delete(request.id)
+              raise ConnectionError, "Request timed out after #{timeout}s"
+            end
+
+            @pending_condition.wait(@pending_mutex, remaining)
+          end
+        end
+      end
+
+      def handle_message(message)
+        case message
+        when Native::Messages::Response
+          handle_response(message)
+        when Native::Messages::Request
+          handle_request(message)
+        when Native::Messages::Notification
+          handle_notification(message)
+        when Exception
+          raise ConnectionError, "Transport error: #{message.message}"
+        end
+      end
+
+      def handle_response(response)
+        @pending_mutex.synchronize do
+          if @pending_requests.key?(response.id)
+            @pending_requests[response.id] = response
+            @pending_condition.broadcast
+          end
+        end
+      end
+
+      def handle_request(request)
+        response = Native::Messages::Response.new(
+          id: request.id,
+          error: {
+            code: Native::Messages::ErrorCodes::METHOD_NOT_FOUND,
+            message: "Method not implemented: #{request.method}"
+          }
+        )
+        @transport.send(response)
+      end
+
+      def handle_notification(notification)
+        case notification.method
+        when "notifications/tools/list_changed"
+          @tools_cache = nil
+        when "notifications/resources/list_changed"
+          @resources_cache = nil
+        when "notifications/prompts/list_changed"
+          @prompts_cache = nil
+        end
+      end
+
+      def index_by_name(objects)
+        objects.each_with_object({}) { |obj, hash| hash[obj.name] = obj }
+      end
+
+      def index_by_uri(objects)
+        objects.each_with_object({}) { |obj, hash| hash[obj.uri] = obj }
+      end
+    end
+  end
+end

data/lib/ask/mcp/native/messages.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Ask
+  module MCP
+    module Native
+      # JSON-RPC 2.0 message types for the Model Context Protocol.
+      module Messages
+        JSON_RPC_VERSION = "2.0"
+
+        class Request
+          attr_reader :id, :method, :params
+
+          def initialize(method:, params: nil, id: nil)
+            @id = id || SecureRandom.uuid
+            @method = method
+            @params = params
+          end
+
+          def to_h
+            h = {
+              jsonrpc: JSON_RPC_VERSION,
+              id: @id,
+              method: @method
+            }
+            h[:params] = @params if @params
+            h
+          end
+
+          def to_json(*args)
+            to_h.to_json(*args)
+          end
+        end
+
+        class Notification
+          attr_reader :method, :params
+
+          def initialize(method:, params: nil)
+            @method = method
+            @params = params
+          end
+
+          def to_h
+            h = {
+              jsonrpc: JSON_RPC_VERSION,
+              method: @method
+            }
+            h[:params] = @params if @params
+            h
+          end
+
+          def to_json(*args)
+            to_h.to_json(*args)
+          end
+        end
+
+        class Response
+          attr_reader :id, :result, :error
+
+          def initialize(id:, result: nil, error: nil)
+            @id = id
+            @result = result
+            @error = error
+          end
+
+          def success?
+            @error.nil?
+          end
+
+          def to_h
+            h = { jsonrpc: JSON_RPC_VERSION, id: @id }
+            if @error
+              h[:error] = {
+                code: @error[:code],
+                message: @error[:message]
+              }
+              h[:error][:data] = @error[:data] if @error[:data]
+            else
+              h[:result] = @result || {}
+            end
+            h
+          end
+
+          def to_json(*args)
+            to_h.to_json(*args)
+          end
+        end
+
+        module Parser
+          def self.parse(json_string)
+            data = JSON.parse(json_string, symbolize_names: true)
+            return data unless data.is_a?(Hash)
+
+            if data.key?(:id) && (data.key?(:result) || data.key?(:error))
+              Response.new(
+                id: data[:id],
+                result: data[:result],
+                error: data[:error]
+              )
+            elsif data.key?(:method) && data.key?(:id)
+              Request.new(
+                method: data[:method],
+                params: data[:params],
+                id: data[:id]
+              )
+            elsif data.key?(:method) && !data.key?(:id)
+              Notification.new(
+                method: data[:method],
+                params: data[:params]
+              )
+            else
+              data
+            end
+          end
+
+          def self.parse_response(json_string)
+            msg = parse(json_string)
+            raise ProtocolError, "Expected a Response, got #{msg.class}" unless msg.is_a?(Response)
+            msg
+          end
+
+          def self.parse_request(json_string)
+            msg = parse(json_string)
+            raise ProtocolError, "Expected a Request, got #{msg.class}" unless msg.is_a?(Request)
+            msg
+          end
+        end
+
+        # Standard JSON-RPC error codes
+        module ErrorCodes
+          PARSE_ERROR      = -32700
+          INVALID_REQUEST  = -32600
+          METHOD_NOT_FOUND = -32601
+          INVALID_PARAMS   = -32602
+          INTERNAL_ERROR   = -32603
+
+          # MCP-specific error codes
+          TOOL_NOT_FOUND      = -32000
+          RESOURCE_NOT_FOUND  = -32001
+          PROMPT_NOT_FOUND    = -32002
+          AUTH_ERROR          = -32003
+          CONNECTION_ERROR    = -32004
+          TIMEOUT_ERROR       = -32005
+
+          ERROR_MESSAGES = {
+            PARSE_ERROR      => "Parse error",
+            INVALID_REQUEST  => "Invalid request",
+            METHOD_NOT_FOUND => "Method not found",
+            INVALID_PARAMS   => "Invalid params",
+            INTERNAL_ERROR   => "Internal error",
+            TOOL_NOT_FOUND   => "Tool not found",
+            RESOURCE_NOT_FOUND => "Resource not found",
+            PROMPT_NOT_FOUND => "Prompt not found",
+            AUTH_ERROR       => "Authentication error",
+            CONNECTION_ERROR => "Connection error",
+            TIMEOUT_ERROR    => "Timeout error"
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/ask/mcp/prompt.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ask
+  module MCP
+    class Prompt
+      attr_reader :name, :description, :arguments
+
+      def initialize(name:, description: nil, arguments: [])
+        @name = name
+        @description = description
+        @arguments = arguments
+      end
+
+      def to_h
+        h = { name: @name }
+        h[:description] = @description if @description
+        h[:arguments] = @arguments if @arguments.any?
+        h
+      end
+
+      def self.from_h(hash)
+        new(
+          name: hash[:name] || hash["name"],
+          description: hash[:description] || hash["description"],
+          arguments: hash[:arguments] || hash["arguments"] || []
+        )
+      end
+    end
+  end
+end

data/lib/ask/mcp/resource.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Ask
+  module MCP
+    class Resource
+      attr_reader :uri, :name, :description, :mime_type
+
+      def initialize(uri:, name:, description: nil, mime_type: nil)
+        @uri = uri
+        @name = name
+        @description = description
+        @mime_type = mime_type
+      end
+
+      def to_h
+        h = { uri: @uri, name: @name }
+        h[:description] = @description if @description
+        h[:mimeType] = @mime_type if @mime_type
+        h
+      end
+
+      def self.from_h(hash)
+        new(
+          uri: hash[:uri] || hash["uri"],
+          name: hash[:name] || hash["name"],
+          description: hash[:description] || hash["description"],
+          mime_type: hash[:mimeType] || hash["mime_type"] || hash[:mime_type]
+        )
+      end
+    end
+  end
+end

data/lib/ask/mcp/server.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Ask
+  module MCP
+    class Server
+      attr_reader :name, :version, :capabilities, :tools, :resources, :prompts
+
+      def initialize(name:, version: "0.1.0", capabilities: {}, tools: {}, resources: {}, prompts: {})
+        @name = name
+        @version = version
+        @capabilities = capabilities
+        @tools = tools
+        @resources = resources
+        @prompts = prompts
+      end
+
+      def tool_names
+        @tools.keys
+      end
+
+      def resource_uris
+        @resources.keys
+      end
+
+      def prompt_names
+        @prompts.keys
+      end
+
+      def to_h
+        {
+          name: @name,
+          version: @version,
+          capabilities: @capabilities,
+          tools: @tools.values.map(&:to_h),
+          resources: @resources.values.map(&:to_h),
+          prompts: @prompts.values.map(&:to_h)
+        }
+      end
+    end
+  end
+end

data/lib/ask/mcp/tool.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Ask
+  module MCP
+    class Tool
+      attr_reader :name, :description, :input_schema
+
+      def initialize(name:, description: "", input_schema: {})
+        @name = name
+        @description = description
+        @input_schema = input_schema
+      end
+
+      def to_ask_tool
+        require "ask/tools/tool"
+
+        Ask::Tools::Tool.new(
+          name: @name,
+          description: @description,
+          parameters: @input_schema
+        )
+      end
+
+      def to_h
+        {
+          name: @name,
+          description: @description,
+          inputSchema: @input_schema
+        }
+      end
+
+      def self.from_h(hash)
+        new(
+          name: hash[:name] || hash["name"],
+          description: hash[:description] || hash["description"] || "",
+          input_schema: hash[:inputSchema] || hash["input_schema"] || hash[:input_schema] || hash["inputSchema"] || {}
+        )
+      end
+    end
+  end
+end

data/lib/ask/mcp/transport/sse.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Ask
+  module MCP
+    module Transport
+      class SSE
+        attr_reader :url
+
+        def initialize(url, options = {})
+          @url = url
+          @options = options
+          @running = false
+          @buffer = +""
+          @message_handlers = []
+          @http = nil
+          @response = nil
+          @post_url = nil
+          @reconnect_delay = options[:reconnect_delay] || 1.0
+          @max_reconnect_delay = options[:max_reconnect_delay] || 30.0
+          @reconnect_jitter = options[:reconnect_jitter] || 0.1
+          @max_retries = options[:max_retries] || 5
+          @retries = 0
+        end
+
+        def on_message(&block)
+          @message_handlers << block
+        end
+
+        def start
+          require "httpx"
+
+          @running = true
+          @retries = 0
+          @post_url = nil
+          connect_stream
+          self
+        end
+
+        def stop
+          @running = false
+          @response&.close
+          @http&.close
+        end
+
+        def send(message)
+          require "httpx"
+
+          data = message.is_a?(String) ? message : message.to_json
+          target = @post_url || @url
+
+          headers = { "Content-Type" => "application/json" }
+          headers.merge!(@options[:headers]) if @options[:headers]
+
+          http = HTTPX.with(headers:)
+          response = http.post(target, body: data)
+
+          unless response.status == 200 || response.status == 202 || response.status == 204
+            raise ConnectionError, "Failed to send message: #{response.status} #{response.body.to_s}"
+          end
+
+          response
+        rescue HTTPX::Error => e
+          raise ConnectionError, "Failed to send message: #{e.message}"
+        end
+
+        def running?
+          @running
+        end
+
+        def shutdown
+          stop
+        end
+
+        private
+
+        def connect_stream
+          return unless @running
+
+          @http = HTTPX.with(timeout: { request_timeout: @options[:timeout] || 300 })
+          @http = @http.with(headers: @options[:headers]) if @options[:headers]
+
+          @response = @http.get(@url)
+
+          unless @response.status == 200
+            raise ConnectionError, "SSE connection failed: #{@response.status}"
+          end
+
+          @retries = 0
+          @current_event = nil
+          @buffer = +""
+
+          @response.body.each do |chunk|
+            process_chunk(chunk)
+          end
+        rescue HTTPX::Error, ConnectionError, Errno::ECONNREFUSED, Errno::ECONNRESET => e
+          handle_disconnect(e)
+        end
+
+        def process_chunk(chunk)
+          @buffer << chunk
+          while (line = @buffer.slice!(/\A.*\n/))
+            line = line.strip
+            next if line.empty?
+
+            if line.start_with?("event: ")
+              @current_event = line[7..]
+            elsif line.start_with?("data: ")
+              data_line = line[6..]
+
+              case @current_event
+              when "endpoint"
+                @post_url = data_line.strip
+                @current_event = nil
+              when "message", nil
+                begin
+                  message = Native::Messages::Parser.parse(data_line)
+                  @message_handlers.each { |handler| handler.call(message) }
+                rescue JSON::ParserError
+                  # Skip non-JSON data
+                end
+                @current_event = nil
+              else
+                @current_event = nil
+              end
+            end
+          end
+        end
+
+        def handle_disconnect(error)
+          return unless @running
+
+          @retries += 1
+
+          if @retries > @max_retries
+            @message_handlers.each { |h| h.call(error) }
+            return
+          end
+
+          delay = calculate_backoff
+          sleep(delay)
+          connect_stream
+        end
+
+        def calculate_backoff
+          delay = [@reconnect_delay * (2 ** (@retries - 1)), @max_reconnect_delay].min
+          jitter = delay * @reconnect_jitter * (rand - 0.5) * 2
+          delay + jitter
+        end
+      end
+    end
+  end
+end