a2a-rb 0.1.1

data/lib/a2a/oauth_flow.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "oauth_flow/authorization_code"
+require_relative "oauth_flow/client_credentials"
+require_relative "oauth_flow/device_code"
+
+module A2A
+  module OAuthFlow
+    FLOW_KEYS = %w[authorizationCode clientCredentials deviceCode].freeze
+    DEPRECATED_FLOW_KEYS = %w[implicit password].freeze
+
+    def self.from_h(hash)
+      reject_deprecated!(hash)
+      matched = FLOW_KEYS.count { |k| hash.key?(k) }
+      raise ArgumentError, "OAuthFlows must contain exactly one flow type, got #{matched}" unless matched == 1
+
+      build_flows(hash)
+    end
+
+    def self.build_flows(hash)
+      {}.tap do |flows|
+        flows[:authorization_code] = AuthorizationCode.from_h(hash["authorizationCode"]) if hash["authorizationCode"]
+        flows[:client_credentials] = ClientCredentials.from_h(hash["clientCredentials"]) if hash["clientCredentials"]
+        flows[:device_code] = DeviceCode.from_h(hash["deviceCode"]) if hash["deviceCode"]
+      end
+    end
+
+    def self.reject_deprecated!(hash)
+      deprecated = DEPRECATED_FLOW_KEYS.select { |k| hash.key?(k) }
+      return unless deprecated.any?
+
+      raise ArgumentError,
+            "OAuthFlows contains deprecated flow(s): #{deprecated.join(', ')} — use authorizationCode or deviceCode"
+    end
+    private_class_method :build_flows, :reject_deprecated!
+  end
+end

data/lib/a2a/operation/cancel_task.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module A2A
+  module Operation
+    class CancelTask
+      include Executable
+
+      METHOD = "CancelTask"
+
+      attr_reader :id, :metadata, :tenant
+
+      def initialize(id:, metadata: nil, tenant: nil)
+        @id = id
+        @metadata = metadata
+        @tenant = tenant
+      end
+
+      def execute_json_rpc(protocol)
+        raw = protocol.post(METHOD, params)
+        raise A2A.from_json_rpc_error(raw["error"]) if raw["error"]
+
+        Task.from_h(Hash(raw["result"]))
+      end
+
+      def execute_http_json(protocol)
+        body = metadata ? { "metadata" => metadata } : {}
+        Task.from_h(protocol.post("/tasks/#{id}:cancel", body: body))
+      end
+
+      def params
+        {
+          "id" => id,
+          "metadata" => metadata,
+          "tenant" => tenant
+        }.compact
+      end
+    end
+  end
+end

data/lib/a2a/operation/create_task_push_notification_config.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module A2A
+  module Operation
+    class CreateTaskPushNotificationConfig
+      include Executable
+
+      METHOD = "CreateTaskPushNotificationConfig"
+
+      attr_reader :config, :tenant
+
+      def initialize(config, tenant: nil)
+        @config = config.is_a?(PushNotification::Config) ? config : PushNotification::Config.from_h(config)
+        @tenant = tenant
+      end
+
+      def execute_json_rpc(protocol)
+        raw = protocol.post(METHOD, params)
+        raise A2A.from_json_rpc_error(raw["error"]) if raw["error"]
+
+        PushNotification::Config.from_h(Hash(raw["result"]))
+      end
+
+      def execute_http_json(protocol)
+        PushNotification::Config.from_h(
+          protocol.post("/tasks/#{config.task_id}/pushNotificationConfigs", body: config.to_h)
+        )
+      end
+
+      def params
+        {
+          "pushNotificationConfig" => config.to_h,
+          "tenant" => tenant
+        }.compact
+      end
+    end
+  end
+end

data/lib/a2a/operation/delete_task_push_notification_config.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module A2A
+  module Operation
+    class DeleteTaskPushNotificationConfig
+      include Executable
+
+      METHOD = "DeleteTaskPushNotificationConfig"
+
+      attr_reader :task_id, :id, :tenant
+
+      def initialize(task_id:, id:, tenant: nil)
+        @task_id = task_id
+        @id = id
+        @tenant = tenant
+      end
+
+      def execute_json_rpc(protocol)
+        raw = protocol.post(METHOD, params)
+        raise A2A.from_json_rpc_error(raw["error"]) if raw["error"]
+
+        nil
+      end
+
+      def execute_http_json(protocol)
+        protocol.delete("/tasks/#{task_id}/pushNotificationConfigs/#{id}")
+      end
+
+      def params
+        {
+          "taskId" => task_id,
+          "id" => id,
+          "tenant" => tenant
+        }.compact
+      end
+    end
+  end
+end

data/lib/a2a/operation/executable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module A2A
+  module Operation
+    module Executable
+      def execute(protocol, &)
+        if protocol.is_a?(Protocol::HttpJson)
+          execute_http_json(protocol, &)
+        else
+          execute_json_rpc(protocol, &)
+        end
+      end
+
+      def execute_json_rpc(*)
+        raise NotImplementedError, "#{self.class}#execute_json_rpc is not implemented"
+      end
+
+      def execute_http_json(*)
+        raise NotImplementedError, "#{self.class}#execute_http_json is not implemented"
+      end
+
+      def params
+        raise NotImplementedError, "#{self.class}#params is not implemented"
+      end
+    end
+  end
+end

data/lib/a2a/operation/get_extended_agent_card.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module A2A
+  module Operation
+    class GetExtendedAgentCard
+      include Executable
+
+      METHOD = "GetExtendedAgentCard"
+
+      attr_reader :tenant
+
+      def initialize(tenant: nil)
+        @tenant = tenant
+      end
+
+      def execute_json_rpc(protocol)
+        raw = protocol.post(METHOD, params)
+        raise A2A.from_json_rpc_error(raw["error"]) if raw["error"]
+
+        AgentCard.from_h(Hash(raw["result"]))
+      end
+
+      def execute_http_json(protocol)
+        AgentCard.from_h(protocol.get("/extendedAgentCard", query: {}))
+      end
+
+      def params
+        { "tenant" => tenant }.compact
+      end
+    end
+  end
+end

data/lib/a2a/operation/get_task.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module A2A
+  module Operation
+    class GetTask
+      include Executable
+
+      METHOD = "GetTask"
+
+      attr_reader :id, :history_length, :tenant
+
+      def initialize(id:, history_length: nil, tenant: nil)
+        @id = id
+        @history_length = history_length
+        @tenant = tenant
+      end
+
+      def execute_json_rpc(protocol)
+        raw = protocol.post(METHOD, params)
+        raise A2A.from_json_rpc_error(raw["error"]) if raw["error"]
+
+        Task.from_h(Hash(raw["result"]))
+      end
+
+      def execute_http_json(protocol)
+        query = { "historyLength" => history_length }.compact
+        Task.from_h(protocol.get("/tasks/#{id}", query: query))
+      end
+
+      def params
+        {
+          "id" => id,
+          "historyLength" => history_length,
+          "tenant" => tenant
+        }.compact
+      end
+    end
+  end
+end

data/lib/a2a/operation/get_task_push_notification_config.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module A2A
+  module Operation
+    class GetTaskPushNotificationConfig
+      include Executable
+
+      METHOD = "GetTaskPushNotificationConfig"
+
+      attr_reader :task_id, :id, :tenant
+
+      def initialize(task_id:, id:, tenant: nil)
+        @task_id = task_id
+        @id = id
+        @tenant = tenant
+      end
+
+      def execute_json_rpc(protocol)
+        raw = protocol.post(METHOD, params)
+        raise A2A.from_json_rpc_error(raw["error"]) if raw["error"]
+
+        PushNotification::Config.from_h(Hash(raw["result"]))
+      end
+
+      def execute_http_json(protocol)
+        PushNotification::Config.from_h(protocol.get("/tasks/#{task_id}/pushNotificationConfigs/#{id}", query: {}))
+      end
+
+      def params
+        {
+          "taskId" => task_id,
+          "id" => id,
+          "tenant" => tenant
+        }.compact
+      end
+    end
+  end
+end

data/lib/a2a/operation/list_task_push_notification_configs.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module A2A
+  module Operation
+    class ListTaskPushNotificationConfigs
+      include Executable
+
+      METHOD = "ListTaskPushNotificationConfigs"
+
+      attr_reader :task_id, :page_size, :page_token, :tenant
+
+      def initialize(task_id:, page_size: nil, page_token: nil, tenant: nil)
+        @task_id = task_id
+        @page_size = page_size
+        @page_token = page_token
+        @tenant = tenant
+      end
+
+      def execute_json_rpc(protocol)
+        raw = protocol.post(METHOD, params)
+        raise A2A.from_json_rpc_error(raw["error"]) if raw["error"]
+
+        Response.from_h(Hash(raw["result"]))
+      end
+
+      def execute_http_json(protocol)
+        query = { "pageSize" => page_size, "pageToken" => page_token }.compact
+        Response.from_h(protocol.get("/tasks/#{task_id}/pushNotificationConfigs", query: query))
+      end
+
+      def params
+        {
+          "taskId" => task_id,
+          "pageSize" => page_size,
+          "pageToken" => page_token,
+          "tenant" => tenant
+        }.compact
+      end
+
+      class Response
+        attr_reader :configs, :next_page_token
+
+        def initialize(configs:, next_page_token: nil)
+          @configs = configs
+          @next_page_token = next_page_token
+        end
+
+        def self.from_h(hash)
+          new(
+            configs: Array(hash["configs"]).map { PushNotification::Config.from_h(_1) },
+            next_page_token: hash["nextPageToken"]
+          )
+        end
+
+        def to_h
+          {
+            "configs" => configs.map(&:to_h),
+            "nextPageToken" => next_page_token
+          }.compact
+        end
+      end
+    end
+  end
+end

data/lib/a2a/operation/list_tasks.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module A2A
+  module Operation
+    class ListTasks
+      include Executable
+
+      METHOD = "ListTasks"
+
+      attr_reader :context_id, :status, :page_size, :page_token, :history_length,
+                  :status_timestamp_after, :include_artifacts, :tenant
+
+      def initialize(**kwargs)
+        @context_id = kwargs[:context_id]
+        @status = kwargs[:status]
+        @page_size = kwargs[:page_size]
+        @page_token = kwargs[:page_token]
+        @history_length = kwargs[:history_length]
+        @status_timestamp_after = kwargs[:status_timestamp_after]
+        @include_artifacts = kwargs[:include_artifacts]
+        @tenant = kwargs[:tenant]
+      end
+
+      def execute_json_rpc(protocol)
+        raw = protocol.post(METHOD, params)
+        raise A2A.from_json_rpc_error(raw["error"]) if raw["error"]
+
+        Response.from_h(Hash(raw["result"]))
+      end
+
+      def execute_http_json(protocol)
+        Response.from_h(protocol.get("/tasks", query: params))
+      end
+
+      def params
+        {
+          "contextId" => context_id,
+          "status" => status,
+          "pageSize" => page_size,
+          "pageToken" => page_token,
+          "historyLength" => history_length,
+          "statusTimestampAfter" => status_timestamp_after,
+          "includeArtifacts" => include_artifacts,
+          "tenant" => tenant
+        }.compact
+      end
+
+      class Response
+        attr_reader :tasks, :next_page_token, :page_size, :total_size
+
+        def initialize(tasks:, next_page_token:, page_size:, total_size:)
+          @tasks = tasks
+          @next_page_token = next_page_token
+          @page_size = page_size
+          @total_size = total_size
+        end
+
+        def self.from_h(hash)
+          new(
+            tasks: Array(hash["tasks"]).map { Task.from_h(_1) },
+            next_page_token: hash.fetch("nextPageToken"),
+            page_size: hash.fetch("pageSize"),
+            total_size: hash.fetch("totalSize")
+          )
+        end
+
+        def to_h
+          {
+            "tasks" => tasks.map(&:to_h),
+            "nextPageToken" => next_page_token,
+            "pageSize" => page_size,
+            "totalSize" => total_size
+          }
+        end
+      end
+    end
+  end
+end

data/lib/a2a/operation/send_message/configuration.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module A2A
+  module Operation
+    class SendMessage
+      class Configuration
+        attr_reader :accepted_output_modes, :task_push_notification_config, :history_length,
+                    :return_immediately
+
+        def initialize(**kwargs)
+          @accepted_output_modes = kwargs[:accepted_output_modes]
+          @task_push_notification_config = kwargs[:task_push_notification_config]
+          @history_length = kwargs[:history_length]
+          @return_immediately = kwargs[:return_immediately]
+        end
+
+        def self.from_h(hash)
+          new(
+            accepted_output_modes: hash["acceptedOutputModes"],
+            task_push_notification_config: hash["taskPushNotificationConfig"],
+            history_length: hash["historyLength"],
+            return_immediately: hash["returnImmediately"]
+          )
+        end
+
+        def to_h
+          push_config = task_push_notification_config
+          push_config = push_config.to_h if push_config.is_a?(PushNotification::Config)
+          {
+            "acceptedOutputModes" => accepted_output_modes,
+            "taskPushNotificationConfig" => push_config,
+            "historyLength" => history_length,
+            "returnImmediately" => return_immediately
+          }.compact
+        end
+      end
+    end
+  end
+end

data/lib/a2a/operation/send_message.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "send_message/configuration"
+
+module A2A
+  module Operation
+    class SendMessage
+      include Executable
+
+      METHOD = "SendMessage"
+
+      attr_reader :message, :configuration, :metadata, :tenant
+
+      def initialize(message, configuration: {}, metadata: nil, tenant: nil)
+        @message = message.is_a?(Message) ? message : Message.from_h(message)
+        @configuration = if configuration.is_a?(Configuration)
+                           configuration
+                         else
+                           Configuration.new(**configuration.transform_keys(&:to_sym))
+                         end
+        @metadata = metadata
+        @tenant = tenant
+      end
+
+      def execute_json_rpc(protocol)
+        raw = protocol.post(METHOD, params)
+        raise A2A.from_json_rpc_error(raw["error"]) if raw["error"]
+
+        parse_result(Hash(raw["result"]))
+      end
+
+      def execute_http_json(protocol)
+        parse_result(protocol.post("/message:send", body: params))
+      end
+
+      def params
+        p = { "message" => message.to_h }
+        config_h = configuration.to_h
+        p["configuration"] = config_h unless config_h.empty?
+        p["metadata"] = metadata if metadata
+        p["tenant"] = tenant if tenant
+        p
+      end
+
+      private
+
+      def parse_result(result)
+        if result.key?("task")
+          Task.from_h(result["task"])
+        elsif result.key?("message")
+          Message.from_h(result["message"])
+        else
+          raise InvalidAgentResponseError, "response is neither Task nor Message"
+        end
+      end
+    end
+  end
+end

data/lib/a2a/operation/send_message_request.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "send_message/configuration"
+
+module A2A
+  module Operation
+    # Server-side counterpart to SendMessage. Deserialises the params hash from
+    # an incoming SendMessage / SendStreamingMessage JSON-RPC call or HTTP+JSON
+    # request body into typed objects.
+    class SendMessageRequest
+      attr_reader :message, :configuration, :metadata, :tenant
+
+      def initialize(message:, configuration: nil, metadata: nil, tenant: nil)
+        @message = message
+        @configuration = configuration
+        @metadata = metadata
+        @tenant = tenant
+      end
+
+      def self.from_h(hash)
+        config_raw = hash["configuration"]
+        config = if config_raw
+                   SendMessage::Configuration.from_h(config_raw)
+                 else
+                   SendMessage::Configuration.new
+                 end
+
+        new(
+          message: Message.from_h(hash.fetch("message")),
+          configuration: config,
+          metadata: hash["metadata"],
+          tenant: hash["tenant"]
+        )
+      end
+    end
+  end
+end

data/lib/a2a/operation/send_streaming_message.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module A2A
+  module Operation
+    class SendStreamingMessage
+      include Executable
+
+      METHOD = "SendStreamingMessage"
+
+      Configuration = SendMessage::Configuration
+
+      attr_reader :message, :configuration, :metadata, :tenant
+
+      def initialize(message, configuration: {}, metadata: nil, tenant: nil)
+        @message = message.is_a?(Message) ? message : Message.from_h(message)
+        @configuration = if configuration.is_a?(Configuration)
+                           configuration
+                         else
+                           Configuration.new(**configuration.transform_keys(&:to_sym))
+                         end
+        @metadata = metadata
+        @tenant = tenant
+      end
+
+      def execute_json_rpc(protocol, &block)
+        protocol.stream(METHOD, params) do |response|
+          sub = Streaming::Subscription.new(response)
+          return sub unless block
+
+          sub.each(&block)
+        end
+      end
+
+      def execute_http_json(protocol, &block)
+        protocol.stream("/message:stream", method: :post, body: params) do |response|
+          sub = Streaming::Subscription.new(response)
+          return sub unless block
+
+          sub.each(&block)
+        end
+      end
+
+      def params
+        p = { "message" => message.to_h }
+        config_h = configuration.to_h
+        p["configuration"] = config_h unless config_h.empty?
+        p["metadata"] = metadata if metadata
+        p["tenant"] = tenant if tenant
+        p
+      end
+    end
+  end
+end

data/lib/a2a/operation/subscribe_to_task.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module A2A
+  module Operation
+    class SubscribeToTask
+      include Executable
+
+      METHOD = "SubscribeToTask"
+
+      attr_reader :id, :tenant
+
+      def initialize(id:, tenant: nil)
+        @id = id
+        @tenant = tenant
+      end
+
+      def execute_json_rpc(protocol, &block)
+        protocol.stream(METHOD, params) do |response|
+          sub = Streaming::Subscription.new(response)
+          return sub unless block
+
+          sub.each(&block)
+        end
+      end
+
+      def execute_http_json(protocol, &block)
+        protocol.stream("/tasks/#{id}:subscribe", method: :get) do |response|
+          sub = Streaming::Subscription.new(response)
+          return sub unless block
+
+          sub.each(&block)
+        end
+      end
+
+      def params
+        { "id" => id, "tenant" => tenant }.compact
+      end
+    end
+  end
+end

data/lib/a2a/operation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "operation/executable"
+require_relative "operation/send_message"
+require_relative "operation/send_streaming_message"
+require_relative "operation/get_task"
+require_relative "operation/list_tasks"
+require_relative "operation/cancel_task"
+require_relative "operation/subscribe_to_task"
+require_relative "operation/create_task_push_notification_config"
+require_relative "operation/get_task_push_notification_config"
+require_relative "operation/list_task_push_notification_configs"
+require_relative "operation/delete_task_push_notification_config"
+require_relative "operation/get_extended_agent_card"
+
+module A2A
+  module Operation
+  end
+end