a2a-rb 0.1.1

data/lib/a2a/part/data.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module A2A
+  class Part
+    class Data
+      attr_reader :data, :media_type, :filename, :metadata
+
+      def initialize(data:, media_type: nil, filename: nil, metadata: nil)
+        @data = data
+        @media_type = media_type
+        @filename = filename
+        @metadata = metadata
+      end
+
+      def self.from_h(hash)
+        new(
+          data: hash.fetch("data"),
+          media_type: hash["mediaType"],
+          filename: hash["filename"],
+          metadata: hash["metadata"]
+        )
+      end
+
+      def to_h
+        {
+          "data" => data,
+          "mediaType" => media_type,
+          "filename" => filename,
+          "metadata" => metadata
+        }.compact
+      end
+    end
+  end
+end

data/lib/a2a/part/file.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module A2A
+  class Part
+    class File
+      attr_reader :raw, :url, :filename, :media_type, :metadata
+
+      def initialize(raw: nil, url: nil, filename: nil, media_type: nil, metadata: nil)
+        @raw = raw
+        @url = url
+        @filename = filename
+        @media_type = media_type
+        @metadata = metadata
+      end
+
+      def self.from_h(hash)
+        new(
+          raw: hash["raw"],
+          url: hash["url"],
+          filename: hash["filename"],
+          media_type: hash["mediaType"],
+          metadata: hash["metadata"]
+        )
+      end
+
+      def to_h
+        {
+          "raw" => raw,
+          "url" => url,
+          "filename" => filename,
+          "mediaType" => media_type,
+          "metadata" => metadata
+        }.compact
+      end
+
+      def inline?
+        !raw.nil?
+      end
+
+      def remote?
+        !url.nil?
+      end
+    end
+  end
+end

data/lib/a2a/part/text.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module A2A
+  class Part
+    class Text
+      attr_reader :text, :media_type, :filename, :metadata
+
+      def initialize(text:, media_type: nil, filename: nil, metadata: nil)
+        @text = text
+        @media_type = media_type
+        @filename = filename
+        @metadata = metadata
+      end
+
+      def self.from_h(hash)
+        new(
+          text: hash.fetch("text"),
+          media_type: hash["mediaType"],
+          filename: hash["filename"],
+          metadata: hash["metadata"]
+        )
+      end
+
+      def to_h
+        {
+          "text" => text,
+          "mediaType" => media_type,
+          "filename" => filename,
+          "metadata" => metadata
+        }.compact
+      end
+    end
+  end
+end

data/lib/a2a/part.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "part/text"
+require_relative "part/data"
+require_relative "part/file"
+
+module A2A
+  class Part
+    def self.from_h(hash)
+      if hash.key?("text")
+        Part::Text.from_h(hash)
+      elsif hash.key?("data")
+        Part::Data.from_h(hash)
+      elsif hash.key?("raw") || hash.key?("url")
+        Part::File.from_h(hash)
+      else
+        raise ArgumentError, "cannot detect Part type from keys: #{hash.keys.inspect}"
+      end
+    end
+  end
+end

data/lib/a2a/protocol/http_json/transport.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module A2A
+  module Protocol
+    class HttpJson
+      class Transport
+        def get(url, query:, headers:)
+          uri = URI.parse(url)
+          uri.query = URI.encode_www_form(query) unless query.empty?
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          request = Net::HTTP::Get.new(uri.request_uri, headers)
+          response = http.request(request)
+          handle_response(response)
+        end
+
+        def post(url, body:, headers:)
+          uri = URI.parse(url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          request = Net::HTTP::Post.new(uri.request_uri, headers)
+          request.body = JSON.generate(body)
+          response = http.request(request)
+          handle_response(response)
+        end
+
+        def delete(url, headers:)
+          uri = URI.parse(url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          response = http.request(Net::HTTP::Delete.new(uri.request_uri, headers))
+          handle_delete_response(response)
+        end
+
+        def stream(url, headers:, method: :post, body: {}, query: {}, &block)
+          uri = URI.parse(url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          http.request(build_stream_request(uri, method, headers, body, query), &block)
+        end
+
+        private
+
+        def build_stream_request(uri, method, headers, body, query)
+          case method
+          when :post
+            req = Net::HTTP::Post.new(uri.request_uri, headers)
+            req.body = JSON.generate(body)
+            req
+          when :get
+            uri.query = URI.encode_www_form(query) unless query.empty?
+            Net::HTTP::Get.new(uri.request_uri, headers)
+          end
+        end
+
+        def handle_response(response)
+          case response.code.to_i
+          when 200..299 then JSON.parse(response.body)
+          when 401 then raise AuthenticationError, "HTTP 401"
+          when 403 then raise AuthorizationError, "HTTP 403"
+          when 404 then raise TaskNotFoundError, "HTTP 404"
+          else raise TransportError, "HTTP #{response.code}"
+          end
+        end
+
+        def handle_delete_response(response)
+          case response.code.to_i
+          when 200..299 then nil
+          when 401 then raise AuthenticationError, "HTTP 401"
+          when 403 then raise AuthorizationError, "HTTP 403"
+          when 404 then raise TaskNotFoundError, "HTTP 404"
+          else raise TransportError, "HTTP #{response.code}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/a2a/protocol/http_json.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "http_json/transport"
+
+module A2A
+  module Protocol
+    class HttpJson
+      attr_reader :url, :version, :headers, :extensions
+
+      def initialize(url:, version: Versioning::CURRENT, headers: {}, extensions: [], transport: Transport.new)
+        @url = url.chomp("/")
+        @version = version
+        @headers = headers
+        @extensions = extensions
+        @transport = transport
+        @built_headers = build_headers
+      end
+
+      def get(path, query: {})
+        @transport.get("#{@url}#{path}", query: query, headers: @built_headers)
+      end
+
+      def post(path, body: {})
+        @transport.post("#{@url}#{path}", body: body, headers: @built_headers)
+      end
+
+      def delete(path)
+        @transport.delete("#{@url}#{path}", headers: @built_headers)
+      end
+
+      def stream(path, method: :post, body: {}, query: {}, &)
+        sse_headers = @built_headers.merge("Accept" => "text/event-stream")
+        @transport.stream("#{@url}#{path}", headers: sse_headers, method: method, body: body, query: query, &)
+      end
+
+      private
+
+      def build_headers
+        h = default_headers.merge(@headers)
+        h["A2A-Extensions"] = @extensions.join(", ") unless @extensions.empty?
+        h
+      end
+
+      def default_headers
+        {
+          "Content-Type" => "application/json",
+          "Accept" => "application/json",
+          "A2A-Version" => @version
+        }
+      end
+    end
+  end
+end

data/lib/a2a/protocol/json_rpc/transport.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module A2A
+  module Protocol
+    class JsonRpc
+      class Transport
+        def post(url, body:, headers:)
+          uri = URI.parse(url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          request = Net::HTTP::Post.new(uri.request_uri, headers)
+          request.body = JSON.generate(body)
+          response = http.request(request)
+          handle_response(response)
+        end
+
+        def stream(url, headers:, method: :post, body: {}, query: {}, &block)
+          uri = URI.parse(url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          http.request(build_stream_request(uri, method, headers, body, query), &block)
+        end
+
+        private
+
+        def build_stream_request(uri, method, headers, body, query)
+          case method
+          when :post
+            req = Net::HTTP::Post.new(uri.request_uri, headers)
+            req.body = JSON.generate(body)
+            req
+          when :get
+            uri.query = URI.encode_www_form(query) unless query.empty?
+            Net::HTTP::Get.new(uri.request_uri, headers)
+          end
+        end
+
+        def handle_response(response)
+          case response.code.to_i
+          when 200..299 then JSON.parse(response.body)
+          when 401 then raise AuthenticationError, "HTTP 401"
+          when 403 then raise AuthorizationError, "HTTP 403"
+          when 404 then raise TaskNotFoundError, "HTTP 404"
+          else raise TransportError, "HTTP #{response.code}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/a2a/protocol/json_rpc.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "json_rpc/transport"
+
+module A2A
+  module Protocol
+    class JsonRpc
+      attr_reader :url, :version, :headers, :extensions
+
+      def initialize(url:, version: Versioning::CURRENT, headers: {}, extensions: [], transport: Transport.new)
+        @url = url
+        @version = version
+        @headers = headers
+        @extensions = extensions
+        @transport = transport
+        @built_headers = build_headers
+      end
+
+      def post(method, params = {})
+        @transport.post(@url, body: build_envelope(method, params), headers: @built_headers)
+      end
+
+      def stream(method, params = {}, &)
+        sse_headers = @built_headers.merge("Accept" => "text/event-stream")
+        @transport.stream(@url, headers: sse_headers, method: :post, body: build_envelope(method, params), &)
+      end
+
+      private
+
+      def build_envelope(method, params)
+        {
+          "jsonrpc" => "2.0",
+          "method" => method,
+          "id" => SecureRandom.uuid,
+          "params" => params
+        }
+      end
+
+      def build_headers
+        h = default_headers.merge(@headers)
+        h["A2A-Extensions"] = @extensions.join(", ") unless @extensions.empty?
+        h
+      end
+
+      def default_headers
+        {
+          "Content-Type" => "application/json",
+          "Accept" => "application/json",
+          "A2A-Version" => @version
+        }
+      end
+    end
+  end
+end

data/lib/a2a/push_notification/authentication_info.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module A2A
+  module PushNotification
+    class AuthenticationInfo
+      attr_reader :scheme, :credentials
+
+      def initialize(scheme:, credentials: nil)
+        @scheme = scheme
+        @credentials = credentials
+      end
+
+      def self.from_h(hash)
+        new(scheme: hash.fetch("scheme"), credentials: hash["credentials"])
+      end
+
+      def to_h
+        {
+          "scheme" => scheme,
+          "credentials" => credentials
+        }.compact
+      end
+
+      def authorization_header
+        credentials ? "#{scheme} #{credentials}" : scheme
+      end
+    end
+  end
+end

data/lib/a2a/push_notification/config.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module A2A
+  module PushNotification
+    class Config
+      attr_reader :id, :url, :token, :tenant, :task_id, :authentication
+
+      def initialize(url:, **kwargs)
+        @url = url
+        @id = kwargs[:id]
+        @token = kwargs[:token]
+        @tenant = kwargs[:tenant]
+        @task_id = kwargs[:task_id]
+        @authentication = kwargs[:authentication]
+      end
+
+      def self.from_h(hash)
+        new(
+          url: hash.fetch("url"),
+          id: hash["id"],
+          token: hash["token"],
+          tenant: hash["tenant"],
+          task_id: hash["taskId"],
+          authentication: hash["authentication"] && AuthenticationInfo.from_h(hash["authentication"])
+        )
+      end
+
+      def to_h
+        {
+          "url" => url,
+          "id" => id,
+          "token" => token,
+          "tenant" => tenant,
+          "taskId" => task_id,
+          "authentication" => authentication
+        }.compact
+      end
+    end
+  end
+end

data/lib/a2a/push_notification/dispatcher.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module A2A
+  module PushNotification
+    class Dispatcher
+      def initialize(transport: Transport.new)
+        @transport = transport
+      end
+
+      def dispatch(config, event)
+        headers = {
+          "Content-Type" => "application/json",
+          "Accept" => "application/json"
+        }
+        headers["Authorization"] = config.authentication.authorization_header if config.authentication
+
+        @transport.post(config.url, body: event.to_h, headers: headers)
+      end
+
+      class Transport
+        def post(url, body:, headers:)
+          uri = URI.parse(url)
+          handle(http_for(uri).request(build_request(uri, body, headers)))
+        end
+
+        private
+
+        def handle(response)
+          return if (200..299).cover?(response.code.to_i)
+
+          raise TransportError, "push notification delivery failed: HTTP #{response.code}"
+        end
+
+        def http_for(uri)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          http
+        end
+
+        def build_request(uri, body, headers)
+          request = Net::HTTP::Post.new(uri.request_uri, headers)
+          request.body = JSON.generate(body)
+          request
+        end
+      end
+    end
+  end
+end

data/lib/a2a/push_notification/receiver.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "rack"
+require "json"
+
+module A2A
+  module PushNotification
+    class Receiver
+      def initialize(app, path: "/a2a/webhook", scheme: "Bearer", credentials: nil, &handler)
+        @app = app
+        @path = path
+        @scheme = scheme
+        @credentials = credentials
+        @handler = handler
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+        return @app.call(env) unless request.post? && request.path == @path
+        return unauthorized unless authorized?(request)
+
+        handle_event(request)
+      end
+
+      private
+
+      def handle_event(request)
+        event = Streaming::Response.from_h(JSON.parse(request.body.read))
+        @handler.call(event)
+        json(200, { "ok" => true })
+      rescue JSON::ParserError => e
+        json(400, { "error" => "invalid JSON: #{e.message}" })
+      rescue ArgumentError => e
+        json(400, { "error" => e.message })
+      end
+
+      def authorized?(request)
+        return true unless @credentials
+
+        expected = "#{@scheme} #{@credentials}"
+        actual = request.get_header("HTTP_AUTHORIZATION").to_s
+        actual.casecmp(expected).zero?
+      end
+
+      def unauthorized
+        json(401, { "error" => "unauthorized" })
+      end
+
+      def json(status, body)
+        [status, { "Content-Type" => "application/json" }, [JSON.generate(body)]]
+      end
+    end
+  end
+end

data/lib/a2a/push_notification.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "push_notification/authentication_info"
+require_relative "push_notification/config"
+require_relative "push_notification/dispatcher"
+require_relative "push_notification/receiver"
+
+module A2A
+  module PushNotification
+  end
+end

data/lib/a2a/role.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module A2A
+  module Role
+    UNSPECIFIED = "ROLE_UNSPECIFIED"
+    USER        = "ROLE_USER"
+    AGENT       = "ROLE_AGENT"
+
+    ALL = [UNSPECIFIED, USER, AGENT].freeze
+
+    def self.valid?(value) = ALL.include?(value)
+  end
+end

data/lib/a2a/security_requirement.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module A2A
+  class SecurityRequirement
+    attr_reader :schemes
+
+    def initialize(schemes:)
+      @schemes = schemes
+    end
+
+    def self.from_h(hash)
+      new(schemes: hash.transform_values { _1.is_a?(Array) ? _1 : _1["list"] })
+    end
+
+    def to_h
+      schemes
+    end
+  end
+end

data/lib/a2a/security_scheme/api_key.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module A2A
+  module SecurityScheme
+    class APIKey
+      attr_reader :name, :location, :description
+
+      def initialize(name:, location:, description: nil)
+        @name = name
+        @location = location
+        @description = description
+      end
+
+      def self.from_h(hash)
+        new(
+          name: hash.fetch("name"),
+          location: hash.fetch("location"),
+          description: hash["description"]
+        )
+      end
+
+      def to_h
+        {
+          "apiKeySecurityScheme" => {
+            "name" => name,
+            "location" => location,
+            "description" => description
+          }.compact
+        }
+      end
+    end
+  end
+end

data/lib/a2a/security_scheme/http_auth.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module A2A
+  module SecurityScheme
+    class HTTPAuth
+      attr_reader :scheme, :bearer_format, :description
+
+      def initialize(scheme:, bearer_format: nil, description: nil)
+        @scheme = scheme
+        @bearer_format = bearer_format
+        @description = description
+      end
+
+      def self.from_h(hash)
+        new(
+          scheme: hash.fetch("scheme"),
+          bearer_format: hash["bearerFormat"],
+          description: hash["description"]
+        )
+      end
+
+      def to_h
+        {
+          "httpAuthSecurityScheme" => {
+            "scheme" => scheme,
+            "bearerFormat" => bearer_format,
+            "description" => description
+          }.compact
+        }
+      end
+    end
+  end
+end