ruby_llm-mcp 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0de5a83b2962398c602fe95d3b1c606bf3c0d1b8367209b70f9ef1f41a7f1e2
-  data.tar.gz: 65c1a8c158efc387d9bec8ee67b701432cc605fd276647496d0825d0d83cafb3
+  metadata.gz: b6cf22dd6e681b51686e73f0149f91b0fd3a256ccbba1e3dd20461d0a92b370d
+  data.tar.gz: 8ed938f20b001c4879a409ab77944e6d8b5e53aa0062d6e499d3739355c5054d
 SHA512:
-  metadata.gz: 416161bdd8d22711c144dd7bf3460e27f01cd57f764ebc5d024748bcdcc4fcf279898da28fefcba1ae31546f8b001d48798c7f9e48a0c1bc7b1ad555e2334fcd
-  data.tar.gz: f9a6cbabf0e78aa89268c0cbbdaa2e07e9b33497cf47d1eab7282f60c6bfa161e4d5cbb7a1e6694de93ed18988318c1040ee0e3ffcd363b5d2d761e40158ce1b
+  metadata.gz: 817fa242ef9d4cd526ea8905093d6c548f36ffeb228ee3b0acfbb0fd80303ec69557493e9b0ee0b2419c0d5adddf79c2bda02ba577e7e90a0503fd9482444bc5
+  data.tar.gz: '09326061dfcdc66d963ef55740ad4d0d82c260ed1da6021229d6441c9c8f1c17af744fd90d9e865e9ddc209589f663c8c5a94aea020ca7bc189c41b668d58433'

data/README.md

@@ -8,7 +8,7 @@ This project is a Ruby client for the [Model Context Protocol (MCP)](https://mod
 
 ## Features
 
-- 🔌 **Multiple Transport Types**: Support for SSE (Server-Sent Events) and stdio transports
+- 🔌 **Multiple Transport Types**: Support for SSE (Server-Sent Events), Streamable HTTP, and stdio transports
 - 🛠️ **Tool Integration**: Automatically converts MCP tools into RubyLLM-compatible tools
 - 🔄 **Real-time Communication**: Efficient bidirectional communication with MCP servers
 - 🎯 **Simple API**: Easy-to-use interface that integrates seamlessly with RubyLLM
@@ -66,6 +66,16 @@ client = RubyLLM::MCP.client(
     env: { "NODE_ENV" => "production" }
   }
 )
+
+# Or connect via streamable HTTP
+client = RubyLLM::MCP.client(
+  name: "my-mcp-server",
+  transport_type: :streamable",
+  config: {
+    url: "http://localhost:8080/mcp",
+    headers: { "Authorization" => "Bearer your-token" }
+  }
+)
 ```
 
 ### Using MCP Tools with RubyLLM
@@ -87,6 +97,14 @@ response = chat.ask("Can you help me search for recent files in my project?")
 puts response
 ```
 
+### Support Complex Parameters
+
+If you want to support complex parameters, like an array of objects it currently requires a patch to RubyLLM itself. This is planned to be temporary until the RubyLLM is updated.
+
+```ruby
+RubyLLM::MCP.support_complex_parameters!
+```
+
 ### Streaming Responses with Tool Calls
 
 ```ruby
@@ -130,13 +148,28 @@ Best for web-based MCP servers or when you need HTTP-based communication:
 ```ruby
 client = RubyLLM::MCP.client(
   name: "web-mcp-server",
-  transport_type: "sse",
+  transport_type: :sse,
   config: {
     url: "https://your-mcp-server.com/mcp/sse"
   }
 )
 ```
 
+### Streamable HTTP
+
+Best for HTTP-based MCP servers that support streaming responses:
+
+```ruby
+client = RubyLLM::MCP.client(
+  name: "streaming-mcp-server",
+  transport_type: :streamable,
+  config: {
+    url: "https://your-mcp-server.com/mcp",
+    headers: { "Authorization" => "Bearer your-token" }
+  }
+)
+```
+
 ### Stdio
 
 Best for local MCP servers or command-line tools:
@@ -144,7 +177,7 @@ Best for local MCP servers or command-line tools:
 ```ruby
 client = RubyLLM::MCP.client(
   name: "local-mcp-server",
-  transport_type: "stdio",
+  transport_type: :stdio,
   config: {
     command: "python",
     args: ["-m", "my_mcp_server"],
@@ -156,10 +189,11 @@ client = RubyLLM::MCP.client(
 ## Configuration Options
 
 - `name`: A unique identifier for your MCP client
-- `transport_type`: Either `:sse` or `:stdio`
+- `transport_type`: Either `:sse`, `:streamable`, or `:stdio`
 - `request_timeout`: Timeout for requests in milliseconds (default: 8000)
 - `config`: Transport-specific configuration
   - For SSE: `{ url: "http://..." }`
+  - For Streamable: `{ url: "http://...", headers: {...} }`
   - For stdio: `{ command: "...", args: [...], env: {...} }`
 
 ## Development

data/lib/ruby_llm/mcp/capabilities.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Capabilities
+      attr_reader :capabilities
+
+      def initialize(capabilities)
+        @capabilities = capabilities
+      end
+
+      def resources_list_changed?
+        @capabilities.dig("resources", "listChanged") || false
+      end
+
+      def resource_subscribe?
+        @capabilities.dig("resources", "subscribe") || false
+      end
+
+      def tools_list_changed?
+        @capabilities.dig("tools", "listChanged") || false
+      end
+
+      def completion?
+        @capabilities["completion"].present?
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/client.rb

@@ -4,21 +4,30 @@ module RubyLLM
   module MCP
     class Client
       PROTOCOL_VERSION = "2025-03-26"
+      PV_2024_11_05 = "2024-11-05"
+
+      attr_reader :name, :config, :transport_type, :transport, :request_timeout, :reverse_proxy_url, :protocol_version,
+                  :capabilities
 
       def initialize(name:, transport_type:, request_timeout: 8000, reverse_proxy_url: nil, config: {})
         @name = name
         @config = config
+        @protocol_version = PROTOCOL_VERSION
+        @headers = config[:headers] || {}
+
         @transport_type = transport_type.to_sym
 
-        # TODO: Add streamable HTTP
         case @transport_type
         when :sse
-          @transport = RubyLLM::MCP::Transport::SSE.new(config[:url])
+          @transport = RubyLLM::MCP::Transport::SSE.new(@config[:url], headers: @headers)
         when :stdio
-          @transport = RubyLLM::MCP::Transport::Stdio.new(config[:command], args: config[:args], env: config[:env])
+          @transport = RubyLLM::MCP::Transport::Stdio.new(@config[:command], args: @config[:args], env: @config[:env])
+        when :streamable
+          @transport = RubyLLM::MCP::Transport::Streamable.new(@config[:url], headers: @headers)
         else
           raise "Invalid transport type: #{transport_type}"
         end
+        @capabilities = nil
 
         @request_timeout = request_timeout
         @reverse_proxy_url = reverse_proxy_url
@@ -27,8 +36,8 @@ module RubyLLM
         notification_request
       end
 
-      def request(body, wait_for_response: true)
-        @transport.request(body, wait_for_response: wait_for_response)
+      def request(body, **options)
+        @transport.request(body, **options)
       end
 
       def tools(refresh: false)
@@ -36,6 +45,16 @@ module RubyLLM
         @tools ||= fetch_and_create_tools
       end
 
+      def resources(refresh: false)
+        @resources = nil if refresh
+        @resources ||= fetch_and_create_resources
+      end
+
+      def resource_templates(refresh: false)
+        @resource_templates = nil if refresh
+        @resource_templates ||= fetch_and_create_resources(set_as_template: true)
+      end
+
       def execute_tool(name:, parameters:)
         response = execute_tool_request(name: name, parameters: parameters)
         result = response["result"]
@@ -45,22 +64,39 @@ module RubyLLM
         result["content"].map { |content| content["text"] }.join("\n")
       end
 
+      def resource_read_request(**args)
+        RubyLLM::MCP::Requests::ResourceRead.new(self, **args).call
+      end
+
+      def completion(**args)
+        RubyLLM::MCP::Requests::Completion.new(self, **args).call
+      end
+
       private
 
       def initialize_request
         @initialize_response = RubyLLM::MCP::Requests::Initialization.new(self).call
+        @capabilities = RubyLLM::MCP::Capabilities.new(@initialize_response["result"]["capabilities"])
       end
 
       def notification_request
-        @notification_response = RubyLLM::MCP::Requests::Notification.new(self).call
+        RubyLLM::MCP::Requests::Notification.new(self).call
       end
 
       def tool_list_request
-        @tool_request = RubyLLM::MCP::Requests::ToolList.new(self).call
+        RubyLLM::MCP::Requests::ToolList.new(self).call
+      end
+
+      def execute_tool_request(**args)
+        RubyLLM::MCP::Requests::ToolCall.new(self, **args).call
+      end
+
+      def resources_list_request
+        RubyLLM::MCP::Requests::ResourceList.new(self).call
       end
 
-      def execute_tool_request(name:, parameters:)
-        @execute_tool_response = RubyLLM::MCP::Requests::ToolCall.new(self, name: name, parameters: parameters).call
+      def resource_template_list_request
+        RubyLLM::MCP::Requests::ResourceTemplateList.new(self).call
       end
 
       def fetch_and_create_tools
@@ -71,6 +107,15 @@ module RubyLLM
           RubyLLM::MCP::Tool.new(self, tool)
         end
       end
+
+      def fetch_and_create_resources(set_as_template: false)
+        resources_response = resources_list_request
+        resources_response = resources_response["result"]["resources"]
+
+        @resources = resources_response.map do |resource|
+          RubyLLM::MCP::Resource.new(self, resource, template: set_as_template)
+        end
+      end
     end
   end
 end

data/lib/ruby_llm/mcp/errors.rb

@@ -3,7 +3,7 @@
 module RubyLLM
   module MCP
     module Errors
-      class TimeoutError < StandardError
+      class BaseError < StandardError
         attr_reader :message
 
         def initialize(message:)
@@ -11,6 +11,12 @@ module RubyLLM
           super(message)
         end
       end
+
+      class InvalidProtocolVersionError < BaseError; end
+
+      class SessionExpiredError < BaseError; end
+
+      class TimeoutError < BaseError; end
     end
   end
 end

data/lib/ruby_llm/mcp/parameter.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Parameter < RubyLLM::Parameter
+      attr_accessor :items, :properties
+    end
+  end
+end

data/lib/ruby_llm/mcp/providers/anthropic/complex_parameter_support.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Providers
+      module Anthropic
+        module ComplexParameterSupport
+          def clean_parameters(parameters)
+            parameters.transform_values do |param|
+              format = {
+                type: param.type,
+                description: param.description
+              }.compact
+
+              if param.type == "array"
+                format[:items] = param.items
+              elsif param.type == "object"
+                format[:properties] = clean_parameters(param.properties)
+              end
+
+              format
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+RubyLLM::Providers::Anthropic.extend(RubyLLM::MCP::Providers::Anthropic::ComplexParameterSupport)

data/lib/ruby_llm/mcp/providers/open_ai/complex_parameter_support.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Providers
+      module OpenAI
+        module ComplexParameterSupport
+          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.transform_values { |value| param_schema(value) }
+            end
+            format
+          end
+        end
+      end
+    end
+  end
+end
+
+RubyLLM::Providers::OpenAI.extend(RubyLLM::MCP::Providers::OpenAI::ComplexParameterSupport)

data/lib/ruby_llm/mcp/requests/completion.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class Completion
+        def initialize(client, type:, name:, argument:, value:)
+          @client = client
+          @type = type
+          @name = name
+          @argument = argument
+          @value = value
+        end
+
+        def call
+          @client.request(request_body)
+        end
+
+        private
+
+        def request_body
+          {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "completion/complete",
+            params: {
+              ref: {
+                type: ref_type,
+                name: @name
+              },
+              argument: {
+                name: @argument,
+                value: @value
+              }
+            }
+          }
+        end
+
+        def ref_type
+          case @type
+          when :prompt
+            "ref/prompt"
+          when :resource
+            "ref/resource"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/initialization.rb

@@ -12,14 +12,10 @@ class RubyLLM::MCP::Requests::Initialization < RubyLLM::MCP::Requests::Base
       jsonrpc: "2.0",
       method: "initialize",
       params: {
-        protocolVersion: RubyLLM::MCP::Client::PROTOCOL_VERSION,
-        capabilities: {
-          tools: {
-            listChanged: true
-          }
-        },
+        protocolVersion: @client.protocol_version,
+        capabilities: {},
         clientInfo: {
-          name: "RubyLLM MCP Client",
+          name: "RubyLLM-MCP Client",
           version: RubyLLM::MCP::VERSION
         }
       }

data/lib/ruby_llm/mcp/requests/notification.rb

@@ -2,7 +2,7 @@
 
 class RubyLLM::MCP::Requests::Notification < RubyLLM::MCP::Requests::Base
   def call
-    client.request(notification_body, wait_for_response: false)
+    client.request(notification_body, add_id: false, wait_for_response: false)
   end
 
   def notification_body

data/lib/ruby_llm/mcp/requests/resource_list.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ResourceList < Base
+        def call
+          client.request(resource_list_body)
+        end
+
+        def resource_list_body
+          {
+            jsonrpc: "2.0",
+            method: "resources/list",
+            params: {}
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/resource_read.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ResourceRead
+        attr_reader :client, :uri
+
+        def initialize(client, uri:)
+          @client = client
+          @uri = uri
+        end
+
+        def call
+          client.request(reading_resource_body(uri))
+        end
+
+        def reading_resource_body(uri)
+          {
+            jsonrpc: "2.0",
+            method: "resources/read",
+            params: {
+              uri: uri
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/resource_template_list.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ResourceTemplateList < Base
+        def call
+          client.request(resource_template_list_body)
+        end
+
+        def resource_template_list_body
+          {
+            jsonrpc: "2.0",
+            method: "resources/templates/list",
+            params: {}
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/resource.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Resource
+      attr_reader :uri, :name, :description, :mime_type, :mcp_client, :template
+
+      def initialize(mcp_client, resource, template: false)
+        @mcp_client = mcp_client
+        @uri = resource["uri"]
+        @name = resource["name"]
+        @description = resource["description"]
+        @mime_type = resource["mimeType"]
+        @template = template
+      end
+
+      def content(parsable_information: {})
+        response = if template?
+                     templated_uri = apply_template(@uri, parsable_information)
+
+                     read_response(uri: templated_uri)
+                   else
+                     read_response
+                   end
+
+        response.dig("result", "contents", 0, "text") ||
+          response.dig("result", "contents", 0, "blob")
+      end
+
+      def arguments_search(argument, value)
+        if template? && @mcp_client.capabilities.completion?
+          response = @mcp_client.completion(type: :resource, name: @name, argument: argument, value: value)
+          response = response.dig("result", "completion")
+
+          Struct.new(:arg_values, :total, :has_more)
+                .new(response["values"], response["total"], response["hasMore"])
+        else
+          []
+        end
+      end
+
+      def template?
+        @template
+      end
+
+      private
+
+      def read_response(uri: @uri)
+        parsed = URI.parse(uri)
+        case parsed.scheme
+        when "http", "https"
+          fetch_uri_content(uri)
+        else # file:// or git://
+          @read_response ||= @mcp_client.resource_read_request(uri: uri)
+        end
+      end
+
+      def fetch_uri_content(uri)
+        response = Faraday.get(uri)
+        { "result" => { "contents" => [{ "text" => response.body }] } }
+      end
+
+      def apply_template(uri, parsable_information)
+        uri.gsub(/\{(\w+)\}/) do
+          parsable_information[::Regexp.last_match(1).to_sym] || "{#{::Regexp.last_match(1)}}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/tool.rb

@@ -5,21 +5,6 @@ module RubyLLM
     class Tool < RubyLLM::Tool
       attr_reader :name, :description, :parameters, :mcp_client, :tool_response
 
-      # @tool_response = {
-      #   name: string;          // Unique identifier for the tool
-      #   description?: string;  // Human-readable description
-      #   inputSchema: {         // JSON Schema for the tool's parameters
-      #     type: "object",
-      #     properties: { ... }  // Tool-specific parameters
-      #   },
-      #   annotations?: {        // Optional hints about tool behavior
-      #     title?: string;      // Human-readable title for the tool
-      #     readOnlyHint?: boolean;    // If true, the tool does not modify its environment
-      #     destructiveHint?: boolean; // If true, the tool may perform destructive updates
-      #     idempotentHint?: boolean;  // If true, repeated calls with same args have no additional effect
-      #     openWorldHint?: boolean;   // If true, tool interacts with external entities
-      #   }
-      # }
       def initialize(mcp_client, tool_response)
         super()
         @mcp_client = mcp_client
@@ -41,13 +26,20 @@ module RubyLLM
       def create_parameters(input_schema)
         params = {}
         input_schema["properties"].each_key do |key|
-          param = RubyLLM::Parameter.new(
+          param = RubyLLM::MCP::Parameter.new(
             key,
             type: input_schema["properties"][key]["type"],
             desc: input_schema["properties"][key]["description"],
             required: input_schema["properties"][key]["required"]
           )
 
+          if param.type == "array"
+            param.items = input_schema["properties"][key]["items"]
+          elsif param.type == "object"
+            properties = create_parameters(input_schema["properties"][key]["properties"])
+            param.properties = properties
+          end
+
           params[key] = param
         end
 

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

@@ -14,7 +14,12 @@ module RubyLLM
 
         def initialize(url, headers: {})
           @event_url = url
-          @messages_url = url.gsub("sse", "messages")
+          @messages_url = nil
+
+          uri = URI.parse(url)
+          @root_url = "#{uri.scheme}://#{uri.host}"
+          @root_url += ":#{uri.port}" if uri.port != uri.default_port
+
           @client_id = SecureRandom.uuid
           @headers = headers.merge({
                                      "Accept" => "text/event-stream",
@@ -35,11 +40,14 @@ module RubyLLM
           start_sse_listener
         end
 
-        def request(body, wait_for_response: true)
+        # rubocop:disable Metrics/MethodLength
+        def request(body, add_id: true, wait_for_response: true)
           # Generate a unique request ID
-          @id_mutex.synchronize { @id_counter += 1 }
-          request_id = @id_counter
-          body["id"] = request_id
+          if add_id
+            @id_mutex.synchronize { @id_counter += 1 }
+            request_id = @id_counter
+            body["id"] = request_id
+          end
 
           # Create a queue for this request's response
           response_queue = Queue.new
@@ -83,6 +91,7 @@ module RubyLLM
             raise RubyLLM::MCP::Errors::TimeoutError.new(message: "Request timed out after 30 seconds")
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def close
           @running = false
@@ -96,17 +105,35 @@ module RubyLLM
           @connection_mutex.synchronize do
             return if sse_thread_running?
 
+            response_queue = Queue.new
+            @pending_mutex.synchronize do
+              @pending_requests["endpoint"] = response_queue
+            end
+
             @sse_thread = Thread.new do
               listen_for_events while @running
             end
-
             @sse_thread.abort_on_exception = true
-            sleep 0.1 # Wait for the SSE connection to be established
+
+            endpoint = response_queue.pop
+            set_message_endpoint(endpoint)
+
+            @pending_mutex.synchronize { @pending_requests.delete("endpoint") }
           end
         end
 
+        def set_message_endpoint(endpoint)
+          uri = URI.parse(endpoint)
+
+          @messages_url = if uri.host.nil?
+                            "#{@root_url}#{endpoint}"
+                          else
+                            endpoint
+                          end
+        end
+
         def sse_thread_running?
-          @sse_thread && @sse_thread.alive?
+          @sse_thread&.alive?
         end
 
         def listen_for_events
@@ -160,14 +187,19 @@ module RubyLLM
         def process_event(raw_event)
           return if raw_event[:data].nil?
 
-          event = begin
-            JSON.parse(raw_event[:data])
-          rescue StandardError
-            nil
-          end
-          return if event.nil?
+          if raw_event[:event] == "endpoint"
+            request_id = "endpoint"
+            event = raw_event[:data]
+          else
+            event = begin
+              JSON.parse(raw_event[:data])
+            rescue StandardError
+              nil
+            end
+            return if event.nil?
 
-          request_id = event["id"]&.to_s
+            request_id = event["id"]&.to_s
+          end
 
           @pending_mutex.synchronize do
             if request_id && @pending_requests.key?(request_id)

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

@@ -14,10 +14,9 @@ module RubyLLM
         def initialize(command, args: [], env: {})
           @command = command
           @args = args
-          @env = env
+          @env = env || {}
           @client_id = SecureRandom.uuid
 
-          # Initialize state variables
           @id_counter = 0
           @id_mutex = Mutex.new
           @pending_requests = {}
@@ -25,17 +24,16 @@ module RubyLLM
           @running = true
           @reader_thread = nil
 
-          # Start the process
           start_process
         end
 
-        def request(body, wait_for_response: true)
-          # Generate a unique request ID
-          @id_mutex.synchronize { @id_counter += 1 }
-          request_id = @id_counter
-          body["id"] = request_id
+        def request(body, add_id: true, wait_for_response: true)
+          if add_id
+            @id_mutex.synchronize { @id_counter += 1 }
+            request_id = @id_counter
+            body["id"] = request_id
+          end
 
-          # Create a queue for this request's response
           response_queue = Queue.new
           if wait_for_response
             @pending_mutex.synchronize do
@@ -43,7 +41,6 @@ module RubyLLM
             end
           end
 
-          # Send the request to the process
           begin
             @stdin.puts(JSON.generate(body))
             @stdin.flush
@@ -55,7 +52,6 @@ module RubyLLM
 
           return unless wait_for_response
 
-          # Wait for the response with matching ID using a timeout
           begin
             Timeout.timeout(30) do
               response_queue.pop
@@ -69,21 +65,18 @@ module RubyLLM
         def close
           @running = false
 
-          # Close stdin to signal the process to exit
           begin
             @stdin&.close
           rescue StandardError
             nil
           end
 
-          # Wait for process to exit
           begin
             @wait_thread&.join(1)
           rescue StandardError
             nil
           end
 
-          # Close remaining IO streams
           begin
             @stdout&.close
           rescue StandardError
@@ -95,7 +88,6 @@ module RubyLLM
             nil
           end
 
-          # Wait for reader thread to finish
           begin
             @reader_thread&.join(1)
           rescue StandardError
@@ -112,13 +104,14 @@ module RubyLLM
         private
 
         def start_process
-          # Close any existing process
           close if @stdin || @stdout || @stderr || @wait_thread
 
-          # Start a new process
-          @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(@env, @command, *@args)
+          @stdin, @stdout, @stderr, @wait_thread = if @env.empty?
+                                                     Open3.popen3(@command, *@args)
+                                                   else
+                                                     Open3.popen3(environment_string, @command, *@args)
+                                                   end
 
-          # Start a thread to read responses
           start_reader_thread
         end
 
@@ -137,13 +130,9 @@ module RubyLLM
                   next
                 end
 
-                # Read a line from the process
                 line = @stdout.gets
-
-                # Skip empty lines
                 next unless line && !line.strip.empty?
 
-                # Process the response
                 process_response(line.strip)
               rescue IOError, Errno::EPIPE => e
                 puts "Reader error: #{e.message}. Restarting in 1 second..."
@@ -160,19 +149,13 @@ module RubyLLM
         end
 
         def process_response(line)
-          # Try to parse the response as JSON
           response = begin
             JSON.parse(line)
           rescue JSON::ParserError => e
-            puts "Error parsing response as JSON: #{e.message}"
-            puts "Raw response: #{line}"
-            return
+            raise "Error parsing response as JSON: #{e.message}\nRaw response: #{line}"
           end
-
-          # Extract the request ID
           request_id = response["id"]&.to_s
 
-          # Find and fulfill the matching request
           @pending_mutex.synchronize do
             if request_id && @pending_requests.key?(request_id)
               response_queue = @pending_requests.delete(request_id)
@@ -180,6 +163,10 @@ module RubyLLM
             end
           end
         end
+
+        def environment_string
+          @env.map { |key, value| "#{key}=#{value}" }.join(" ")
+        end
       end
     end
   end

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.1"
+    VERSION = "0.1.0"
   end
 end

data/lib/ruby_llm/mcp.rb

@@ -10,8 +10,15 @@ loader.setup
 
 module RubyLLM
   module MCP
-    def self.client(*args, **kwargs)
+    module_function
+
+    def client(*args, **kwargs)
       @client ||= Client.new(*args, **kwargs)
     end
+
+    def support_complex_parameters!
+      require_relative "mcp/providers/open_ai/complex_parameter_support"
+      require_relative "mcp/providers/anthropic/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.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Patrick Vice
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-22 00:00:00.000000000 Z
+date: 2025-06-11 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
@@ -108,13 +108,22 @@ files:
 - LICENSE
 - README.md
 - lib/ruby_llm/mcp.rb
+- lib/ruby_llm/mcp/capabilities.rb
 - lib/ruby_llm/mcp/client.rb
 - lib/ruby_llm/mcp/errors.rb
+- lib/ruby_llm/mcp/parameter.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/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
@@ -146,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A RubyLLM MCP Client