ruby_llm-mcp 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a516cd88de84929d95dbaaea467780ba499dc8362001a02d00ac0c8672107506
-  data.tar.gz: b852e278be156403a32454a00fa4ad450491d219d6243d9629098680576056d2
+  metadata.gz: d19acd8152ac9ce9f7991474d6ff590175512f2e5f6524acf11e1e011e4a312c
+  data.tar.gz: 4ad593f7c6d7c5d6c5f225c7c6466226e0ff71f412c53e4542af2a65b9b59299
 SHA512:
-  metadata.gz: a63c3650a2db47782d7db7eae32feec794302e63f2fe9967a584d1253fb42de75dfe004c87ba8758e9c09d06be856dc0d645183d0fc5b80e18a0cb294c5cda68
-  data.tar.gz: a89b6bffe3d03b95a9b2734c39f8b6152c7a07f945a9fe70f6eb3f3cb5423939a4fa7e16de2db94e5b01acdc82fde6b0d0d7eadcf4ce94ebd91a6654fa65565f
+  metadata.gz: 2b012fa00eaf0b132de3f716cd0e20045ef6188327dbb35770794bd0d6955d5f3396854718d8ae12ca5a09752aa5ce26bb7b347f4241ca7a4d243ca8c4ac6097
+  data.tar.gz: 7c0684175c0032fdac8a5ec1a5e1acb09d16fb5bb4fc81b64b12984a30e2e74ff96e6929dcc8d16780820febe871d151d1da41e00d7abf526c29f7110cb80143

data/lib/ruby_llm/mcp/auth/client_registrar.rb

@@ -123,7 +123,8 @@ module RubyLLM
         def parse_registered_metadata(data, redirect_uri)
           ClientMetadata.new(
             redirect_uris: data["redirect_uris"] || [redirect_uri],
-            token_endpoint_auth_method: data["token_endpoint_auth_method"] || "none",
+            token_endpoint_auth_method: data["token_endpoint_auth_method"] ||
+                                      (data["client_secret"] ? "client_secret_post" : "none"),
             grant_types: data["grant_types"] || %w[authorization_code refresh_token],
             response_types: data["response_types"] || ["code"],
             scope: data["scope"],

data/lib/ruby_llm/mcp/auth/token_manager.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "base64"
+require "uri"
+
 module RubyLLM
   module MCP
     module Auth
@@ -26,8 +29,8 @@ module RubyLLM
           registered_redirect_uri = client_info.metadata.redirect_uris.first
           params = build_auth_code_params(client_info, code, pkce, registered_redirect_uri, server_url)
 
-          response = post_token_exchange(server_metadata, params)
-          response = retry_if_redirect_mismatch(response, server_metadata, params, registered_redirect_uri)
+          response = post_token_exchange(server_metadata, params, client_info)
+          response = retry_if_redirect_mismatch(response, server_metadata, params, registered_redirect_uri, client_info)
 
           validate_token_response!(response, "Token exchange")
           parse_token_response(response)
@@ -45,12 +48,11 @@ module RubyLLM
           params = {
             grant_type: "client_credentials",
             client_id: client_info.client_id,
-            client_secret: client_info.client_secret,
             scope: scope,
             resource: server_url
           }.compact
 
-          response = post_token_exchange(server_metadata, params)
+          response = post_token_exchange(server_metadata, params, client_info)
           validate_token_response!(response, "Token exchange")
           parse_token_response(response)
         end
@@ -67,7 +69,7 @@ module RubyLLM
           logger.debug("Refreshing access token")
 
           params = build_refresh_params(client_info, token, server_url)
-          response = post_token_refresh(server_metadata, params)
+          response = post_token_refresh(server_metadata, params, client_info)
 
           # Return nil on error responses
           return nil if response.is_a?(HTTPX::ErrorResponse)
@@ -100,7 +102,7 @@ module RubyLLM
         # @param server_url [String] MCP server URL
         # @return [Hash] token exchange parameters
         def build_auth_code_params(client_info, code, pkce, redirect_uri, server_url)
-          params = {
+          {
             grant_type: "authorization_code",
             code: code,
             redirect_uri: redirect_uri,
@@ -108,9 +110,6 @@ module RubyLLM
             code_verifier: pkce.code_verifier,
             resource: server_url
           }
-
-          add_client_secret_if_needed(params, client_info)
-          params
         end
 
         # Build parameters for token refresh
@@ -119,49 +118,65 @@ module RubyLLM
         # @param server_url [String] MCP server URL
         # @return [Hash] refresh parameters
         def build_refresh_params(client_info, token, server_url)
-          params = {
+          {
             grant_type: "refresh_token",
             refresh_token: token.refresh_token,
             client_id: client_info.client_id,
             resource: server_url
           }
-
-          add_client_secret_if_needed(params, client_info)
-          params
         end
 
-        # Add client secret to params if needed
-        # @param params [Hash] token request parameters
-        # @param client_info [ClientInfo] client info
-        def add_client_secret_if_needed(params, client_info)
+        # Apply client authentication per RFC 6749 §2.3
+        # Supports "client_secret_post" (secret in body), "client_secret_basic" (HTTP Basic),
+        # and "none" (public client, no secret sent).
+        # @param params [Hash] token request form parameters (mutated in place)
+        # @param headers [Hash] HTTP headers (mutated in place)
+        # @param client_info [ClientInfo] client info with secret and auth method
+        def apply_client_auth!(params, headers, client_info)
           return unless client_info.client_secret
-          return unless client_info.metadata.token_endpoint_auth_method == "client_secret_post"
 
-          params[:client_secret] = client_info.client_secret
+          case client_auth_method(client_info)
+          when "client_secret_post"
+            params[:client_secret] = client_info.client_secret
+          when "client_secret_basic"
+            client_id = URI.encode_www_form_component(client_info.client_id)
+            client_secret = URI.encode_www_form_component(client_info.client_secret)
+            credentials = Base64.strict_encode64("#{client_id}:#{client_secret}")
+            headers["Authorization"] = "Basic #{credentials}"
+          end
+        end
+
+        # Resolve the client authentication method, including registrations cached by older versions.
+        # Older versions stored an omitted method as "none", even when the server returned a secret.
+        # @param client_info [ClientInfo] client info with secret and auth method
+        # @return [String, nil] effective token endpoint authentication method
+        def client_auth_method(client_info)
+          auth_method = client_info.metadata&.token_endpoint_auth_method
+          return "client_secret_post" if client_info.client_secret && [nil, "none"].include?(auth_method)
+
+          auth_method
         end
 
         # Post token exchange request
         # @param server_metadata [ServerMetadata] server metadata
         # @param params [Hash] form parameters
+        # @param client_info [ClientInfo, nil] client info for authentication
         # @return [HTTPX::Response] HTTP response
-        def post_token_exchange(server_metadata, params)
-          http_client.post(
-            server_metadata.token_endpoint,
-            headers: { "Content-Type" => "application/x-www-form-urlencoded" },
-            form: params
-          )
+        def post_token_exchange(server_metadata, params, client_info = nil)
+          headers = { "Content-Type" => "application/x-www-form-urlencoded" }
+          apply_client_auth!(params, headers, client_info) if client_info
+          http_client.post(server_metadata.token_endpoint, headers:, form: params)
         end
 
         # Post token refresh request
         # @param server_metadata [ServerMetadata] server metadata
         # @param params [Hash] form parameters
+        # @param client_info [ClientInfo, nil] client info for authentication
         # @return [HTTPX::Response] HTTP response
-        def post_token_refresh(server_metadata, params)
-          response = http_client.post(
-            server_metadata.token_endpoint,
-            headers: { "Content-Type" => "application/x-www-form-urlencoded" },
-            form: params
-          )
+        def post_token_refresh(server_metadata, params, client_info = nil)
+          headers = { "Content-Type" => "application/x-www-form-urlencoded" }
+          apply_client_auth!(params, headers, client_info) if client_info
+          response = http_client.post(server_metadata.token_endpoint, headers:, form: params)
 
           if response.is_a?(HTTPX::ErrorResponse)
             logger.warn("Token refresh failed: #{response.error&.message || 'Request failed'}")
@@ -176,8 +191,9 @@ module RubyLLM
         # @param server_metadata [ServerMetadata] server metadata
         # @param params [Hash] exchange parameters
         # @param registered_redirect_uri [String] registered redirect URI
+        # @param client_info [ClientInfo] client info for authentication
         # @return [HTTPX::Response] response (possibly retried)
-        def retry_if_redirect_mismatch(response, server_metadata, params, registered_redirect_uri)
+        def retry_if_redirect_mismatch(response, server_metadata, params, registered_redirect_uri, client_info)
           # Don't retry on error responses
           return response if response.is_a?(HTTPX::ErrorResponse)
           return response if response.status == 200
@@ -188,7 +204,7 @@ module RubyLLM
 
           logger.warn("Redirect URI mismatch, retrying with: #{redirect_hint[:expected]}")
           params[:redirect_uri] = redirect_hint[:expected]
-          post_token_exchange(server_metadata, params)
+          post_token_exchange(server_metadata, params, client_info)
         end
 
         # Validate token response

data/lib/ruby_llm/mcp/handlers/async_response.rb

@@ -5,7 +5,7 @@ module RubyLLM
     module Handlers
       # Represents an async response for deferred completion
       class AsyncResponse
-        attr_reader :elicitation_id, :state, :result, :error
+        attr_reader :elicitation_id
 
         VALID_STATES = %i[pending completed rejected cancelled timed_out].freeze
 
@@ -95,27 +95,27 @@ module RubyLLM
 
         # Check if operation is pending
         def pending?
-          @state == :pending
+          @mutex.synchronize { @state == :pending }
         end
 
         # Check if operation is completed
         def completed?
-          @state == :completed
+          @mutex.synchronize { @state == :completed }
         end
 
         # Check if operation is rejected
         def rejected?
-          @state == :rejected
+          @mutex.synchronize { @state == :rejected }
         end
 
         # Check if operation is cancelled
         def cancelled?
-          @state == :cancelled
+          @mutex.synchronize { @state == :cancelled }
         end
 
         # Check if operation timed out
         def timed_out?
-          @state == :timed_out
+          @mutex.synchronize { @state == :timed_out }
         end
 
         # Check if operation is finished (any terminal state)
@@ -123,6 +123,18 @@ module RubyLLM
           !pending?
         end
 
+        def state
+          @mutex.synchronize { @state }
+        end
+
+        def result
+          @mutex.synchronize { @result }
+        end
+
+        def error
+          @mutex.synchronize { @error }
+        end
+
         private
 
         # Transition to new state (thread-safe)

data/lib/ruby_llm/mcp/handlers/promise.rb

@@ -5,8 +5,6 @@ module RubyLLM
     module Handlers
       # Promise implementation for async operations
       class Promise
-        attr_reader :state, :value, :reason
-
         # Initialize a new promise
         def initialize
           @state = :pending
@@ -120,17 +118,17 @@ module RubyLLM
 
         # Check if promise is pending
         def pending?
-          @state == :pending
+          @mutex.synchronize { @state == :pending }
         end
 
         # Check if promise is fulfilled
         def fulfilled?
-          @state == :fulfilled
+          @mutex.synchronize { @state == :fulfilled }
         end
 
         # Check if promise is rejected
         def rejected?
-          @state == :rejected
+          @mutex.synchronize { @state == :rejected }
         end
 
         # Check if promise is settled (fulfilled or rejected)
@@ -146,7 +144,7 @@ module RubyLLM
             # Wait until promise is settled
             if timeout
               deadline = Time.now + timeout
-              while pending?
+              while @state == :pending
                 remaining = deadline - Time.now
                 if remaining <= 0
                   raise Timeout::Error, "Promise timed out after #{timeout} seconds"
@@ -155,15 +153,27 @@ module RubyLLM
                 @condition.wait(@mutex, remaining)
               end
             else
-              @condition.wait(@mutex) while pending?
+              @condition.wait(@mutex) while @state == :pending
             end
 
             # Return value or raise error
-            return @value if fulfilled?
-            raise @reason if rejected?
+            return @value if @state == :fulfilled
+            raise @reason if @state == :rejected
           end
         end
 
+        def state
+          @mutex.synchronize { @state }
+        end
+
+        def value
+          @mutex.synchronize { @value }
+        end
+
+        def reason
+          @mutex.synchronize { @reason }
+        end
+
         private
 
         # Execute a callback safely

data/lib/ruby_llm/mcp/native/cancellable_operation.rb

@@ -6,7 +6,7 @@ module RubyLLM
       # Wraps server-initiated requests to support cancellation.
       # The operation tracks terminal state so cancellation outcomes are explicit.
       class CancellableOperation
-        attr_reader :request_id, :thread, :state
+        attr_reader :request_id
 
         def initialize(request_id)
           @request_id = request_id
@@ -61,22 +61,21 @@ module RubyLLM
         def execute(&)
           return nil if cancelled?
 
-          @mutex.synchronize do
+          worker = @mutex.synchronize do
             return nil if %i[cancelled cancelling].include?(@state)
 
             @state = :running
-          end
-
-          @thread = Thread.new do
-            Thread.current.abort_on_exception = false
-            begin
-              @result = yield
-            rescue Errors::RequestCancelled, StandardError => e
-              @error = e
+            @thread = Thread.new do
+              Thread.current.abort_on_exception = false
+              begin
+                @result = yield
+              rescue Errors::RequestCancelled, StandardError => e
+                @error = e
+              end
             end
           end
 
-          @thread.join
+          worker.join
           raise @error if @error && !@error.is_a?(Errors::RequestCancelled)
 
           @result
@@ -88,6 +87,14 @@ module RubyLLM
             @thread = nil
           end
         end
+
+        def state
+          @mutex.synchronize { @state }
+        end
+
+        def thread
+          @mutex.synchronize { @thread }
+        end
       end
     end
   end

data/lib/ruby_llm/mcp/native/transports/streamable_http.rb

@@ -406,6 +406,7 @@ module RubyLLM
               handle_authorization_challenge(response, request_id, original_message)
             when 405
               # Method not allowed - acceptable for some endpoints
+              fail_pending_request(request_id, response) if request_id
               nil
             when 400...500
               handle_client_error(response)
@@ -418,6 +419,19 @@ module RubyLLM
             end
           end
 
+          def fail_pending_request(request_id, response)
+            response_body = response.respond_to?(:body) ? response.body.to_s : "Unknown error"
+            error = Errors::TransportError.new(
+              code: response.status,
+              message: "HTTP request failed: #{response.status} - #{response_body}"
+            )
+
+            @pending_mutex.synchronize do
+              queue = @pending_requests.delete(request_id.to_s)
+              queue&.push(error)
+            end
+          end
+
           def handle_success_response(response, request_id, _original_message)
             content_type = response.respond_to?(:headers) ? response.headers["content-type"] : nil
 
@@ -479,7 +493,7 @@ module RubyLLM
           def handle_oauth_authorization_error(response, status_code)
             response_body = response.respond_to?(:body) ? response.body.to_s : ""
             error_body = JSON.parse(response_body)
-            error_message = error_body.dig("error", "message") || "Authorization failed"
+            error_message = oauth_error_message(error_body) || "Authorization failed"
 
             raise Errors::TransportError.new(
               code: status_code,
@@ -492,6 +506,17 @@ module RubyLLM
             )
           end
 
+          # A 403 body can be either a JSON-RPC error ({ "error" => { "message" => ... } }) or an
+          # RFC 6749 OAuth error ({ "error" => "invalid_token", "error_description" => ... })
+          def oauth_error_message(error_body)
+            return unless error_body.is_a?(Hash)
+
+            case error_body["error"]
+            when Hash then error_body["error"]["message"]
+            when String then error_body["error_description"] || error_body["error"]
+            end
+          end
+
           def handle_json_error_response(response, status_code)
             response_body = response.respond_to?(:body) ? response.body.to_s : "Unknown error"
             error_body = JSON.parse(response_body)

data/lib/ruby_llm/mcp/native/transports/support/timeout.rb

@@ -22,6 +22,7 @@ module RubyLLM
                 result
               else
                 worker.kill # stop the thread (can still have some risk if shared resources)
+                worker.join(0.1)
                 raise RubyLLM::MCP::Errors::TimeoutError.new(
                   message: "Request timed out after #{seconds} seconds",
                   request_id: request_id

data/lib/ruby_llm/mcp/tool.rb

@@ -8,9 +8,9 @@ module RubyLLM
       def initialize(annotation)
         @title = annotation["title"] || ""
         @read_only_hint = annotation["readOnlyHint"] || false
-        @destructive_hint = annotation["destructiveHint"] || true
+        @destructive_hint = annotation.fetch("destructiveHint", true)
         @idempotent_hint = annotation["idempotentHint"] || false
-        @open_world_hint = annotation["openWorldHint"] || true
+        @open_world_hint = annotation.fetch("openWorldHint", true)
       end
 
       def to_h

data/lib/ruby_llm/mcp/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module MCP
-    VERSION = "1.0.0"
+    VERSION = "1.0.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-mcp
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Patrick Vice
@@ -27,16 +27,22 @@ dependencies:
   name: json-schema
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: json_schemer
   requirement: !ruby/object:Gem::Requirement
@@ -238,7 +244,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: A RubyLLM MCP Client
 test_files: []