ruby-utcp 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1869c15823d927455e8339580df8200a4eae60a1313a1384b2d98f793786e78d
-  data.tar.gz: 3f63ab346e1316dd5ba26e367637f3a1c39d8b7202d1b5c117c3885cf0c8405a
+  metadata.gz: 265426eb4dd2ca952c81a23b71aeb8c1f0b1c90f8fbf247ec502279b0129ffba
+  data.tar.gz: 79c0d4d21648777686b7caf3cc32f333cb7001bfcf8fa3f10c340195a706f449
 SHA512:
-  metadata.gz: 0bb88097ddb4f9170b8aeec82fb14d34fc708abc15ac7cfed54df9c03737105183c0fd09ca202c2ae53fbd276e85221393c4d8adfa36f80f5e05296b1c4ca860
-  data.tar.gz: 4c9c0147d82493982d2717bc56b4f5b0486b09fa1c37b4a2a5d4ebf7b04dd0859b28ef4361eb6d7e8458d27b6a1975073b9af68784401695a300f97f2fa7ecfd
+  metadata.gz: 698ae3e9f0600fedeaa7adf2ae51c4e6872affed4a2da34454456c51f444a25d83ae59d6984d395b77f85ca36fa426731bcca6565cd0e7b1fc915473cb1caf3a
+  data.tar.gz: 1a0ff70255dbd8b4ab2b7b323e638d726646423833144eed365d3fd9236908a038e0652c18548e9095ecbbfa87a87b2d01b5167dc8d93125918b09054326f21d

data/CHANGELOG.md

@@ -2,12 +2,21 @@
 
 ## Unreleased
 
+- Raise the Code Mode value budget to 30 MiB, account for string/symbol hash keys, and enforce shared byte, item, and step limits while collecting streams.
+- Close temporary discovery sessions when inspecting required variables, preserving active MCP, WebRTC, and WebSocket sessions. Isolate persistent WebSocket connections between clients and close transient discovery sockets on failure.
+- Run real gRPC/WebRTC tests in CI using pinned, unmodified native dependencies and libdatachannel 0.24.5. Keep the additional backend shutdown probes opt-in rather than requiring modified WebRTC bindings.
+- Correct the README coverage thresholds and document the native integration setup.
+
+## 1.1.3
+
 - Split Code Mode into focused components while preserving the public API; fix `do...end` block results.
 - Add branch-focused interpreter tests, concurrent request tests, and local HTTP/TCP/WebSocket fault injection.
 - Isolate WebRTC peers between clients, close failed registrations, and align native offer/answer negotiation with `webrtc-ruby`.
 - Close WebSocket sockets when the opening handshake fails.
 - Add an opt-in real gRPC/WebRTC integration suite and raise coverage gates to 80% lines / 60% branches.
-- Bound native integration runs with a subprocess watchdog. Include an opt-in source patch for `webrtc-ruby` 1.0.0 shutdown deadlocks, pointer-lifetime protection, and real callback/concurrent-shutdown regression tests.
+- Bound native integration runs with a subprocess watchdog and add real callback/concurrent-shutdown regression tests for the locally patched WebRTC backend.
+
+## 1.1.2
 
 - 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.
@@ -16,6 +25,10 @@
 - 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.1
+
+- Add Code Mode for composing tools with a constrained Ruby interpreter, progressive tool discovery, captured logs, and execution limits.
+
 ## 1.1.0
 
 - Initial Ruby implementation of the UTCP 1.1 client and data model.

data/README.md

@@ -267,7 +267,7 @@ load_variables_from:
     env_file_path: .env
 ```
 
-Manual-specific names are tried first. For a manual named `weather_api`, `${TOKEN}` first looks for `weather__api_TOKEN`, then `TOKEN`. Use `get_required_variables_for_manual_and_tools` or `get_required_variables_for_registered_tool` to inspect requirements without exposing values.
+Manual-specific names are tried first. For a manual named `weather_api`, `${TOKEN}` first looks for `weather__api_TOKEN`, then `TOKEN`. Use `get_required_variables_for_manual_and_tools` or `get_required_variables_for_registered_tool` to inspect requirements without exposing values. Discovery performed by the former uses a temporary client and closes its sessions before returning, including on failure; existing client sessions stay open.
 
 ## Migrating v0.1 documents
 
@@ -315,7 +315,7 @@ 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.
+The 30 MiB (31,457,280 bytes) value budget is shared across strings, numeric payloads, and hash keys within each tool argument, result, or collected stream. String and symbol keys count toward both the byte budget and the 10,000-value limit. Streams are checked one item at a time and stop as soon as the shared budget is exceeded. 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. Source code is limited to 64 KiB and captured logs to 1 MiB per execution.
 
 ## Custom protocol plugins
 
@@ -361,4 +361,8 @@ 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.
+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 80% of executable lines and 60% of branches. The standard demo uses WEBrick, included as a development dependency.
+
+A dedicated Ruby 3.4 CI job sets `UTCP_NATIVE_TESTS=1` to install the original, unmodified backends from the Gemfile, builds libdatachannel 0.24.5 and the WebRTC extension, and runs `bundle exec rake native`. The test subprocess has a 45-second watchdog. The native dependencies remain optional for applications using the gem.
+
+The default native suite checks discovery, real calls, streaming, concurrent requests, timeouts, and client isolation. Additional backend shutdown probes are opt-in with `UTCP_WEBRTC_SHUTDOWN_REGRESSIONS=1`; they require callback shutdown guarantees that the stock `webrtc-ruby` 1.0.0 release does not provide and are not part of the CI job. No WebRTC patches are installed or applied.

data/lib/utcp/client.rb

@@ -132,12 +132,22 @@ module UTCP
       return required unless required.empty?
 
       substituted = substitute_template(template, template.name)
-      result = fetch_protocol(substituted.call_template_type).register_manual(self, substituted)
-      return [] unless result.success?
-
-      result.manual.tools.flat_map do |tool|
-        variable_substitutor.find_required_variables(tool.tool_call_template.to_h, template.name)
-      end.uniq
+      protocol = fetch_protocol(substituted.call_template_type)
+      # Give discovery its own session owner and repository, even for an existing manual.
+      inspection_config = config.dup
+      inspection_config.tool_repository = InMemoryToolRepository.new
+      inspection_config.manual_call_templates = []
+      inspection_client = Client.new(root_dir: root_dir, config: inspection_config, logger: logger)
+      begin
+        result = protocol.register_manual(inspection_client, substituted)
+        return [] unless result.success?
+
+        result.manual.tools.flat_map do |tool|
+          variable_substitutor.find_required_variables(tool.tool_call_template.to_h, template.name)
+        end.uniq
+      ensure
+        protocol.deregister_manual(inspection_client, substituted)
+      end
     end
 
     def get_required_variables_for_registered_tool(tool_name)
@@ -214,4 +224,3 @@ module UTCP
   end
   UtcpClient = Client
 end
-

data/lib/utcp/code_mode/runtime.rb

@@ -14,7 +14,7 @@ module UTCP
           safe_tool_value(@client.call_tool(arguments[0], tool_arguments(arguments[1])))
         when "call_tool_stream", "call_tool_streaming"
           require_arity!("codemode.#{method_name}", arguments, 1..2)
-          safe_tool_value(@client.call_tool_streaming(arguments[0], tool_arguments(arguments[1])).to_a)
+          safe_tool_stream(@client.call_tool_streaming(arguments[0], tool_arguments(arguments[1])))
         when "search_tools"
           require_arity!("codemode.search_tools", arguments, 1..2)
           options = arguments[1].is_a?(Hash) ? arguments[1] : {}

data/lib/utcp/code_mode/value_limits.rb

@@ -81,13 +81,23 @@ module UTCP
           value.map { |item| safe_tool_value(item, depth + 1, budget) }
         when Hash
           value.each_with_object({}) do |(key, item), result|
-            safe_key = key.is_a?(Symbol) ? key : key.to_s
+            key_string = safe_tool_value(key.to_s, depth + 1, budget)
+            safe_key = key.is_a?(Symbol) ? key : key_string
             result[safe_key] = safe_tool_value(item, depth + 1, budget)
           end
         else
           raise CodeModeExecutionError, "Tool returned unsupported #{value.class} value"
         end
       end
+
+      def safe_tool_stream(stream)
+        # Reserve the root array so streamed and ordinary results use the same budget.
+        budget = { items: MAX_VALUE_ITEMS - 1, bytes: MAX_VALUE_BYTES }
+        stream.each_with_object([]) do |item, result|
+          tick!
+          result << safe_tool_value(item, 1, budget)
+        end
+      end
     end
   end
 end

data/lib/utcp/code_mode.rb

@@ -12,7 +12,7 @@ module UTCP
     DEFAULT_MAX_STEPS = 100_000
     MAX_CODE_BYTES = 64 * 1024
     MAX_LOG_BYTES = 1024 * 1024
-    MAX_VALUE_BYTES = 1024 * 1024
+    MAX_VALUE_BYTES = 30 * 1024 * 1024
     MAX_VALUE_ITEMS = 10_000
     MAX_INTEGER_BITS = MAX_VALUE_BYTES * 8
 

data/lib/utcp/protocols/websocket.rb

@@ -250,33 +250,35 @@ module UTCP
 
     def register_manual(client, template)
       assert_websocket_template!(template)
-      entry, transient = connection_for(template, {})
+      entry, transient = connection_for(client, template, {})
       payload = entry.mutex.synchronize do
         entry.connection.send_text(JSON.generate("type" => "utcp"))
         _opcode, bytes = entry.connection.read_message
         bytes
       end
-      entry.connection.close if transient
       success(template, manual_from_payload(template, payload, source: "WebSocket discovery response"))
     rescue StandardError => error
       client.logger.warn("Unable to register WebSocket manual #{template.name.inspect}: #{error.message}")
       failure(template, error)
+    ensure
+      entry.connection.close if entry && transient
     end
 
-    def deregister_manual(_client, template)
-      prefix = [template.url, template.protocol].join("\0") + "\0"
+    def deregister_manual(client, template)
       entries = @connections_mutex.synchronize do
-        keys = @connections.keys.select { |key| key.start_with?(prefix) }
+        keys = @connections.keys.select do |owner, url, subprotocol, _key|
+          owner.equal?(client) && url == template.url && subprotocol == template.protocol
+        end
         keys.map { |key| @connections.delete(key) }
       end
       entries.each { |entry| entry.connection.close }
       nil
     end
 
-    def call_tool(_client, tool_name, tool_args, template)
+    def call_tool(client, tool_name, tool_args, template)
       assert_websocket_template!(template)
       args = Utils.stringify_keys(tool_args || {})
-      entry, transient, message_args = connection_for(template, args, include_arguments: true)
+      entry, transient, message_args = connection_for(client, template, args, include_arguments: true)
       result = entry.mutex.synchronize do
         message = format_message(template, message_args)
         entry.connection.send_text(message)
@@ -302,7 +304,7 @@ module UTCP
       raise ValidationError, "WebSocket protocol requires a WebSocketCallTemplate"
     end
 
-    def connection_for(template, arguments, include_arguments: false)
+    def connection_for(client, template, arguments, include_arguments: false)
       args = arguments.dup
       headers = Utils.stringify_keys(template.headers || {})
       template.header_fields.each { |field| headers[field] = args.delete(field).to_s if args.key?(field) }
@@ -315,7 +317,7 @@ module UTCP
       headers["Cookie"] = cookies.map { |key, value| "#{key}=#{value}" }.join("; ") unless cookies.empty?
       url = append_query(template.url, query)
       WebSocketURLSecurity.validate!(url)
-      key = connection_key(template, url, headers)
+      key = [client, template.url, template.protocol, connection_key(template, url, headers)]
       if template.keep_alive
         entry = @connections_mutex.synchronize do
           current = @connections[key]

data/lib/utcp/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-utcp
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors:
 - ruby-utcp contributors