acp_ruby 0.1.0

data/lib/agent_client_protocol/meta.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# AUTO-GENERATED from meta.json — DO NOT EDIT
+
+module AgentClientProtocol
+  PROTOCOL_VERSION = 1
+
+  AGENT_METHODS = {
+    authenticate: "authenticate",
+    initialize: "initialize",
+    session_cancel: "session/cancel",
+    session_load: "session/load",
+    session_new: "session/new",
+    session_prompt: "session/prompt",
+    session_set_config_option: "session/set_config_option",
+    session_set_mode: "session/set_mode",
+  }.freeze
+
+  CLIENT_METHODS = {
+    fs_read_text_file: "fs/read_text_file",
+    fs_write_text_file: "fs/write_text_file",
+    session_request_permission: "session/request_permission",
+    session_update: "session/update",
+    terminal_create: "terminal/create",
+    terminal_kill: "terminal/kill",
+    terminal_output: "terminal/output",
+    terminal_release: "terminal/release",
+    terminal_wait_for_exit: "terminal/wait_for_exit",
+  }.freeze
+end

data/lib/agent_client_protocol/router.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module AgentClientProtocol
+  class Router
+    def initialize
+      @request_handlers = {}
+      @notification_handlers = {}
+      @ext_method_handler = nil
+      @ext_notification_handler = nil
+    end
+
+    def on_request(method, request_class: nil, response_class: nil, optional: false, &handler)
+      @request_handlers[method] = {
+        handler: handler,
+        request_class: request_class,
+        response_class: response_class,
+        optional: optional
+      }
+    end
+
+    def on_notification(method, request_class: nil, &handler)
+      @notification_handlers[method] = {
+        handler: handler,
+        request_class: request_class
+      }
+    end
+
+    def on_ext_method(&handler)
+      @ext_method_handler = handler
+    end
+
+    def on_ext_notification(&handler)
+      @ext_notification_handler = handler
+    end
+
+    def call(method, params, is_notification)
+      if is_notification
+        dispatch_notification(method, params)
+      else
+        dispatch_request(method, params)
+      end
+    end
+
+    private
+
+    def dispatch_request(method, params)
+      # Extension methods start with _
+      if method.start_with?("_")
+        if @ext_method_handler
+          return @ext_method_handler.call(method, params)
+        else
+          raise RequestError.method_not_found(method)
+        end
+      end
+
+      entry = @request_handlers[method]
+      unless entry
+        raise RequestError.method_not_found(method)
+      end
+
+      begin
+        deserialized = deserialize_params(params, entry[:request_class])
+        result = entry[:handler].call(deserialized)
+
+        if result.nil? && entry[:optional]
+          return nil
+        end
+
+        serialize_result(result)
+      rescue NotImplementedError
+        if entry[:optional]
+          nil
+        else
+          raise RequestError.method_not_found(method)
+        end
+      end
+    end
+
+    def dispatch_notification(method, params)
+      if method.start_with?("_")
+        @ext_notification_handler&.call(method, params)
+        return nil
+      end
+
+      entry = @notification_handlers[method]
+      return nil unless entry
+
+      deserialized = deserialize_params(params, entry[:request_class])
+      entry[:handler].call(deserialized)
+      nil
+    end
+
+    def deserialize_params(params, klass)
+      return params unless klass && params.is_a?(Hash)
+
+      klass.from_hash(params)
+    end
+
+    def serialize_result(result)
+      case result
+      when Schema::BaseModel then result.to_h
+      when Hash then result
+      when nil then nil
+      else result
+      end
+    end
+  end
+end

data/lib/agent_client_protocol/schema/base_model.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module AgentClientProtocol
+  module Schema
+    class BaseModel
+      class << self
+        def properties
+          @properties ||= {}
+        end
+
+        def required_properties
+          @required_properties ||= Set.new
+        end
+
+        # Register a discriminator field + value for this class.
+        # E.g., `discriminator "type", "text"` means to_h includes {"type" => "text"}
+        def discriminator(field = nil, value = nil)
+          if field
+            @discriminator_field = field
+            @discriminator_value = value
+          end
+          @discriminator_field ? [@discriminator_field, @discriminator_value] : nil
+        end
+
+        def property(ruby_name, json_name: nil, type: nil, default: :_no_default, required: false)
+          json_name ||= to_camel_case(ruby_name.to_s)
+          properties[ruby_name] = {json_name: json_name, type: type, default: default}
+          required_properties << ruby_name if required
+          attr_reader ruby_name
+        end
+
+        def from_hash(hash)
+          return nil if hash.nil?
+
+          kwargs = {}
+          properties.each do |ruby_name, meta|
+            json_name = meta[:json_name]
+            if hash.key?(json_name)
+              kwargs[ruby_name] = deserialize_value(hash[json_name], meta[:type])
+            elsif hash.key?(ruby_name.to_s)
+              kwargs[ruby_name] = deserialize_value(hash[ruby_name.to_s], meta[:type])
+            end
+          end
+          new(**kwargs)
+        end
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@properties, properties.dup)
+          subclass.instance_variable_set(:@required_properties, required_properties.dup)
+        end
+
+        private
+
+        def to_camel_case(str)
+          return str if str == "_meta"
+
+          parts = str.split("_")
+          parts[0] + parts[1..].map(&:capitalize).join
+        end
+
+        def deserialize_value(value, type)
+          return nil if value.nil?
+
+          case type
+          when Class
+            if type < BaseModel
+              type.from_hash(value)
+            else
+              value
+            end
+          when :content_block
+            ContentBlock.parse(value)
+          when :session_update
+            SessionUpdate.parse(value)
+          when :tool_call_content
+            ToolCallContent.parse(value)
+          when :permission_outcome
+            RequestPermissionOutcome.parse(value)
+          when Array
+            if type[0] == :array && value.is_a?(::Array)
+              value.map { |v| deserialize_value(v, type[1]) }
+            else
+              value
+            end
+          when :hash
+            value
+          else
+            value
+          end
+        end
+      end
+
+      def initialize(**kwargs)
+        self.class.properties.each do |ruby_name, meta|
+          if kwargs.key?(ruby_name)
+            instance_variable_set(:"@#{ruby_name}", kwargs[ruby_name])
+          elsif meta[:default] != :_no_default
+            default = meta[:default]
+            default = default.dup if default.is_a?(::Hash) || default.is_a?(::Array)
+            instance_variable_set(:"@#{ruby_name}", default)
+          end
+        end
+      end
+
+      def to_h
+        result = {}
+
+        # Include discriminator if set on this class
+        disc = self.class.discriminator
+        if disc
+          result[disc[0]] = disc[1]
+        end
+
+        self.class.properties.each do |ruby_name, meta|
+          value = instance_variable_get(:"@#{ruby_name}")
+          next if value.nil? && !self.class.required_properties.include?(ruby_name)
+
+          result[meta[:json_name]] = serialize_value(value)
+        end
+        result
+      end
+
+      def to_json(*)
+        JSON.generate(to_h, *)
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && to_h == other.to_h
+      end
+
+      def hash
+        [self.class, to_h].hash
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def inspect
+        pairs = self.class.properties.keys.map { |k| "#{k}: #{instance_variable_get(:"@#{k}").inspect}" }
+        "#<#{self.class.name} #{pairs.join(", ")}>"
+      end
+
+      private
+
+      def serialize_value(value)
+        case value
+        when BaseModel then value.to_h
+        when ::Array then value.map { |v| serialize_value(v) }
+        when ::Hash then value.transform_values { |v| serialize_value(v) }
+        else
+          value.respond_to?(:to_h) && !value.is_a?(Numeric) ? value.to_h : value
+        end
+      end
+    end
+  end
+end