acp_sdk_async 0.2.0 → 0.3.0

data/lib/acp/schema_base.rb

@@ -19,7 +19,7 @@ module ACP
     end
 
     def self.to_snake(camel)
-      camel.to_s.gsub(/([A-Z])/) { "_#{$1.downcase}" }.sub(/\A_/, "")
+      camel.to_s.gsub(/([A-Z])/) { "_#{::Regexp.last_match(1).downcase}" }.sub(/\A_/, "")
     end
 
     def self.serialize(value)
@@ -75,7 +75,7 @@ module ACP
 
             fail!(value, path)
           when :boolean
-            return value if value == true || value == false
+            return value if [true, false].include?(value)
 
             fail!(value, path)
           when :object
@@ -141,11 +141,9 @@ module ACP
 
           result = []
           value.each_with_index do |element, index|
-            begin
-              result << @item.coerce(element, path + [index])
-            rescue ValidationError
-              raise unless @skip_invalid
-            end
+            result << @item.coerce(element, path + [index])
+          rescue ValidationError
+            raise unless @skip_invalid
           end
           result
         end
@@ -204,9 +202,7 @@ module ACP
           if @tag && value.is_a?(Hash)
             tag_value = read_tag(value)
             candidates = @tagged[tag_value] if tag_value
-            if candidates && !candidates.empty?
-              return try_variants(candidates, value, path) { |error| raise error }
-            end
+            return try_variants(candidates, value, path) { |error| raise error } if candidates && !candidates.empty?
           end
 
           try_variants(@untagged, value, path) do
@@ -254,6 +250,17 @@ module ACP
         keyword_init: true
       )
 
+      # Catch-all Other* variants must reject values reserved by known
+      # variants, otherwise unions would accept malformed payloads
+      # (e.g. action=accept in Other).
+      RESERVED_TAGS = {
+        "CreateOtherSessionElicitationRequest" => ["mode", %w[form url].freeze],
+        "CreateOtherRequestElicitationRequest" => ["mode", %w[form url].freeze],
+        "OtherElicitationResponse" => ["action", %w[accept cancel decline].freeze],
+        "ElicitationOtherPropertySchema" => ["type", %w[array boolean integer number string].freeze],
+        "OtherMultiSelectItems" => ["type", %w[string].freeze]
+      }.freeze
+
       class << self
         def fields
           @fields ||= superclass.respond_to?(:fields) ? superclass.fields.dup : []
@@ -276,6 +283,7 @@ module ACP
             default_on_error: default_on_error
           )
           attr_reader name
+
           define_method(:"#{name}=") do |value|
             instance_variable_set(:"@#{name}", value)
             @set_fields << name
@@ -288,6 +296,7 @@ module ACP
 
           instance = allocate
           instance.send(:load_from_hash, value, path)
+          instance.send(:check_reserved_tags!, path)
           instance
         end
 
@@ -300,7 +309,7 @@ module ACP
         alias parse coerce
       end
 
-      attr_reader :field_meta
+      attr_accessor :field_meta
 
       def initialize(**kwargs)
         @set_fields = []
@@ -311,18 +320,36 @@ module ACP
         self.class.fields.each do |f|
           if kwargs.key?(f.name)
             value = kwargs[f.name]
-            value = f.type.coerce(value, [f.key]) unless value.nil?
-            assign(f, value, set: !value.nil?)
+            if value.nil?
+              if f.const
+                assign(f, f.const, set: true)
+              elsif f.required && !f.default_on_error
+                raise ValidationError.new("missing required field #{f.key}", [f.key])
+              else
+                assign(f, default_for(f), set: false)
+              end
+            else
+              begin
+                coerced = f.type.coerce(value, [f.key])
+              rescue ValidationError
+                raise unless f.default_on_error
+
+                assign(f, default_for(f), set: false)
+                next
+              end
+              raise ValidationError.new("expected #{f.const.inspect}, got #{coerced.inspect}", [f.key]) if f.const && coerced != f.const
+
+              assign(f, coerced, set: true)
+            end
           elsif f.const
             assign(f, f.const, set: true)
+          elsif f.required
+            raise ValidationError.new("missing required field #{f.key}", [f.key])
           else
             assign(f, default_for(f), set: false)
           end
         end
-      end
-
-      def field_meta=(value)
-        @field_meta = value
+        check_reserved_tags!
       end
 
       def set?(name)
@@ -418,9 +445,7 @@ module ACP
 
       def load_present(field, raw, path)
         value = field.type.coerce(raw, path + [field.key])
-        if field.const && value != field.const
-          raise ValidationError.new("expected #{field.const.inspect}, got #{value.inspect}", path + [field.key])
-        end
+        raise ValidationError.new("expected #{field.const.inspect}, got #{value.inspect}", path + [field.key]) if field.const && value != field.const
 
         assign(field, value, set: true)
       rescue ValidationError
@@ -435,6 +460,25 @@ module ACP
         end
         [false, nil]
       end
+
+      def check_reserved_tags!(path = [])
+        rule = RESERVED_TAGS[self.class.name.split("::").last]
+        return unless rule
+
+        wire_field, reserved = rule
+        field = self.class.fields.find { |f| f.key == wire_field || f.name.to_s == wire_field }
+        return unless field
+
+        value = instance_variable_get(:"@#{field.name}")
+        return if value.nil?
+
+        return unless reserved.include?(value)
+
+        raise ValidationError.new(
+          "#{wire_field} value is reserved by a known variant",
+          path + [field.key]
+        )
+      end
     end
   end
 end

data/lib/acp/stdio.rb

@@ -68,7 +68,7 @@ module ACP
           line = line.scrub unless line.valid_encoding?
           ACP.logger.info("acp[#{label}] stderr: #{line.chomp}")
         end
-      rescue IOError, Errno::EBADF, ::Async::Cancel
+      rescue IOError, Errno::EBADF, Wait::TASK_STOPPED
         nil
       ensure
         io.close unless io.closed?

data/lib/acp/transport.rb

@@ -84,11 +84,23 @@ module ACP
     private
 
     def read_line
-      if @receive_timeout && @input.respond_to?(:wait_readable) && !@input.wait_readable(@receive_timeout)
-        raise TimeoutError, "No message received within #{@receive_timeout}s"
-      end
+      return @input.gets unless @receive_timeout
+
+      if Wait.async?
+        begin
+          ::Async::Task.current.with_timeout(@receive_timeout) { @input.gets }
+        rescue ::Async::TimeoutError
+          raise TimeoutError, "No message received within #{@receive_timeout}s"
+        end
+      elsif @input.respond_to?(:wait_readable)
+        raise TimeoutError, "No message received within #{@receive_timeout}s" unless @input.wait_readable(@receive_timeout)
+
+        @input.gets
+      else
+        raise TimeoutError, "No message received within #{@receive_timeout}s" unless IO.select([@input], nil, nil, @receive_timeout)
 
-      @input.gets
+        @input.gets
+      end
     end
   end
 
@@ -104,31 +116,48 @@ module ACP
     def initialize(inbox, outbox)
       @inbox = inbox
       @outbox = outbox
+      @mutex = Mutex.new
       @closed = false
     end
 
     def closed?
-      @closed
+      @mutex.synchronize { @closed }
     end
 
     def send_message(message)
-      raise ConnectionError, "Transport is closed" if @closed
+      raise ConnectionError, "Transport is closed" if closed?
 
+      # JSON round-trip simulates the wire: isolates mutation between peers
+      # and normalizes symbol keys to strings, like NDJSON framing does.
       @outbox.push(JSON.parse(JSON.generate(message)))
+    rescue ::Async::Queue::ClosedError
+      raise ConnectionError, "Transport is closed"
     end
 
     def receive_message
-      return nil if @closed && @inbox.empty?
+      return nil if closed? && @inbox.empty?
 
       @inbox.pop
     end
 
     def close
-      return if @closed
+      should_signal = @mutex.synchronize do
+        next false if @closed
 
-      @closed = true
-      @outbox.push(nil)
-      @inbox.push(nil)
+        @closed = true
+        true
+      end
+      return unless should_signal
+
+      # Signal EOF to the peer only. The local receive loop unblocks via
+      # task cancellation (Connection#stop_workers) or via the closed?+empty?
+      # fast path in receive_message above. Pushing nil to our own inbox
+      # would discard ordering guarantees, so we deliberately avoid it.
+      begin
+        @outbox.push(nil)
+      rescue ::Async::Queue::ClosedError
+        nil
+      end
     end
   end
 end

data/lib/acp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ACP
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/acp/wait.rb

@@ -15,6 +15,18 @@ module ACP
   end
 
   module Wait
+    # Task cancellation exception renamed across async 2.x:
+    # older releases raise Async::Stop, newer raise Async::Cancel
+    # (with Stop kept as an alias). Pick whichever exists.
+    TASK_STOPPED =
+      if defined?(::Async::Cancel)
+        ::Async::Cancel
+      elsif defined?(::Async::Stop)
+        ::Async::Stop
+      else
+        StandardError
+      end
+
     def self.async?
       !::Async::Task.current?.nil?
     rescue RuntimeError
@@ -51,8 +63,12 @@ module ACP
     def self.stop(worker)
       return if worker.nil? || worker.finished?
 
-      worker.stop
-    rescue ::Async::Cancel, StandardError
+      if worker.respond_to?(:stop)
+        worker.stop
+      else
+        worker.cancel
+      end
+    rescue TASK_STOPPED, StandardError
       nil
     end
 
@@ -61,11 +77,24 @@ module ACP
 
       if timeout.nil?
         worker.wait
+      elsif async?
+        # Task#wait(timeout:) only exists on newer async; with_timeout
+        # around a blocking wait works on every 2.x.
+        begin
+          ::Async::Task.current.with_timeout(timeout) { worker.wait }
+        rescue ::Async::TimeoutError
+          return false
+        end
       else
-        worker.wait(timeout: timeout)
+        require "timeout" unless defined?(::Timeout)
+        begin
+          ::Timeout.timeout(timeout) { worker.wait }
+        rescue ::Timeout::Error
+          return false
+        end
       end
       true
-    rescue ::Async::Cancel
+    rescue TASK_STOPPED
       true
     rescue ::Async::TimeoutError, TimeoutError
       false
@@ -103,8 +132,11 @@ module ACP
         @promise = ::Async::Promise.new
       end
 
+      # Async::Promise#resolved? is true after either resolve or reject
+      # (completed? is only true for successful resolution), so it is the
+      # correct settled check. Fall back to failed?/completed? for safety.
       def settled?
-        @promise.resolved?
+        @promise.resolved? || @promise.failed? || @promise.completed?
       end
 
       def resolve(value)

data/lib/acp_sdk_async.rb

@@ -12,3 +12,6 @@ require_relative "acp/router"
 require_relative "acp/client"
 require_relative "acp/agent"
 require_relative "acp/stdio"
+require_relative "acp/contrib/tool_calls"
+require_relative "acp/contrib/session_state"
+require_relative "acp/contrib/permissions"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acp_sdk_async
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - nutsoriginal
@@ -43,11 +43,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - lib/acp/agent.rb
 - lib/acp/client.rb
 - lib/acp/connection.rb
+- lib/acp/contrib/permissions.rb
+- lib/acp/contrib/session_state.rb
+- lib/acp/contrib/tool_calls.rb
 - lib/acp/exceptions.rb
 - lib/acp/meta.rb
 - lib/acp/router.rb