ruby_llm-mcp 0.0.2 → 0.2.0

data/lib/ruby_llm/mcp/transport/streamable.rb

@@ -1,20 +1,290 @@
 # frozen_string_literal: true
 
+require "json"
+require "uri"
+require "faraday"
+require "timeout"
+require "securerandom"
+
 module RubyLLM
   module MCP
     module Transport
       class Streamable
+        attr_reader :headers, :id, :session_id
+
         def initialize(url, headers: {})
           @url = url
-          @headers = headers
+          @client_id = SecureRandom.uuid
+          @session_id = nil
+          @base_headers = headers.merge({
+                                          "Content-Type" => "application/json",
+                                          "Accept" => "application/json, text/event-stream",
+                                          "Connection" => "keep-alive",
+                                          "X-CLIENT-ID" => @client_id
+                                        })
+
+          @id_counter = 0
+          @id_mutex = Mutex.new
+          @pending_requests = {}
+          @pending_mutex = Mutex.new
+          @running = true
+          @sse_streams = {}
+          @sse_mutex = Mutex.new
+
+          # Initialize HTTP connection
+          @connection = create_connection
         end
 
-        def request(messages)
-          # TODO: Implement streaming
+        def request(body, add_id: true, wait_for_response: true)
+          # Generate a unique request ID for requests
+          if add_id && body.is_a?(Hash) && !body.key?("id")
+            @id_mutex.synchronize { @id_counter += 1 }
+            body["id"] = @id_counter
+          end
+
+          request_id = body.is_a?(Hash) ? body["id"] : nil
+          is_initialization = body.is_a?(Hash) && body["method"] == "initialize"
+
+          # Create a queue for this request's response if needed
+          response_queue = setup_response_queue(request_id, wait_for_response)
+
+          # Send the HTTP request
+          response = send_http_request(body, request_id, is_initialization: is_initialization)
+
+          # Handle different response types based on content
+          handle_response(response, request_id, response_queue, wait_for_response)
         end
 
         def close
-          # TODO: Implement closing
+          @running = false
+          @sse_mutex.synchronize do
+            @sse_streams.each_value(&:close)
+            @sse_streams.clear
+          end
+          @connection&.close if @connection.respond_to?(:close)
+          @connection = nil
+        end
+
+        def terminate_session
+          return unless @session_id
+
+          begin
+            response = @connection.delete do |req|
+              build_headers.each { |key, value| req.headers[key] = value }
+            end
+            @session_id = nil if response.status == 200
+          rescue StandardError => e
+            # Server may not support session termination (405), which is allowed
+            puts "Warning: Failed to terminate session: #{e.message}"
+          end
+        end
+
+        private
+
+        def create_connection
+          Faraday.new(url: @url) do |f|
+            f.options.timeout = 300
+            f.options.open_timeout = 10
+          end
+        end
+
+        def build_headers
+          headers = @base_headers.dup
+          headers["Mcp-Session-Id"] = @session_id if @session_id
+          headers
+        end
+
+        def build_initialization_headers
+          @base_headers.dup
+        end
+
+        def setup_response_queue(request_id, wait_for_response)
+          response_queue = Queue.new
+          if wait_for_response && request_id
+            @pending_mutex.synchronize do
+              @pending_requests[request_id.to_s] = response_queue
+            end
+          end
+          response_queue
+        end
+
+        def send_http_request(body, request_id, is_initialization: false)
+          @connection.post do |req|
+            headers = is_initialization ? build_initialization_headers : build_headers
+            headers.each { |key, value| req.headers[key] = value }
+            req.body = JSON.generate(body)
+          end
+        rescue StandardError => e
+          @pending_mutex.synchronize { @pending_requests.delete(request_id.to_s) } if request_id
+          raise e
+        end
+
+        def handle_response(response, request_id, response_queue, wait_for_response)
+          case response.status
+          when 200
+            handle_200_response(response, request_id, response_queue, wait_for_response)
+          when 202
+            # Accepted - for notifications/responses only, no body expected
+            nil
+          when 400..499
+            handle_client_error(response)
+          when 404
+            handle_session_expired
+          else
+            raise "HTTP request failed: #{response.status} - #{response.body}"
+          end
+        rescue StandardError => e
+          @pending_mutex.synchronize { @pending_requests.delete(request_id.to_s) } if request_id
+          raise e
+        end
+
+        def handle_200_response(response, request_id, response_queue, wait_for_response)
+          content_type = response.headers["content-type"]
+
+          if content_type&.include?("text/event-stream")
+            handle_sse_response(response, request_id, response_queue, wait_for_response)
+          elsif content_type&.include?("application/json")
+            handle_json_response(response, request_id, response_queue, wait_for_response)
+          else
+            raise "Unexpected content type: #{content_type}"
+          end
+        end
+
+        def handle_sse_response(response, request_id, response_queue, wait_for_response)
+          # Extract session ID from initial response if present
+          extract_session_id(response)
+
+          if wait_for_response && request_id
+            # Process SSE stream for this specific request
+            process_sse_for_request(response.body, request_id.to_s, response_queue)
+            # Wait for the response with timeout
+            wait_for_response_with_timeout(request_id.to_s, response_queue)
+          else
+            # Process general SSE stream
+            process_sse_stream(response.body)
+            nil
+          end
+        end
+
+        def handle_json_response(response, request_id, response_queue, wait_for_response)
+          # Extract session ID from response if present
+          extract_session_id(response)
+
+          begin
+            json_response = JSON.parse(response.body)
+
+            if wait_for_response && request_id && response_queue
+              @pending_mutex.synchronize { @pending_requests.delete(request_id.to_s) }
+              return json_response
+            end
+
+            json_response
+          rescue JSON::ParserError => e
+            raise "Invalid JSON response: #{e.message}"
+          end
+        end
+
+        def extract_session_id(response)
+          session_id = response.headers["Mcp-Session-Id"]
+          @session_id = session_id if session_id
+        end
+
+        def handle_client_error(response)
+          begin
+            error_body = JSON.parse(response.body)
+            if error_body.is_a?(Hash) && error_body["error"]
+              error_message = error_body["error"]["message"] || error_body["error"]["code"]
+
+              if error_message.to_s.downcase.include?("session")
+                raise "Server error: #{error_message} (Current session ID: #{@session_id || 'none'})"
+              end
+
+              raise "Server error: #{error_message}"
+
+            end
+          rescue JSON::ParserError
+            # Fall through to generic error
+          end
+
+          raise "HTTP client error: #{response.status} - #{response.body}"
+        end
+
+        def handle_session_expired
+          @session_id = nil
+          raise RubyLLM::MCP::Errors::SessionExpiredError.new(
+            message: "Session expired, re-initialization required"
+          )
+        end
+
+        def process_sse_for_request(sse_body, request_id, response_queue)
+          Thread.new do
+            process_sse_events(sse_body) do |event_data|
+              if event_data.is_a?(Hash) && event_data["id"]&.to_s == request_id
+                response_queue.push(event_data)
+                @pending_mutex.synchronize { @pending_requests.delete(request_id) }
+                break # Found our response, stop processing
+              end
+            end
+          rescue StandardError => e
+            puts "Error processing SSE stream: #{e.message}"
+            response_queue.push({ "error" => { "message" => e.message } })
+          end
+        end
+
+        def process_sse_stream(sse_body)
+          Thread.new do
+            process_sse_events(sse_body) do |event_data|
+              # Handle server-initiated requests/notifications
+              handle_server_message(event_data) if event_data.is_a?(Hash)
+            end
+          rescue StandardError => e
+            puts "Error processing SSE stream: #{e.message}"
+          end
+        end
+
+        def process_sse_events(sse_body)
+          event_buffer = ""
+          event_id = nil
+
+          sse_body.each_line do |line|
+            line = line.strip
+
+            if line.empty?
+              # End of event, process accumulated data
+              unless event_buffer.empty?
+                begin
+                  event_data = JSON.parse(event_buffer)
+                  yield event_data
+                rescue JSON::ParserError
+                  puts "Warning: Failed to parse SSE event data: #{event_buffer}"
+                end
+                event_buffer = ""
+              end
+            elsif line.start_with?("id:")
+              event_id = line[3..].strip
+            elsif line.start_with?("data:")
+              data = line[5..].strip
+              event_buffer += data
+            elsif line.start_with?("event:")
+              # Event type - could be used for different message types
+              # For now, we treat all as data events
+            end
+          end
+        end
+
+        def handle_server_message(message)
+          # Handle server-initiated requests and notifications
+          # This would typically be passed to a message handler
+          puts "Received server message: #{message.inspect}"
+        end
+
+        def wait_for_response_with_timeout(request_id, response_queue)
+          Timeout.timeout(30) do
+            response_queue.pop
+          end
+        rescue Timeout::Error
+          @pending_mutex.synchronize { @pending_requests.delete(request_id.to_s) }
+          raise RubyLLM::MCP::Errors::TimeoutError.new(message: "Request timed out after 30 seconds")
         end
       end
     end

data/lib/ruby_llm/mcp/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module MCP
-    VERSION = "0.0.2"
+    VERSION = "0.2.0"
   end
 end

data/lib/ruby_llm/mcp.rb

@@ -2,6 +2,7 @@
 
 require "ruby_llm"
 require "zeitwerk"
+require_relative "chat"
 
 loader = Zeitwerk::Loader.for_gem_extension(RubyLLM)
 loader.inflector.inflect("mcp" => "MCP")
@@ -17,8 +18,9 @@ module RubyLLM
     end
 
     def support_complex_parameters!
-      require_relative "providers/open_ai/complex_parameter_support"
-      require_relative "providers/anthropic/complex_parameter_support"
+      require_relative "mcp/providers/open_ai/complex_parameter_support"
+      require_relative "mcp/providers/anthropic/complex_parameter_support"
+      require_relative "mcp/providers/gemini/complex_parameter_support"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-mcp
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Patrick Vice
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-24 00:00:00.000000000 Z
+date: 2025-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -107,23 +107,35 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- lib/ruby_llm/chat.rb
 - lib/ruby_llm/mcp.rb
+- lib/ruby_llm/mcp/attachment.rb
+- lib/ruby_llm/mcp/capabilities.rb
 - lib/ruby_llm/mcp/client.rb
+- lib/ruby_llm/mcp/completion.rb
+- lib/ruby_llm/mcp/content.rb
 - lib/ruby_llm/mcp/errors.rb
 - lib/ruby_llm/mcp/parameter.rb
+- lib/ruby_llm/mcp/prompt.rb
 - lib/ruby_llm/mcp/providers/anthropic/complex_parameter_support.rb
 - lib/ruby_llm/mcp/providers/open_ai/complex_parameter_support.rb
 - lib/ruby_llm/mcp/requests/base.rb
+- lib/ruby_llm/mcp/requests/completion.rb
 - lib/ruby_llm/mcp/requests/initialization.rb
 - lib/ruby_llm/mcp/requests/notification.rb
+- lib/ruby_llm/mcp/requests/prompt_call.rb
+- lib/ruby_llm/mcp/requests/prompt_list.rb
+- lib/ruby_llm/mcp/requests/resource_list.rb
+- lib/ruby_llm/mcp/requests/resource_read.rb
+- lib/ruby_llm/mcp/requests/resource_template_list.rb
 - lib/ruby_llm/mcp/requests/tool_call.rb
 - lib/ruby_llm/mcp/requests/tool_list.rb
+- lib/ruby_llm/mcp/resource.rb
 - lib/ruby_llm/mcp/tool.rb
 - lib/ruby_llm/mcp/transport/sse.rb
 - lib/ruby_llm/mcp/transport/stdio.rb
 - lib/ruby_llm/mcp/transport/streamable.rb
 - lib/ruby_llm/mcp/version.rb
-- lib/ruby_llm/overrides.rb
 homepage: https://github.com/patvice/ruby_llm-mcp
 licenses:
 - MIT
@@ -143,7 +155,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.1.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/ruby_llm/overrides.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module ToolsComplexParametersSupport
-    def param_schema(param)
-      format = {
-        type: param.type,
-        description: param.description
-      }.compact
-
-      if param.type == "array"
-        format[:items] = param.items
-      elsif param.type == "object"
-        format[:properties] = param.properties
-      end
-      format
-    end
-  end
-end
-
-RubyLLM::Providers::OpenAI.extend(RubyLLM::ToolsComplexParametersSupport)