agent2agent 1.0.0

data/lib/a2a/store/webhooks.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "async"
+require "async/http/internet"
+require "json"
+require "console"
+
+module A2A
+  module Store
+    # Async webhook delivery for A2A push notifications.
+    #
+    # Following the gospel (async-http):
+    #   - Uses Async::HTTP::Internet for non-blocking HTTP requests
+    #   - Each delivery runs in its own Async task (fiber, not thread)
+    #   - Failures are logged but do not propagate
+    #
+    # The A2A spec says:
+    #   - Push notification payloads use StreamResponse format
+    #   - Content-Type: application/a2a+json
+    #   - Authentication via scheme + credentials from the config
+    #   - Token header: X-A2A-Notification-Token
+    #   - Delivery is at-least-once with possible retries
+    #
+    class Webhooks
+      def initialize
+        @internet = nil
+      end
+
+      # Deliver a payload to all push notification configs for a task.
+      #
+      # @param configs [Array<Hash>] push notification configs
+      # @param payload [Hash] the StreamResponse payload
+      #
+      def deliver(configs, payload)
+        return if configs.nil? || configs.empty?
+
+        configs.each do |config|
+          Async do
+            deliver_single(config, payload)
+          rescue => e
+            Console.error(self) { "Webhook delivery failed for #{config["url"]}: #{e.message}" }
+          end
+        end
+      end
+
+      private
+
+        def internet
+          @internet ||= Async::HTTP::Internet.new
+        end
+
+        def deliver_single(config, payload)
+          url = config["url"]
+          return unless url && !url.empty?
+
+          headers = {
+            "content-type" => "application/a2a+json",
+          }
+
+          # Authentication
+          if (auth = config["authentication"])
+            scheme = auth["scheme"] || "Bearer"
+            creds  = auth["credentials"] || ""
+            headers["authorization"] = "#{scheme} #{creds}"
+          end
+
+          # Token header
+          if (token = config["token"])
+            headers["x-a2a-notification-token"] = token
+          end
+
+          body = JSON.generate(payload)
+
+          internet.post(url, headers, [body])
+        end
+    end
+  end
+end
+
+test do
+  describe "A2A::Store::Webhooks" do
+    it "can be instantiated" do
+      wh = A2A::Store::Webhooks.new
+      wh.should.not.be.nil
+    end
+
+    it "silently skips empty config lists" do
+      wh = A2A::Store::Webhooks.new
+      # Should not raise — returns nil for empty/nil configs
+      wh.deliver([], { "statusUpdate" => {} }).should.be.nil
+      wh.deliver(nil, { "statusUpdate" => {} }).should.be.nil
+    end
+  end
+end

data/lib/a2a/store.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "store/pub_sub"
+require_relative "store/webhooks"
+require_relative "store/sqlite"
+require_relative "store/processor"

data/lib/a2a/task_store.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "a2a"
+require "securerandom"
+require "net/http"
+require "uri"
+require "json"
+
+module A2A
+  Task = Struct.new(
+    :id, :context_id, :state, :result, :artifacts, :history,
+    :push_configs, :subscribers, :created_at, :updated_at,
+    keyword_init: true
+  )
+
+  # In-memory task registry with pub/sub for streaming and webhook delivery.
+  # Swap for a DB-backed implementation in production --
+  # if the server crashes, in-memory tasks vanish and the client never gets notified.
+  class TaskStore
+    TERMINAL_STATES = %w[
+      TASK_STATE_COMPLETED TASK_STATE_FAILED
+      TASK_STATE_CANCELED TASK_STATE_REJECTED
+    ].freeze
+
+    def initialize
+      @tasks = {}
+      @mutex = Mutex.new
+    end
+
+    # ── Task CRUD ──────────────────────────────────────────────────────
+
+    def create(id, context_id, push_config = nil)
+      @mutex.synchronize do
+        now = Time.now.utc
+        configs = {}
+        if push_config
+          cfg_id = push_config["id"] || SecureRandom.uuid
+          push_config["id"] = cfg_id
+          configs[cfg_id] = push_config
+        end
+
+        @tasks[id] = Task.new(
+          id:           id,
+          context_id:   context_id,
+          state:        "TASK_STATE_SUBMITTED",
+          result:       nil,
+          artifacts:    [],
+          history:      [],
+          push_configs: configs,
+          subscribers:  [],
+          created_at:   now,
+          updated_at:   now,
+        )
+      end
+    end
+
+    def get(id)
+      @mutex.synchronize { @tasks[id] }
+    end
+
+    def update_state(id, state, message: nil)
+      task = nil
+      @mutex.synchronize do
+        task = @tasks[id]
+        return nil unless task
+        task.state = state
+        task.updated_at = Time.now.utc
+      end
+      if task
+        event = build_status_event(task, message)
+        notify_subscribers(task, event)
+        deliver_webhooks(task, { "statusUpdate" => event })
+      end
+      task
+    end
+
+    def complete(id, result)
+      task = nil
+      @mutex.synchronize do
+        task = @tasks[id]
+        return nil unless task
+        task.state  = "TASK_STATE_COMPLETED"
+        task.result = result
+        task.updated_at = Time.now.utc
+      end
+      if task
+        event = build_status_event(task)
+        notify_subscribers(task, event)
+        deliver_webhooks(task, { "statusUpdate" => event })
+        close_subscribers(task)
+      end
+      task
+    end
+
+    def fail(id, msg)
+      task = nil
+      @mutex.synchronize do
+        task = @tasks[id]
+        return nil unless task
+        task.state  = "TASK_STATE_FAILED"
+        task.result = msg
+        task.updated_at = Time.now.utc
+      end
+      if task
+        event = build_status_event(task)
+        notify_subscribers(task, event)
+        deliver_webhooks(task, { "statusUpdate" => event })
+        close_subscribers(task)
+      end
+      task
+    end
+
+    def cancel(id)
+      update_state(id, "TASK_STATE_CANCELED")
+      task = get(id)
+      close_subscribers(task) if task
+      task
+    end
+
+    def terminal?(id)
+      task = get(id)
+      task && TERMINAL_STATES.include?(task.state)
+    end
+
+    # ── Artifacts ──────────────────────────────────────────────────────
+
+    def add_artifact(id, artifact)
+      task = nil
+      @mutex.synchronize do
+        task = @tasks[id]
+        return nil unless task
+        task.artifacts << artifact
+        task.updated_at = Time.now.utc
+      end
+      if task
+        event = {
+          "taskId"    => task.id,
+          "contextId" => task.context_id,
+          "artifact"  => artifact,
+          "append"    => false,
+          "lastChunk" => true,
+        }
+        notify_subscribers(task, event, type: :artifact)
+        deliver_webhooks(task, { "artifactUpdate" => event })
+      end
+      task
+    end
+
+    # ── History ────────────────────────────────────────────────────────
+
+    def add_message(id, msg)
+      @mutex.synchronize do
+        task = @tasks[id]
+        return nil unless task
+        task.history << msg
+        task.updated_at = Time.now.utc
+        task
+      end
+    end
+
+    # ── Listing ────────────────────────────────────────────────────────
+
+    def list(context_id: nil, state: nil)
+      @mutex.synchronize do
+        @tasks.values
+              .select { |t| context_id.nil? || t.context_id == context_id }
+              .select { |t| state.nil?      || t.state == state }
+              .sort_by { |t| t.updated_at }
+              .reverse
+      end
+    end
+
+    # ── Push Notification Config CRUD ──────────────────────────────────
+
+    def create_push_config(task_id, config)
+      @mutex.synchronize do
+        task = @tasks[task_id]
+        return nil unless task
+        cfg_id = config["id"] || SecureRandom.uuid
+        config["id"] = cfg_id
+        config["taskId"] = task_id
+        task.push_configs[cfg_id] = config
+        task.updated_at = Time.now.utc
+        config
+      end
+    end
+
+    def get_push_config(task_id, config_id)
+      @mutex.synchronize do
+        task = @tasks[task_id]
+        return nil unless task
+        task.push_configs[config_id]
+      end
+    end
+
+    def list_push_configs(task_id)
+      @mutex.synchronize do
+        task = @tasks[task_id]
+        return [] unless task
+        task.push_configs.values
+      end
+    end
+
+    def delete_push_config(task_id, config_id)
+      @mutex.synchronize do
+        task = @tasks[task_id]
+        return nil unless task
+        task.push_configs.delete(config_id)
+        task.updated_at = Time.now.utc
+      end
+    end
+
+    # ── Streaming / Pub-Sub ────────────────────────────────────────────
+
+    # Subscribe to task updates. Returns a Queue that will receive events.
+    # Each event is a Hash: { type: :status|:artifact, data: Hash }
+    # A nil sentinel signals stream end.
+    def subscribe(task_id)
+      queue = Thread::Queue.new
+      @mutex.synchronize do
+        task = @tasks[task_id]
+        return nil unless task
+        task.subscribers << queue
+      end
+      queue
+    end
+
+    def unsubscribe(task_id, queue)
+      @mutex.synchronize do
+        task = @tasks[task_id]
+        return unless task
+        task.subscribers.delete(queue)
+      end
+    end
+
+    private
+
+      def build_status_event(task, message = nil)
+        event = {
+          "taskId"    => task.id,
+          "contextId" => task.context_id,
+          "status"    => {
+            "state"     => task.state,
+            "timestamp" => task.updated_at.strftime("%Y-%m-%dT%H:%M:%S.%3NZ"),
+          },
+        }
+        event["status"]["message"] = message if message
+        event
+      end
+
+      def notify_subscribers(task, event, type: :status)
+        subs = @mutex.synchronize { task.subscribers.dup }
+        subs.each do |queue|
+          queue << { type: type, data: event }
+        rescue ClosedQueueError
+          # subscriber disconnected
+        end
+      end
+
+      def close_subscribers(task)
+        subs = @mutex.synchronize { task.subscribers.dup }
+        subs.each do |queue|
+          queue << nil # sentinel
+          queue.close
+        rescue ClosedQueueError
+          # already closed
+        end
+        @mutex.synchronize { task.subscribers.clear }
+      end
+
+      def deliver_webhooks(task, payload)
+        configs = @mutex.synchronize { task.push_configs.values.dup }
+        return if configs.empty?
+
+        configs.each do |config|
+          Thread.new do
+            deliver_single_webhook(config, payload)
+          rescue => e
+            # Log but don't fail
+            $stderr.puts "[A2A::TaskStore] Webhook delivery failed for #{config["url"]}: #{e.message}"
+          end
+        end
+      end
+
+      def deliver_single_webhook(config, payload)
+        url = config["url"]
+        return unless url && !url.empty?
+
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = 10
+        http.read_timeout = 30
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request["Content-Type"] = "application/a2a+json"
+
+        # Authentication
+        if (auth = config["authentication"])
+          scheme = auth["scheme"] || "Bearer"
+          creds  = auth["credentials"] || ""
+          request["Authorization"] = "#{scheme} #{creds}"
+        end
+
+        # Token header
+        if (token = config["token"])
+          request["X-A2A-Notification-Token"] = token
+        end
+
+        request.body = JSON.generate(payload)
+        http.request(request)
+      end
+  end
+end

data/lib/a2a/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module A2A
+  VERSION = "1.0.0"
+end

data/lib/a2a.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "scampi"
+require "json"
+require "json_schemer"
+require "async"
+require "async/http/internet"
+require "uri"
+require "rack"
+
+module A2A
+end
+
+require "a2a/proto"
+require "a2a/schema"
+require "a2a/schema/definition"
+require "a2a/schema/validation_error"
+require "a2a/task_store"
+require "a2a/store"
+require "a2a/sse"
+require "a2a/agent"
+
+require "a2a/server"
+
+require "a2a/client"

metadata

@@ -0,0 +1,216 @@
+--- !ruby/object:Gem::Specification
+name: agent2agent
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- A2A Contributors
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: async-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.95'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.95'
+- !ruby/object:Gem::Dependency
+  name: protocol-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.62'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.62'
+- !ruby/object:Gem::Dependency
+  name: scampi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: json_schemer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: google-protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.34'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.34'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: falcon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.55'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.55'
+description: Abstraction to help work with A2A protocol
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- data/a2a.json
+- data/a2a.proto
+- data/download-a2a-resources
+- data/spec.txt
+- lib/a2a.rb
+- lib/a2a/agent.rb
+- lib/a2a/bindings/json_rpc.rb
+- lib/a2a/bindings/rest.rb
+- lib/a2a/client.rb
+- lib/a2a/proto.rb
+- lib/a2a/schema.rb
+- lib/a2a/schema/definition.rb
+- lib/a2a/schema/validation_error.rb
+- lib/a2a/server.rb
+- lib/a2a/server/cancel_task.rb
+- lib/a2a/server/create_task_push_notification_config.rb
+- lib/a2a/server/delete_task_push_notification_config.rb
+- lib/a2a/server/dispatcher.rb
+- lib/a2a/server/env.rb
+- lib/a2a/server/get_extended_agent_card.rb
+- lib/a2a/server/get_task.rb
+- lib/a2a/server/get_task_push_notification_config.rb
+- lib/a2a/server/list_task_push_notification_configs.rb
+- lib/a2a/server/list_tasks.rb
+- lib/a2a/server/send_message.rb
+- lib/a2a/server/send_streaming_message.rb
+- lib/a2a/server/subscribe_to_task.rb
+- lib/a2a/server/triage.rb
+- lib/a2a/sse.rb
+- lib/a2a/sse/json_rpc_stream.rb
+- lib/a2a/sse/rest_stream.rb
+- lib/a2a/sse/stream.rb
+- lib/a2a/store.rb
+- lib/a2a/store/processor.rb
+- lib/a2a/store/pub_sub.rb
+- lib/a2a/store/sqlite.rb
+- lib/a2a/store/webhooks.rb
+- lib/a2a/task_store.rb
+- lib/a2a/version.rb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Agent2Agent protocol
+test_files: []