clamo 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50a648eb843f70c35499806bb4f53736046560d333af184759917ff10f321dbe
-  data.tar.gz: ce450a2e07864e7908ec0321f1f1f116168dbe6fd7ae7cc054bffc84442f33d5
+  metadata.gz: 1c91f68aa4a88440e10a75a4ae3f138df400c10fd698b2d2b8c72990dc7e25f1
+  data.tar.gz: bef5052025e0714e0297b20d95d1b90dfed7fce4e30a2fecd24cff9e8a84913c
 SHA512:
-  metadata.gz: 242c0a8d44b69ada88887001943213ab8a6cd074eecfec4482e08de60b39d505df2fd58b4e34a7f00b2266250e3d54f07bc187b036dc08d47889ec1fe55d6140
-  data.tar.gz: 4c72e3384fd958d1e9fe2a5a5b0ae607c4a667fbb9bc69eb04b1c8a10889ced46fd7caa47e8cc8f413dc5aec1746104c509c83165ec70863b4e02cc717090845
+  metadata.gz: 96fa52c9f35c408c60a6827fa7886ee35fcea05af69fc6dde54aca497f0347c8de76bfd163fdb6bb4595f498fe9b55e9059e32d7212f997ec43cf5e77fafafef
+  data.tar.gz: a7519eeba5bfd4074ada39cea72a03afa03cfc22809b53034eaf06c48d8a94a1122e136a6cf7b9452a27fb2f0ca54d9507db91a7bf498073b5f25e76cee74f45

data/.rubocop.yml

@@ -1,6 +1,6 @@
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.3
 
 Metrics/MethodLength:
   Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,77 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [0.6.0] - 2026-03-14
+
+### Added
+
+- `Clamo::Server.handle` — JSON string in, JSON string out entry point for HTTP/socket integrations
+- `Clamo::Server.on_error` callback for notification failure reporting
+- `Clamo::Error` base exception class
+
+### Changed
+
+- Notifications now dispatch synchronously instead of spawning a background thread per call; callers control their own concurrency
+- `build_error_response_from` accepts explicit `descriptor:` and `id:` keyword arguments instead of `**opts`
+- `build_error_response_parse_error` takes no arguments (always returns `id: nil`)
+- `parallel` dependency relaxed from `~> 1.27.0` to `~> 1.27`
+- Minimum Ruby version raised from 3.0 to 3.3
+
+### Removed
+
+- `JSONRPC.valid_params?` (use `JSONRPC.proper_params_if_any?` directly)
+- `JSONRPC::PROTOCOL_VERSION_PRAGMA` constant (unused)
+- `JSONRPC::ProtocolErrors::SERVER_ERROR_CODE_RANGE` constant (unused)
+
+### Fixed
+
+- **Security:** replaced `send` with `public_send` to prevent remote invocation of private methods
+- **Security:** `method_known?` now uses `public_methods(false)` to expose only explicitly defined methods
+- Notifications now validate method existence before dispatch (previously skipped validation)
+- Empty batch requests correctly return Invalid Request error per spec
+- All-notification batches return `nil` instead of empty array per spec
+- `build_error_response_from` no longer leaks the `:descriptor` key into the error response builder
+
+### Internal
+
+- `method_known?`, `dispatch_to_ruby`, `response_for` moved from public to private API
+- `response_for_single_request` extracted into focused private helpers
+- Test suite expanded from scaffold to 62 tests / 84 assertions covering validation, dispatch, security, error handling, batching, notifications, and argument edge cases
+- CI matrix set to Ruby 3.3, 3.4, 4.0
+
+## [0.5.0] - 2025-02-07
+
+### Changed
+
+- Updated README with detailed usage examples, error table, and batch/notification documentation
+
+## [0.4.0] - 2025-02-07
+
+### Fixed
+
+- Corrected gem metadata URLs
+
+## [0.3.0] - 2025-02-06
+
+### Added
+
+- Batch request support via `parallel` gem
+- Named parameter (Hash) dispatch
+- JSON-RPC 2.0 validation (pragma, method, id, params)
+- Protocol error constants (`PARSE_ERROR`, `INVALID_REQUEST`, etc.)
+- RuboCop configuration
+
+### Changed
+
+- Multiple version bumps during initial development
+
+## [0.1.0] - 2025-02-06
+
+### Added
+
+- Initial release
+- Basic JSON-RPC 2.0 server with positional parameter dispatch
+- `Clamo::JSONRPC` request/response builders

data/README.md

@@ -1,29 +1,142 @@
 # Clamo
 
-JSON-RPC protocol toolkit for Ruby.
+A Ruby implementation of [JSON-RPC 2.0](https://www.jsonrpc.org/specification) designed for simplicity and compliance with the specification.
 
-Consume, Serve or test JSON-RPC endpoints with Clamo.
 
-## Installation
+## Usage
 
-Install the gem and add to the application's Gemfile by executing:
+### Basic Usage
 
-    $ bundle add clamo
+```ruby
+require 'clamo'
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+# Define a service object with methods you want to expose
+module MyService
+  def self.add(a, b)
+    a + b
+  end
 
-    $ gem install clamo
+  def self.subtract(a:, b:)
+    a - b
+  end
 
-## Usage
+  # Private methods won't be accessible via JSON-RPC
+  private_class_method def self.internal_method
+    # This won't be exposed
+  end
+end
+
+# Handle a JSON-RPC request
+request_body = '{"jsonrpc": "2.0", "method": "add", "params": [1, 2], "id": 1}'
+response = Clamo::Server.unparsed_dispatch_to_object(
+  request: request_body,
+  object: MyService
+)
+
+puts response
+# => {jsonrpc: "2.0", result: 3, id: 1}
+```
+
+### Handling Different Parameter Types
+
+Clamo supports both positional (array) and named (object/hash) parameters:
+
+```ruby
+# Positional parameters
+request = '{"jsonrpc": "2.0", "method": "add", "params": [1, 2], "id": 1}'
+
+# Named parameters
+request = '{"jsonrpc": "2.0", "method": "subtract", "params": {"a": 5, "b": 3}, "id": 2}'
+```
+
+### Batch Requests
+
+Clamo handles batch requests automatically:
+
+```ruby
+batch_request = <<~JSON
+[
+  {"jsonrpc": "2.0", "method": "add", "params": [1, 2], "id": 1},
+  {"jsonrpc": "2.0", "method": "subtract", "params": {"a": 5, "b": 3}, "id": 2}
+]
+JSON
+
+batch_response = Clamo::Server.unparsed_dispatch_to_object(
+  request: batch_request,
+  object: MyService
+)
+
+puts batch_response
+# => [{jsonrpc: "2.0", result: 3, id: 1}, {jsonrpc: "2.0", result: 2, id: 2}]
+```
+
+### Notifications
+
+Notifications are requests without an ID field. They don't produce a response:
 
-TODO: Write usage instructions here
+```ruby
+notification = '{"jsonrpc": "2.0", "method": "add", "params": [1, 2]}'
+response = Clamo::Server.unparsed_dispatch_to_object(
+  request: notification,
+  object: MyService
+)
+
+puts response
+# => nil
+```
+
+### Building JSON-RPC Requests
+
+Clamo provides utilities for building JSON-RPC requests:
+
+```ruby
+request = Clamo::JSONRPC.build_request(
+  method: "add",
+  params: [1, 2],
+  id: 1
+)
+
+puts request
+# => {jsonrpc: "2.0", method: "add", params: [1, 2], id: 1}
+```
+
+## Error Handling
+
+Clamo follows the JSON-RPC 2.0 specification for error handling:
+
+| Error Code | Message          | Description                                          |
+|------------|------------------|------------------------------------------------------|
+| -32700     | Parse error      | Invalid JSON was received                            |
+| -32600     | Invalid request  | The JSON sent is not a valid Request object          |
+| -32601     | Method not found | The method does not exist / is not available         |
+| -32602     | Invalid params   | Invalid method parameter(s)                          |
+| -32603     | Internal error   | Internal JSON-RPC error                              |
+| -32000     | Server error     | Reserved for implementation-defined server errors    |
+
+## Advanced Features
+
+### Parallel Processing
+
+Batch requests are processed in parallel using the [parallel](https://github.com/grosser/parallel) gem. You can pass options to `Parallel.map` via the `parsed_dispatch_to_object` method:
+
+```ruby
+Clamo::Server.parsed_dispatch_to_object(
+  request: batch_request,
+  object: MyService,
+  in_processes: 4  # Parallel processing option
+)
+```
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/rubakas/clamo
+Bug reports and pull requests are welcome on GitHub at https://github.com/rubakas/clamo.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/clamo/jsonrpc.rb

@@ -2,11 +2,8 @@
 
 module Clamo
   module JSONRPC
-    PROTOCOL_VERSION_PRAGMA = { jsonrpc: "2.0" }.freeze
-
     module ProtocolErrors
       ErrorDescriptor = Data.define(:code, :message)
-      SERVER_ERROR_CODE_RANGE = ((-32_099)..(-32_000))
 
       PARSE_ERROR       = ErrorDescriptor.new(code: -32_700, message: "Parse error")
       INVALID_REQUEST   = ErrorDescriptor.new(code: -32_600, message: "Invalid request")
@@ -50,28 +47,24 @@ module Clamo
           proper_id_if_any?(request)
       end
 
-      def valid_params?(request)
-        proper_params_if_any?(request)
-      end
+      def build_request(**opts)
+        raise ArgumentError, "method is required" unless opts.key?(:method)
 
-      def build_request **opts
-        # raise if no method present
-        # raise if params present, but not an array
-        { jsonrpc: "2.0",
-          method: opts[:method] }
-          .merge({ params: opts[:params] })
-          .merge(opts.key?(:id) ? { id: opts[:id] } : {})
+        validate_params_type!(opts[:params]) if opts.key?(:params)
+
+        { jsonrpc: "2.0", method: opts[:method] }
+          .then { |r| opts.key?(:params) ? r.merge(params: opts[:params]) : r }
+          .then { |r| opts.key?(:id) ? r.merge(id: opts[:id]) : r }
       end
 
       def build_result_response(id:, result:)
-        {}.merge(PROTOCOL_VERSION_PRAGMA)
-          .merge({ result: result })
-          .merge({ id: id })
+        { jsonrpc: "2.0", result: result, id: id }
       end
 
-      def build_error_response **opts
-        # raise if no error code present
-        # raise if no error message present
+      def build_error_response(**opts)
+        raise ArgumentError, "error code is required" unless opts.dig(:error, :code)
+        raise ArgumentError, "error message is required" unless opts.dig(:error, :message)
+
         { jsonrpc: "2.0",
           id: opts[:id],
           error: {
@@ -81,23 +74,32 @@ module Clamo
           }.reject { |k, _| k == :data && !opts[:error].key?(:data) } }
       end
 
-      def build_error_response_from **opts
-        # raise unless opts[:descriptor]
-        opts.merge(
-          { error:
-            { code: opts[:descriptor].code,
-              message: opts[:descriptor].message } }
+      def build_error_response_from(descriptor:, id: nil)
+        build_error_response(
+          id: id,
+          error: {
+            code: descriptor.code,
+            message: descriptor.message
+          }
         )
-            .then { |hash| build_error_response(**hash) }
       end
 
-      def build_error_response_parse_error **opts
-        opts.merge(
-          { error:
-            { code: ProtocolErrors::PARSE_ERROR.code,
-              message: ProtocolErrors::PARSE_ERROR.message } }
+      def build_error_response_parse_error
+        build_error_response(
+          id: nil,
+          error: {
+            code: ProtocolErrors::PARSE_ERROR.code,
+            message: ProtocolErrors::PARSE_ERROR.message
+          }
         )
-            .then { |hash| build_error_response(**hash) }
+      end
+
+      private
+
+      def validate_params_type!(params)
+        return if params.is_a?(Array) || params.is_a?(Hash)
+
+        raise ArgumentError, "params must be an Array or Hash"
       end
     end
   end

data/lib/clamo/server.rb

@@ -1,128 +1,138 @@
 # frozen_string_literal: true
 
 require "json"
+require "parallel"
 
 module Clamo
   module Server
     class << self
+      # Global error callback for notification failures.
+      # This is module-level state shared across all callers.
+      # Set to any callable (lambda, method, proc) that accepts (exception, method, params).
+      #
+      #   Clamo::Server.on_error = ->(e, method, params) { Rails.logger.error(e) }
+      #
+      attr_accessor :on_error
+
+      # JSON string in, JSON string out. Full round-trip for HTTP/socket integrations.
+      #
+      #   Clamo::Server.handle(request: body, object: MyService)
+      #
+      def handle(request:, object:, **)
+        response = unparsed_dispatch_to_object(request: request, object: object, **)
+        response&.to_json
+      end
+
       # Clamo::Server.unparsed_dispatch_to_object(
       #   request:  request_body,
       #   object:   MyModule
       # )
-      def unparsed_dispatch_to_object(request:, object:, **opts)
-        # TODO: raise unless object is present?
+      def unparsed_dispatch_to_object(request:, object:, **)
+        raise ArgumentError, "object is required" unless object
+
         begin
           parsed = JSON.parse(request)
-        rescue JSON::JSONError # TODO: any error
+        rescue JSON::JSONError
           return JSONRPC.build_error_response_parse_error
         end
 
-        parsed_dispatch_to_object(request: parsed, object: object, **opts)
+        parsed_dispatch_to_object(request: parsed, object: object, **)
       end
 
       def parsed_dispatch_to_object(request:, object:, **opts)
         response_for(request: request, object: object, **opts) do |method, params|
-          dispatch_to_ruby(
-            object: object,
-            method: method,
-            params: params # consider splating
-          )
+          dispatch_to_ruby(object: object, method: method, params: params)
         end
       end
 
+      private
+
       def method_known?(object:, method:)
-        (object.public_methods - Object.methods)
-          .map(&:to_sym)
-          .include?(method.to_sym)
+        object.public_methods(false).map(&:to_sym).include?(method.to_sym)
       end
 
       def dispatch_to_ruby(object:, method:, params:)
         case params
+        when Array     then object.public_send(method.to_sym, *params)
+        when Hash      then object.public_send(method.to_sym, **params.transform_keys(&:to_sym))
+        when NilClass  then object.public_send(method.to_sym)
+        else raise ArgumentError, "Unsupported params type: #{params.class}"
+        end
+      end
+
+      def response_for(request:, object:, **, &block)
+        case request
         when Array
-          object.send method.to_sym, *params
+          response_for_batch(request: request, object: object, block: block, **)
         when Hash
-          object.send method.to_sym, **params.transform_keys(&:to_sym)
-        when NilClass
-          object.send method.to_sym
+          response_for_single_request(request: request, object: object, block: block)
         else
-          # TODO: raise
-          raise "WTF"
+          JSONRPC.build_error_response_from(id: nil, descriptor: JSONRPC::ProtocolErrors::INVALID_REQUEST)
         end
       end
 
-      def response_for(request:, object:, **opts, &block)
-        case request
-        when Array # batch request
-          Parallel.map(request, **opts) do |item|
-            response_for_single_request(
-              request: item,
-              object: object,
-              block: block
-            )
-          end.compact
-        when Hash # single request
-          response_for_single_request(
-            request: request,
-            object: object,
-            block: block
-          )
-        else
-          JSONRPC.build_error_response_from(
-            id: nil,
-            descriptor: JSONRPC::ProtocolErrors::INVALID_REQUEST
-          )
+      def response_for_single_request(request:, object:, block:)
+        error = validate_request_structure(request)
+        return error if error
+
+        unless method_known?(object: object, method: request["method"])
+          return request.key?("id") ? method_not_found_error(request) : nil
         end
+
+        return dispatch_notification(request, block) unless request.key?("id")
+
+        dispatch_request(request, block)
       end
 
-      def yield_to_execution(block:, method:, params:)
-        block.yield method, params
+      def response_for_batch(request:, object:, block:, **opts)
+        if request.empty?
+          return JSONRPC.build_error_response_from(id: nil, descriptor: JSONRPC::ProtocolErrors::INVALID_REQUEST)
+        end
+
+        result = Parallel.map(request, **opts) do |item|
+          response_for_single_request(request: item, object: object, block: block)
+        end.compact
+        result.empty? ? nil : result
       end
 
-      def response_for_single_request(request:, object:, block:)
+      def validate_request_structure(request)
         unless JSONRPC.valid_request?(request)
           return JSONRPC.build_error_response_from(
-            id: request["id"],
+            id: request.is_a?(Hash) ? request["id"] : nil,
             descriptor: JSONRPC::ProtocolErrors::INVALID_REQUEST
           )
         end
 
-        unless JSONRPC.valid_params?(request)
-          return JSONRPC.build_error_response_from(
-            id: request["id"],
-            descriptor: JSONRPC::ProtocolErrors::INVALID_PARAMS
-          )
-        end
+        return if JSONRPC.proper_params_if_any?(request)
 
-        unless request.key?("id") # notification - no result needed
-          # TODO: block.call off the current thread
-          Thread.new do
-            yield_to_execution(
-              block: block,
-              method: request["method"],
-              params: request["params"]
-            )
-          rescue StandardError
-            # TODO: add exception handler
-            nil
-          end
-
-          return nil
-        end
+        JSONRPC.build_error_response_from(id: request["id"], descriptor: JSONRPC::ProtocolErrors::INVALID_PARAMS)
+      end
 
-        unless method_known?(object: object, method: request["method"])
-          return JSONRPC.build_error_response_from(
-            id: request["id"],
-            descriptor: JSONRPC::ProtocolErrors::METHOD_NOT_FOUND
-          )
-        end
+      def method_not_found_error(request)
+        JSONRPC.build_error_response_from(id: request["id"], descriptor: JSONRPC::ProtocolErrors::METHOD_NOT_FOUND)
+      end
 
+      def dispatch_notification(request, block)
+        block.yield request["method"], request["params"]
+        nil
+      rescue StandardError => e
+        on_error&.call(e, request["method"], request["params"])
+        nil
+      end
+
+      def dispatch_request(request, block)
         JSONRPC.build_result_response(
           id: request["id"],
-          result: yield_to_execution(
-            block: block,
-            method: request["method"],
-            params: request["params"]
-          )
+          result: block.yield(request["method"], request["params"])
+        )
+      rescue StandardError => e
+        JSONRPC.build_error_response(
+          id: request["id"],
+          error: {
+            code: JSONRPC::ProtocolErrors::INTERNAL_ERROR.code,
+            message: JSONRPC::ProtocolErrors::INTERNAL_ERROR.message,
+            data: e.message
+          }
         )
       end
     end

data/lib/clamo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clamo
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/clamo.rb

@@ -5,5 +5,5 @@ require_relative "clamo/jsonrpc"
 require_relative "clamo/server"
 
 module Clamo
-  # class Error < StandardError; end
+  class Error < StandardError; end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: clamo
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Andriy Tyurnikov
 bindir: exe
 cert_chain: []
-date: 2025-04-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -15,15 +15,15 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.27.0
+        version: '1.27'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.27.0
-description: JSON-RPC Client/Server tooling for Ruby
+        version: '1.27'
+description: JSON-RPC 2.0 server toolkit for Ruby
 email:
 - Andriy.Tyurnikov@gmail.com
 executables: []
@@ -31,11 +31,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rubocop.yml"
+- CHANGELOG.md
 - README.md
 - Rakefile
 - lib/clamo.rb
-- lib/clamo/client.rb
-- lib/clamo/gpt_json_rpc_server.rb
 - lib/clamo/jsonrpc.rb
 - lib/clamo/server.rb
 - lib/clamo/version.rb
@@ -45,7 +44,7 @@ licenses: []
 metadata:
   homepage_uri: https://github.com/rubakas/clamo
   source_code_uri: https://github.com/rubakas/clamo
-  changelog_uri: https://github.com/rubakas/clamo
+  changelog_uri: https://github.com/rubakas/clamo/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -54,14 +53,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.5
+rubygems_version: 4.0.3
 specification_version: 4
-summary: JSON-RPC Client/Server tooling for Ruby
+summary: JSON-RPC 2.0 server toolkit for Ruby
 test_files: []

data/lib/clamo/client.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-class Client
-  ANSWER = 42
-end

data/lib/clamo/gpt_json_rpc_server.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module GPTJsonRpcServer
-  PROTOCOL_VERSION = "2.0"
-
-  def self.handle_request(object:, request_json:)
-    requests = JSON.parse(request_json)
-    if requests.is_a?(Array)
-      responses = requests.map do |request|
-        Thread.new { process_request(object, request) }
-      end.map(&:value).compact
-      responses.empty? ? nil : responses.to_json
-    else
-      response = process_request(object, requests)
-      response&.to_json
-    end
-  rescue JSON::ParserError
-    { jsonrpc: PROTOCOL_VERSION, error: { code: -32_700, message: "Parse error" }, id: nil }.to_json
-  end
-
-  def self.process_request(object, request)
-    method = request["method"]
-    params = request["params"]
-    id = request["id"]
-
-    unless valid_id?(id)
-      return { jsonrpc: PROTOCOL_VERSION, error: { code: -32_600, message: "Invalid Request" }, id: nil }
-    end
-
-    unless method.is_a?(String) && object.public_methods(false).include?(method.to_sym)
-      return { jsonrpc: PROTOCOL_VERSION, error: { code: -32_601, message: "Method not found" }, id: id }
-    end
-
-    method_object = object.method(method)
-    param_list = method_object.parameters
-    valid_params = case params
-                   when Array
-                     param_list.none? { |type, _| type == :rest } && params.size == param_list.count do |type, _|
-                       %i[req opt rest].include?(type)
-                     end
-                   when Hash
-                     required_params = param_list.slice(:keyreq).map(&:last)
-                     required_params.all? { |key| params.key?(key) } && param_list.all? do |type, name|
-                       type != :keyreq || params.key?(name)
-                     end
-                   when NilClass
-                     param_list.empty?
-                   else
-                     false
-                   end
-
-    unless valid_params
-      return { jsonrpc: PROTOCOL_VERSION, error: { code: -32_602, message: "Invalid params" },
-               id: id }
-    end
-
-    if id.nil?
-      # Treat id: null as a notification
-      Thread.new { safe_call_method(method_object, params) }
-      return nil
-    end
-
-    begin
-      result = safe_call_method(method_object, params)
-      { jsonrpc: PROTOCOL_VERSION, result: result, id: id }
-    rescue StandardError => e
-      { jsonrpc: PROTOCOL_VERSION, error: { code: -32_603, message: "Internal error", data: e.message }, id: id }
-    end
-  end
-
-  def self.safe_call_method(method_object, params)
-    if params.is_a?(Array)
-      method_object.call(*params)
-    elsif params.is_a?(Hash)
-      method_object.call(**params)
-    else
-      method_object.call
-    end
-  end
-
-  def self.valid_id?(id)
-    return false unless id.is_a?(String) || id.is_a?(Numeric) || id.nil?
-    return false if id.is_a?(Numeric) && id != id.to_i
-
-    true
-  end
-end
-
-# Example usage
-
-class MyService
-  def add(a, b)
-    a + b
-  end
-
-  def subtract(a:, b:)
-    a - b
-  end
-
-  private
-
-  def private_method
-    "This should not be exposed"
-  end
-end
-
-service = MyService.new
-
-# Example JSON-RPC requests
-single_request_positional = {
-  jsonrpc: "2.0",
-  method: "add",
-  params: [1, 2],
-  id: 1
-}.to_json
-
-single_request_keyword = {
-  jsonrpc: "2.0",
-  method: "subtract",
-  params: { a: 5, b: 3 },
-  id: 2
-}.to_json
-
-batch_request = [
-  { jsonrpc: "2.0", method: "add", params: [1, 2], id: 1 },
-  { jsonrpc: "2.0", method: "subtract", params: { a: 5, b: 3 }, id: 2 },
-  { jsonrpc: "2.0", method: "add", params: [7, 3], id: 3 }
-].to_json
-
-notification_request = {
-  jsonrpc: "2.0",
-  method: "add",
-  params: [1, 2]
-}.to_json
-
-invalid_id_null_request = {
-  jsonrpc: "2.0",
-  method: "add",
-  params: [1, 2],
-  id: nil
-}.to_json
-
-invalid_id_object_request = {
-  jsonrpc: "2.0",
-  method: "add",
-  params: [1, 2],
-  id: {}
-}.to_json
-
-invalid_method_request = {
-  jsonrpc: "2.0",
-  method: {},
-  params: [1, 2],
-  id: 1
-}.to_json
-
-# Handling single request with positional parameters
-response_json_positional = GPTJsonRpcServer.handle_request(object: service, request_json: single_request_positional)
-puts response_json_positional # Output: {"jsonrpc":"2.0","result":3,"id":1}
-
-# Handling single request with keyword parameters
-response_json_keyword = GPTJsonRpcServer.handle_request(object: service, request_json: single_request_keyword)
-puts response_json_keyword # Output: {"jsonrpc":"2.0","result":2,"id":2}
-
-# Handling batch request
-batch_response_json = GPTJsonRpcServer.handle_request(object: service, request_json: batch_request)
-puts batch_response_json # Output: [{"jsonrpc":"2.0","result":3,"id":1},{"jsonrpc":"2.0","result":2,"id":2},{"jsonrpc":"2.0","result":10,"id":3}]
-
-# Handling notification request (no response expected)
-notification_response_json = GPTJsonRpcServer.handle_request(object: service, request_json: notification_request)
-puts notification_response_json.nil? # Output: true
-
-# Handling request with id = null (treated as a notification)
-invalid_id_null_response_json = GPTJsonRpcServer.handle_request(object: service, request_json: invalid_id_null_request)
-puts invalid_id_null_response_json.nil? # Output: true
-
-# Handling request with id as an object (should return an error)
-invalid_id_object_response_json = GPTJsonRpcServer.handle_request(object: service,
-                                                                  request_json: invalid_id_object_request)
-puts invalid_id_object_response_json # Output: {"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request"},"id":null}
-
-# Handling request with method as an object (should return an error)
-invalid_method_response_json = GPTJsonRpcServer.handle_request(object: service, request_json: invalid_method_request)
-puts invalid_method_response_json # Output: {"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request"},"id":1}