ruby-utcp 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99c878fb7098dd9c213ffa10c01349acf87fb03f6e5742f9214ec077a3502c0b
-  data.tar.gz: 0dfd532e70fde83d025aa0a9c6282c460a26b2c333cb917e6951d62ac979c780
+  metadata.gz: c041cd63497e9162042ccdd75ef1adad0bd1b3e8c7fe13ca67d84519bcced0c8
+  data.tar.gz: 2ff6634e287d5b313f58de19de4c70c64c626d894e939cad2246339f2683c12a
 SHA512:
-  metadata.gz: fa88cea89f5be786a37ba117ee308e301d760d55b76d9d409be03a1370934cc6b11a534d80b16d5c2c335d0dcc4ea82358ee7dda6a6eaaff768a2f7ecf8f7f68
-  data.tar.gz: 6eeb7f901ca0e58de3d9f33f8ca92bf990ea8e547aad89e5b28a17a7337ed491ceef0bf747710fa81c26092706550ebb0407e849e38e1ed3ee0d6dbfb30c312e
+  metadata.gz: 37b298c327a546cfa35799045ad2450c76cdfba4ad3cd8aee9d6fa79206d70667bfdec596654bb37cbdc4a25029732eb116943ce06cffbbd75c977dc18d3a5c5
+  data.tar.gz: 1b131b7c326f7eeb8f4e100d11160dac9d56e0f766cbb315ae4d2916f1351364b3f2cc39a81183e7b766634a06b2f9cecff1b49f26cb10b22f24c6ecdad88e40

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## Unreleased
+
+- Isolate MCP sessions and resource mappings between clients and clean up failed registrations.
+- Follow MCP tool/resource pagination and raise `ToolCallError` for tool failures, preserving the original payload.
+- Enforce stdio deadlines across partial reads, notifications, and blocked writes; bound message and stderr buffers.
+- Bound Code Mode integer powers, products, and numeric results, including aggregate tool-result budgets.
+- Declare `base64` and `logger` runtime dependencies for Bundler compatibility.
+- Add regression tests, coverage checks, a Ruby version CI matrix, and local transport integration checks.
+
 ## 1.1.0
 
 - Initial Ruby implementation of the UTCP 1.1 client and data model.

data/README.md

@@ -16,10 +16,10 @@ Or build this checkout:
 
 ```sh
 gem build ruby-utcp.gemspec
-gem install ./ruby-utcp-1.1.0.gem
+gem install "./ruby-utcp-$(ruby -Ilib -rutcp/version -e 'print UTCP::VERSION').gem"
 ```
 
-Ruby 2.6 or newer is supported for the core and 11 transports. The WebRTC default backend uses the optional `webrtc-ruby` gem, which requires Ruby 3.1 and `libdatachannel`; an application can instead inject its own peer adapter. The gRPC transport similarly loads the optional `grpc` gem only when used. There are no mandatory runtime dependencies outside Ruby's standard library.
+Ruby 2.6 or newer is supported for the core and 11 transports. The WebRTC default backend uses the optional `webrtc-ruby` gem, which requires Ruby 3.1 and `libdatachannel`; an application can instead inject its own peer adapter. The gRPC transport similarly loads the optional `grpc` gem only when used. `base64` and `logger` are declared runtime dependencies so Bundler can load them on Ruby versions where they are distributed as separate gems; the remaining core libraries come with Ruby.
 
 ## Quick start
 
@@ -229,6 +229,10 @@ MCP sessions implement initialization, notifications, `tools/list`, `tools/call`
 }
 ```
 
+Sessions and resource mappings are isolated per client. Closing one client does not close another client's sessions, even when manual and server names match. Tool and resource discovery follows all result pages. An MCP result with `isError: true` raises `UTCP::ToolCallError`; the original result is available in `error.response_body`.
+
+For stdio, `timeout` bounds the complete request write and response read, including partial lines and intervening notifications. Messages are limited to 16 MiB, and stderr is drained while retaining only its last 64 KiB. Call `client.close` when finished to release server processes.
+
 ### WebRTC
 
 WebRTC follows the reference signaling contract: `POST /connect` exchanges SDP and returns `sdp`, `candidates`, and `tools`; `POST /candidate` exchanges ICE candidates. DataChannel requests are JSON envelopes containing `id`, `tool`, and `args`, and responses correlate the same `id` with `result`.
@@ -311,6 +315,8 @@ Use `codemode.call_tool_stream` to collect a streaming call into an array. `code
 
 Code Mode accepts a constrained Ruby subset for local variables, JSON-like literals, arithmetic, conditionals, loops, indexing, and common collection transforms. It is interpreted without `eval`; filesystem, process, constant, reflection, import, and direct network APIs are not exposed. Executions also have code-size, step, result-size, log-size, and wall-clock limits. External effects remain possible through the UTCP tools that you deliberately register.
 
+The 1 MiB value budget includes numeric payloads as well as strings. Integer powers and products are checked before allocating their results, and non-finite floating-point results are rejected. Power checks use a conservative size estimate and can reject expressions close to the limit.
+
 ## Custom protocol plugins
 
 Register a call-template class and a protocol implementation before creating a client:
@@ -348,6 +354,11 @@ UTCP.register_protocol("queue", QueueProtocol.new)
 ## Development
 
 ```sh
-rake test
+bundle install
+bundle exec rake test
+bundle exec rake coverage
+bundle exec make standard-demo
 gem build ruby-utcp.gemspec
 ```
+
+CI runs the tests and gem build on Ruby 2.6, 2.7, 3.0–3.4, and 4.0. A separate Ruby 3.4 job runs the local transport examples and enforces minimum coverage of 75% of executable lines and 45% of branches. The standard demo uses WEBrick, included as a development dependency; native gRPC/WebRTC backends remain optional.

data/lib/utcp/code_mode.rb

@@ -14,6 +14,7 @@ module UTCP
     MAX_LOG_BYTES = 1024 * 1024
     MAX_VALUE_BYTES = 1024 * 1024
     MAX_VALUE_ITEMS = 10_000
+    MAX_INTEGER_BITS = MAX_VALUE_BYTES * 8
 
     attr_reader :client
 
@@ -611,7 +612,7 @@ module UTCP
           raise CodeModeSyntaxError, "Method #{method_name.inspect} is not available in Code Mode"
         end
 
-        invoke_safe_value_method(receiver, method_name, arguments, block)
+        bounded_value!(invoke_safe_value_method(receiver, method_name, arguments, block))
       end
 
       def invoke_runtime_api(method_name, arguments, block)
@@ -827,7 +828,14 @@ module UTCP
       end
 
       def preflight_binary_size!(left, operator, right)
-        if operator == :+ && left.is_a?(String) && right.is_a?(String)
+        if operator == :** && right.is_a?(Integer)
+          bases = left.is_a?(Rational) ? [left.numerator, left.denominator] : [left]
+          bases.each { |base| preflight_integer_power!(base, right) if base.is_a?(Integer) }
+        elsif operator == :* && left.is_a?(Integer) && right.is_a?(Integer)
+          if !left.zero? && !right.zero? && left.abs.bit_length + right.abs.bit_length > MAX_INTEGER_BITS
+            raise CodeModeLimitError, "Integer product exceeds #{MAX_VALUE_BYTES} bytes"
+          end
+        elsif operator == :+ && left.is_a?(String) && right.is_a?(String)
           raise CodeModeLimitError, "String result exceeds #{MAX_VALUE_BYTES} bytes" if left.bytesize + right.bytesize > MAX_VALUE_BYTES
         elsif operator == :+ && left.is_a?(Array) && right.is_a?(Array)
           raise CodeModeLimitError, "Collection result exceeds #{MAX_VALUE_ITEMS} items" if left.length + right.length > MAX_VALUE_ITEMS
@@ -838,7 +846,34 @@ module UTCP
         end
       end
 
+      def preflight_integer_power!(base, exponent)
+        magnitude = base.abs
+        return if magnitude <= 1 || exponent.zero?
+
+        # Use an upper bound without constructing the potentially enormous result.
+        bits = magnitude.bit_length
+        bits -= 1 if (magnitude & (magnitude - 1)).zero?
+        if exponent.abs > (MAX_INTEGER_BITS - 1) / bits
+          raise CodeModeLimitError, "Integer power exceeds #{MAX_VALUE_BYTES} bytes"
+        end
+      end
+
+      def numeric_bytes(value)
+        case value
+        when Integer then [(value.abs.bit_length + 7) / 8, 1].max
+        when Rational then numeric_bytes(value.numerator) + numeric_bytes(value.denominator)
+        when Complex then numeric_bytes(value.real) + numeric_bytes(value.imaginary)
+        when Float
+          raise CodeModeLimitError, "Numeric result must be finite" unless value.finite?
+          8
+        else value.to_s.bytesize
+        end
+      end
+
       def bounded_value!(value)
+        if value.is_a?(Numeric) && numeric_bytes(value) > MAX_VALUE_BYTES
+          raise CodeModeLimitError, "Numeric result exceeds #{MAX_VALUE_BYTES} bytes"
+        end
         if value.is_a?(String) && value.bytesize > MAX_VALUE_BYTES
           raise CodeModeLimitError, "String result exceeds #{MAX_VALUE_BYTES} bytes"
         end
@@ -881,7 +916,11 @@ module UTCP
           budget[:bytes] -= value.bytesize
           raise CodeModeLimitError, "Tool result contains too much string data" if budget[:bytes].negative?
           value.dup
-        when nil, true, false, Numeric
+        when Numeric
+          budget[:bytes] -= numeric_bytes(value)
+          raise CodeModeLimitError, "Tool result contains too much numeric data" if budget[:bytes].negative?
+          value
+        when nil, true, false
           value
         when Array
           value.map { |item| safe_tool_value(item, depth + 1, budget) }

data/lib/utcp/protocols/mcp.rb

@@ -4,7 +4,16 @@ require "open3"
 
 module UTCP
   class MCPStdioSession
-    def initialize(config, timeout)
+    MAX_MESSAGE_BYTES = 16 * 1024 * 1024
+    MAX_STDERR_BYTES = 64 * 1024
+
+    def initialize(config, timeout, max_message_bytes: MAX_MESSAGE_BYTES)
+      @timeout = Float(timeout)
+      raise ValidationError, "MCP timeout must be finite and greater than zero" unless @timeout.finite? && @timeout.positive?
+
+      @max_message_bytes = Integer(max_message_bytes)
+      raise ValidationError, "MCP message limit must be greater than zero" unless @max_message_bytes.positive?
+
       command = config["command"]
       command = command.first if command.is_a?(Array)
       raise ValidationError, "MCP stdio server requires command" if command.to_s.empty?
@@ -14,20 +23,26 @@ module UTCP
       options = { pgroup: true }
       options[:chdir] = config["cwd"] || config["workingDir"] if config["cwd"] || config["workingDir"]
       @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(environment, command.to_s, *args, options)
-      @timeout = timeout
+      @stdin.binmode
+      @stdout.binmode
+      @stderr.binmode
       @next_id = 0
       @mutex = Mutex.new
-      @stderr_reader = Thread.new { @stderr.read }
+      @read_buffer = +"".b
+      @stderr_buffer = +"".b
+      @stderr_mutex = Mutex.new
+      @stderr_reader = Thread.new { drain_stderr }
     end
 
     def request(method, params = nil)
       @mutex.synchronize do
+        deadline = monotonic_now + @timeout
         identifier = (@next_id += 1)
         message = { "jsonrpc" => "2.0", "id" => identifier, "method" => method }
         message["params"] = params unless params.nil?
-        write_message(message)
+        write_message(message, deadline)
         loop do
-          response = read_message
+          response = read_message(deadline)
           next unless response["id"] == identifier
           raise ToolCallError, "MCP error #{response["error"].inspect}" if response["error"]
 
@@ -40,7 +55,7 @@ module UTCP
       @mutex.synchronize do
         message = { "jsonrpc" => "2.0", "method" => method }
         message["params"] = params unless params.nil?
-        write_message(message)
+        write_message(message, monotonic_now + @timeout)
       end
       nil
     end
@@ -50,34 +65,94 @@ module UTCP
       Process.kill("TERM", -@wait_thread.pid) if @wait_thread&.alive?
       @wait_thread.join(1) if @wait_thread
       Process.kill("KILL", -@wait_thread.pid) if @wait_thread&.alive?
+      @wait_thread.join(1) if @wait_thread
     rescue Errno::ESRCH, Errno::EPERM, IOError
       nil
     ensure
       @stdout.close unless @stdout.closed?
+      @stderr_reader.join(1) if @stderr_reader
       @stderr.close unless @stderr.closed?
       @stderr_reader.kill if @stderr_reader&.alive?
     end
 
+    def stderr_output
+      @stderr_mutex.synchronize { @stderr_buffer.dup }
+    end
+
     private
 
-    def write_message(message)
-      @stdin.write(JSON.generate(message) + "\n")
-      @stdin.flush
+    def write_message(message, deadline)
+      data = (JSON.generate(message) + "\n").b
+      raise SerializerValidationError, "MCP stdio message exceeds #{@max_message_bytes} bytes" if data.bytesize > @max_message_bytes
+
+      offset = 0
+      while offset < data.bytesize
+        remaining_time(deadline)
+        written = @stdin.write_nonblock(data.byteslice(offset, 4096), exception: false)
+        if written == :wait_writable
+          wait_for_io(deadline, writable: true)
+        else
+          offset += written
+        end
+      end
     rescue Errno::EPIPE, IOError => error
       raise ToolCallError, "MCP stdio write failed: #{error.message}"
     end
 
-    def read_message
-      ready = IO.select([@stdout], nil, nil, @timeout)
-      raise TimeoutError, "MCP stdio response timed out" unless ready
+    def read_message(deadline)
+      loop do
+        remaining_time(deadline)
+        if (index = @read_buffer.index("\n"))
+          response = JSON.parse(@read_buffer.slice!(0, index + 1))
+          raise SerializerValidationError, "MCP stdio response must be an object" unless response.is_a?(Hash)
 
-      line = @stdout.gets
-      raise ToolCallError, "MCP stdio server closed the stream" unless line
+          return response
+        end
+        if @read_buffer.bytesize >= @max_message_bytes
+          raise SerializerValidationError, "MCP stdio message exceeds #{@max_message_bytes} bytes"
+        end
 
-      JSON.parse(line)
+        chunk = @stdout.read_nonblock([4096, @max_message_bytes - @read_buffer.bytesize].min, exception: false)
+        case chunk
+        when :wait_readable then wait_for_io(deadline)
+        when nil then raise ToolCallError, "MCP stdio server closed the stream"
+        else @read_buffer << chunk
+        end
+      end
     rescue JSON::ParserError => error
       raise SerializerValidationError, "Invalid MCP stdio JSON: #{error.message}"
     end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def remaining_time(deadline)
+      remaining = deadline - monotonic_now
+      raise TimeoutError, "MCP stdio request timed out" unless remaining.positive?
+
+      remaining
+    end
+
+    def wait_for_io(deadline, writable: false)
+      readers, writers = writable ? [nil, [@stdin]] : [[@stdout], nil]
+      ready = IO.select(readers, writers, nil, remaining_time(deadline))
+      raise TimeoutError, "MCP stdio request timed out" unless ready
+    end
+
+    def drain_stderr
+      loop do
+        chunk = @stderr.readpartial(4096)
+        @stderr_mutex.synchronize do
+          @stderr_buffer << chunk
+          if @stderr_buffer.bytesize > MAX_STDERR_BYTES
+            @stderr_buffer = @stderr_buffer.byteslice(-MAX_STDERR_BYTES, MAX_STDERR_BYTES)
+          end
+        end
+      end
+    rescue EOFError, IOError
+      nil
+    end
   end
 
   class MCPHTTPSession
@@ -156,10 +231,9 @@ module UTCP
       errors = []
       template.servers.each do |server_name, config|
         begin
-          session = session_for(template, server_name, config)
+          session = session_for(client, template, server_name, config)
           initialize_session(session, template)
-          result = session.request("tools/list", {}) || {}
-          Array(result["tools"]).each do |tool|
+          each_list_item(session, "tools/list", "tools") do |tool|
             tools << Tool.new(
               name: "#{server_name}.#{tool.fetch("name")}",
               description: tool["description"].to_s,
@@ -168,11 +242,12 @@ module UTCP
               tool_call_template: template
             )
           end
-          add_resource_tools(template, server_name, session, tools) if template.register_resources_as_tools
+          add_resource_tools(client, template, server_name, session, tools) if template.register_resources_as_tools
         rescue StandardError => error
           errors << "#{server_name}: #{error.message}"
         end
       end
+      deregister_manual(client, template) unless errors.empty?
       manual = Manual.new(utcp_version: VERSION, manual_version: "1.0.0", tools: tools)
       RegisterManualResult.new(
         manual_call_template: template,
@@ -185,29 +260,28 @@ module UTCP
       failure(template, error)
     end
 
-    def deregister_manual(_client, template)
-      prefix = "#{template.name}\0"
+    def deregister_manual(client, template)
       sessions = @sessions_mutex.synchronize do
-        keys = @sessions.keys.select { |key| key.start_with?(prefix) }
+        keys = @sessions.keys.select { |owner, name, _server| owner.equal?(client) && name == template.name }
+        @resources.delete_if { |(owner, name, _server, _resource), _value| owner.equal?(client) && name == template.name }
         keys.map { |key| @sessions.delete(key) }
       end
       sessions.each(&:close)
-      @resources.delete_if { |key, _value| key.start_with?(prefix) }
       nil
     end
 
-    def call_tool(_client, tool_name, tool_args, template)
+    def call_tool(client, tool_name, tool_args, template)
       assert_mcp_template!(template)
       server_name, local_name = parse_tool_name(tool_name, template)
       config = template.servers.fetch(server_name)
-      session = session_for(template, server_name, config)
-      resource_uri = @resources[resource_key(template, server_name, local_name)]
+      session = session_for(client, template, server_name, config)
+      resource_uri = @sessions_mutex.synchronize { @resources[resource_key(client, template, server_name, local_name)] }
       result = if resource_uri
                  session.request("resources/read", "uri" => resource_uri)
                else
                  session.request("tools/call", "name" => local_name, "arguments" => Utils.stringify_keys(tool_args || {}))
                end
-      process_mcp_result(result)
+      process_mcp_result(result, tool_name: tool_name)
     rescue Error
       raise
     rescue StandardError => error
@@ -251,8 +325,8 @@ module UTCP
       raise ValidationError, "MCP protocol requires a McpCallTemplate"
     end
 
-    def session_for(template, server_name, config)
-      key = "#{template.name}\0#{server_name}"
+    def session_for(client, template, server_name, config)
+      key = [client, template.name, server_name]
       @sessions_mutex.synchronize do
         @sessions[key] ||= if @session_factory
                             @session_factory.call(server_name, config, template)
@@ -273,30 +347,42 @@ module UTCP
       session.notify("notifications/initialized", {})
     end
 
-    def add_resource_tools(template, server_name, session, tools)
+    def each_list_item(session, method, collection)
       cursor = nil
+      seen = {}
       loop do
-        params = cursor ? { "cursor" => cursor } : {}
-        result = session.request("resources/list", params) || {}
-        Array(result["resources"]).each do |resource|
-          safe_name = resource.fetch("name", resource.fetch("uri")).to_s.gsub(/[^[:alnum:]_]/, "_")
-          local_name = "resource_#{safe_name}"
-          @resources[resource_key(template, server_name, local_name)] = resource.fetch("uri")
-          tools << Tool.new(
-            name: "#{server_name}.#{local_name}",
-            description: "Read MCP resource: #{resource["description"] || resource["name"] || resource["uri"]}",
-            inputs: { "type" => "object", "properties" => {} },
-            outputs: { "type" => "object" },
-            tool_call_template: template
-          )
-        end
+        params = cursor.nil? ? {} : { "cursor" => cursor }
+        result = Utils.hash!(session.request(method, params) || {}, "MCP #{method} result")
+        Utils.array!(result.fetch(collection, []), "MCP #{collection}").each { |item| yield item }
         cursor = result["nextCursor"]
-        break if cursor.nil? || cursor.empty?
+        break if cursor.nil?
+        unless cursor.is_a?(String) && !seen.key?(cursor)
+          raise SerializerValidationError, "MCP #{method} returned an invalid or repeated cursor"
+        end
+
+        seen[cursor] = true
+      end
+    end
+
+    def add_resource_tools(client, template, server_name, session, tools)
+      each_list_item(session, "resources/list", "resources") do |resource|
+        safe_name = resource.fetch("name", resource.fetch("uri")).to_s.gsub(/[^[:alnum:]_]/, "_")
+        local_name = "resource_#{safe_name}"
+        @sessions_mutex.synchronize do
+          @resources[resource_key(client, template, server_name, local_name)] = resource.fetch("uri")
+        end
+        tools << Tool.new(
+          name: "#{server_name}.#{local_name}",
+          description: "Read MCP resource: #{resource["description"] || resource["name"] || resource["uri"]}",
+          inputs: { "type" => "object", "properties" => {} },
+          outputs: { "type" => "object" },
+          tool_call_template: template
+        )
       end
     end
 
-    def resource_key(template, server_name, local_name)
-      "#{template.name}\0#{server_name}\0#{local_name}"
+    def resource_key(client, template, server_name, local_name)
+      [client, template.name, server_name, local_name]
     end
 
     def parse_tool_name(tool_name, template)
@@ -311,8 +397,15 @@ module UTCP
       end
     end
 
-    def process_mcp_result(result)
+    def process_mcp_result(result, tool_name: nil)
       return result unless result.is_a?(Hash)
+      if result["isError"]
+        details = Array(result["content"]).select { |item| item.is_a?(Hash) && item["type"] == "text" }
+                                          .map { |item| item["text"].to_s }.join("\n")
+        message = "MCP tool #{tool_name.inspect} failed"
+        message += ": #{details}" unless details.empty?
+        raise ToolCallError.new(message, tool_name: tool_name, response_body: Utils.deep_copy(result))
+      end
       return result["structuredContent"] if result.key?("structuredContent")
       return result if result.key?("contents")
 

data/lib/utcp/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module UTCP
-  VERSION = "1.1.1"
+  VERSION = "1.1.2"
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-utcp
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - ruby-utcp contributors
@@ -9,6 +9,46 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -49,6 +89,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '14.0'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: Discover, search, and call UTCP 1.1 tools over pluggable native protocols.
 email:
 - maintainers@utcp.io