agent2agent 1.0.8 → 1.1.0

data/lib/a2a/faraday/middleware/json_rpc/response.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "a2a"
+require "faraday"
+require "json"
+
+module A2A
+  module Faraday
+    module Middleware
+      module JsonRpc
+        # Faraday response middleware that unwraps JSON-RPC 2.0 responses
+        # and converts the result into A2A::Schema::Definition objects.
+        #
+        # Reads env.request.context[:a2a_operation] to determine which
+        # Schema class to instantiate. If no operation is set, passes through.
+        #
+        # Raises on JSON-RPC error responses.
+        #
+        class Response < ::Faraday::Middleware
+          def on_complete(env)
+            operation = env.request.context&.dig(:a2a_operation)
+            return unless operation
+
+            parsed = env.body
+            return if parsed.nil?
+
+            # Handle string bodies (if JSON response middleware hasn't run)
+            if parsed.is_a?(String)
+              return if parsed.empty?
+              parsed = JSON.parse(parsed)
+            end
+
+            # Handle JSON-RPC error responses
+            if parsed.is_a?(Hash) && (err = parsed["error"])
+              raise A2A::JsonRpcError.new(err["message"], code: err["code"], data: err["data"])
+            end
+
+            # Extract result from JSON-RPC envelope
+            result = parsed.is_a?(Hash) && parsed.key?("result") ? parsed["result"] : parsed
+
+            schema_class = operation.response_schema
+            unless schema_class
+              env.body = result
+              return
+            end
+
+            env.body = schema_class.new(result)
+          rescue JSON::ParserError
+            # Leave body as-is if JSON parsing fails
+          end
+        end
+      end
+    end
+  end
+end
+
+::Faraday::Response.register_middleware(a2a_json_rpc: A2A::Faraday::Middleware::JsonRpc::Response)
+
+test do
+  middleware = A2A::Faraday::Middleware::JsonRpc::Response
+  operation = A2A::Proto.operation("GetTask")
+
+  it "unwraps JSON-RPC result into Schema object" do
+    env = ::Faraday::Env.new
+    env.body = {
+      "jsonrpc" => "2.0", "id" => 1,
+      "result" => {
+        "id" => "task-123", "contextId" => "ctx-456",
+        "status" => { "state" => "TASK_STATE_SUBMITTED" }
+      }
+    }
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: operation }
+
+    middleware.new(nil).on_complete(env)
+
+    env.body.should.be.kind_of(A2A::Schema::Definition)
+    env.body.id.should == "task-123"
+    env.body.context_id.should == "ctx-456"
+  end
+
+  it "raises on JSON-RPC error" do
+    env = ::Faraday::Env.new
+    env.body = {
+      "jsonrpc" => "2.0", "id" => 1,
+      "error" => { "code" => -32600, "message" => "Invalid Request" }
+    }
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: operation }
+
+    lambda { middleware.new(nil).on_complete(env) }.should.raise(A2A::JsonRpcError)
+  end
+
+  it "returns raw hash when response_schema is nil" do
+    op = A2A::Proto.operation("DeleteTaskPushNotificationConfig")
+    env = ::Faraday::Env.new
+    env.body = { "jsonrpc" => "2.0", "id" => 1, "result" => {} }
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: op }
+
+    middleware.new(nil).on_complete(env)
+
+    env.body.should == {}
+  end
+
+  it "passes through when no operation is set" do
+    env = ::Faraday::Env.new
+    env.body = { "foo" => "bar" }
+    env.request = ::Faraday::RequestOptions.new
+
+    middleware.new(nil).on_complete(env)
+
+    env.body.should == { "foo" => "bar" }
+  end
+
+  it "handles string body" do
+    env = ::Faraday::Env.new
+    env.body = JSON.generate({
+      "jsonrpc" => "2.0", "id" => 1,
+      "result" => { "id" => "task-1", "contextId" => "ctx-1", "status" => { "state" => "TASK_STATE_COMPLETED" } }
+    })
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: operation }
+
+    middleware.new(nil).on_complete(env)
+
+    env.body.should.be.kind_of(A2A::Schema::Definition)
+    env.body.id.should == "task-1"
+  end
+end

data/lib/a2a/faraday/middleware/rest/request.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "a2a"
+require "faraday"
+
+module A2A
+  module Faraday
+    module Middleware
+      module REST
+        # Faraday request middleware that rewrites the request for the
+        # A2A HTTP+JSON/REST protocol binding.
+        #
+        # Reads env.request.context[:a2a_operation] to determine the
+        # HTTP verb and path. Interpolates path parameters from the
+        # request body (e.g. {id=*} placeholders). For GET/DELETE
+        # operations, remaining params become query string parameters.
+        #
+        # Sets Content-Type to application/a2a+json for POST requests.
+        #
+        class Request < ::Faraday::Middleware
+          def on_request(env)
+            operation = env.request.context&.dig(:a2a_operation)
+            return unless operation
+
+            params = env.body || {}
+            path = interpolate_path(operation.rest_path, params)
+            remaining = remove_path_params(operation.rest_path, params)
+
+            env.url.path = path
+            env.method = operation.rest_verb.to_sym
+
+            if [:get, :delete].include?(env.method)
+              remaining.each { |k, v| env.params[k.to_s] = v }
+              env.body = nil
+            else
+              env.body = remaining
+              env.request_headers["content-type"] = "application/a2a+json"
+            end
+          end
+
+          private
+
+            # Extract {name=*} placeholder names from a path pattern.
+            def path_param_names(pattern)
+              pattern.scan(/\{(\w+)(?:=[^}]*)?\}/).flatten
+            end
+
+            # Substitute {name=*} placeholders with values from params.
+            # Pattern names are snake_case (e.g. task_id) but Schema#to_h
+            # produces camelCase keys (e.g. taskId), so we check both.
+            def interpolate_path(pattern, params)
+              pattern.gsub(/\{(\w+)(?:=[^}]*)?\}/) do
+                name = $1
+                camel = snake_to_camel(name)
+                params[name] || params[name.to_sym] ||
+                  params[camel] || params[camel.to_sym] || ""
+              end
+            end
+
+            # Return params with path-interpolated keys removed.
+            def remove_path_params(pattern, params)
+              names = path_param_names(pattern)
+              camel_names = names.map { |n| snake_to_camel(n) }
+              all_names = (names + camel_names).to_a
+              params.reject { |k, _| all_names.include?(k.to_s) }
+            end
+
+            # "task_id" => "taskId"
+            def snake_to_camel(str)
+              str.gsub(/_([a-z])/) { $1.upcase }
+            end
+        end
+      end
+    end
+  end
+end
+
+::Faraday::Request.register_middleware(a2a_rest: A2A::Faraday::Middleware::REST::Request)
+
+test do
+  middleware = A2A::Faraday::Middleware::REST::Request
+
+  it "rewrites POST operation with correct path, verb, and content-type" do
+    operation = A2A::Proto.operation("SendMessage")
+    env = ::Faraday::Env.new
+    env.url = URI.parse("http://localhost:9292/")
+    env.body = { "message" => { "role" => "ROLE_USER" } }
+    env.params = {}
+    env.request_headers = {}
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: operation }
+
+    middleware.new(nil).on_request(env)
+
+    env.url.path.should == "/message:send"
+    env.method.should == :post
+    env.body.should == { "message" => { "role" => "ROLE_USER" } }
+    env.request_headers["content-type"].should == "application/a2a+json"
+  end
+
+  it "rewrites GET operation with path interpolation and query params" do
+    operation = A2A::Proto.operation("GetTask")
+    env = ::Faraday::Env.new
+    env.url = URI.parse("http://localhost:9292/")
+    env.body = { "id" => "task-123", "historyLength" => "5" }
+    env.params = {}
+    env.request_headers = {}
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: operation }
+
+    middleware.new(nil).on_request(env)
+
+    env.url.path.should == "/tasks/task-123"
+    env.method.should == :get
+    env.body.should.be.nil
+    env.params["historyLength"].should == "5"
+  end
+
+  it "rewrites DELETE operation with multi-param path interpolation" do
+    operation = A2A::Proto.operation("DeleteTaskPushNotificationConfig")
+    env = ::Faraday::Env.new
+    env.url = URI.parse("http://localhost:9292/")
+    env.body = { "taskId" => "task-123", "id" => "config-1" }
+    env.params = {}
+    env.request_headers = {}
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: operation }
+
+    middleware.new(nil).on_request(env)
+
+    env.url.path.should == "/tasks/task-123/pushNotificationConfigs/config-1"
+    env.method.should == :delete
+    env.body.should.be.nil
+  end
+
+  it "rewrites POST cancel with path interpolation" do
+    operation = A2A::Proto.operation("CancelTask")
+    env = ::Faraday::Env.new
+    env.url = URI.parse("http://localhost:9292/")
+    env.body = { "id" => "task-123", "metadata" => { "key" => "val" } }
+    env.params = {}
+    env.request_headers = {}
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: operation }
+
+    middleware.new(nil).on_request(env)
+
+    env.url.path.should == "/tasks/task-123:cancel"
+    env.method.should == :post
+    env.body.should == { "metadata" => { "key" => "val" } }
+  end
+
+  it "passes through when no operation is set" do
+    env = ::Faraday::Env.new
+    env.url = URI.parse("http://localhost:9292/")
+    env.body = { "foo" => "bar" }
+    env.params = {}
+    env.request_headers = {}
+    env.request = ::Faraday::RequestOptions.new
+
+    middleware.new(nil).on_request(env)
+
+    env.body.should == { "foo" => "bar" }
+  end
+end

data/lib/a2a/faraday/middleware/rest/response.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "a2a"
+require "faraday"
+require "json"
+
+module A2A
+  module Faraday
+    module Middleware
+      module REST
+        # Faraday response middleware for the A2A HTTP+JSON/REST binding.
+        #
+        # Unlike the JSON-RPC binding, REST responses have no envelope —
+        # the body IS the result directly. Errors are signaled via HTTP
+        # status codes with application/problem+json bodies.
+        #
+        # Reads env.request.context[:a2a_operation] to determine which
+        # Schema class to instantiate. If no operation is set, passes through.
+        #
+        class Response < ::Faraday::Middleware
+          def on_complete(env)
+            operation = env.request.context&.dig(:a2a_operation)
+            return unless operation
+
+            if env.status >= 400
+              parsed = env.body
+              if parsed.is_a?(Hash)
+                message = parsed["title"] || parsed["message"] || parsed.to_s
+                data    = parsed["detail"]
+              else
+                message = parsed.to_s
+                data    = nil
+              end
+              raise A2A::RestError.new(message, http_status: env.status, data: data)
+            end
+
+            parsed = env.body
+            return if parsed.nil?
+
+            if parsed.is_a?(String)
+              return if parsed.empty?
+              parsed = JSON.parse(parsed)
+            end
+
+            schema_class = operation.response_schema
+            unless schema_class
+              env.body = parsed
+              return
+            end
+
+            env.body = schema_class.new(parsed)
+          rescue JSON::ParserError
+            # Leave body as-is if JSON parsing fails
+          end
+        end
+      end
+    end
+  end
+end
+
+::Faraday::Response.register_middleware(a2a_rest: A2A::Faraday::Middleware::REST::Response)
+
+test do
+  middleware = A2A::Faraday::Middleware::REST::Response
+  operation = A2A::Proto.operation("GetTask")
+
+  it "wraps response body in Schema object directly (no envelope)" do
+    env = ::Faraday::Env.new
+    env.status = 200
+    env.body = {
+      "id" => "task-123", "contextId" => "ctx-456",
+      "status" => { "state" => "TASK_STATE_SUBMITTED" }
+    }
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: operation }
+
+    middleware.new(nil).on_complete(env)
+
+    env.body.should.be.kind_of(A2A::Schema::Definition)
+    env.body.id.should == "task-123"
+    env.body.context_id.should == "ctx-456"
+  end
+
+  it "returns raw hash when response_schema is nil" do
+    op = A2A::Proto.operation("DeleteTaskPushNotificationConfig")
+    env = ::Faraday::Env.new
+    env.status = 200
+    env.body = {}
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: op }
+
+    middleware.new(nil).on_complete(env)
+
+    env.body.should == {}
+  end
+
+  it "raises on HTTP 4xx error" do
+    env = ::Faraday::Env.new
+    env.status = 400
+    env.body = { "type" => "error", "title" => "Bad Request", "status" => 400 }
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: operation }
+
+    lambda { middleware.new(nil).on_complete(env) }.should.raise(A2A::RestError)
+  end
+
+  it "raises on HTTP 5xx error" do
+    env = ::Faraday::Env.new
+    env.status = 500
+    env.body = { "type" => "error", "title" => "Internal Server Error", "status" => 500 }
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: operation }
+
+    lambda { middleware.new(nil).on_complete(env) }.should.raise(A2A::RestError)
+  end
+
+  it "passes through when no operation is set" do
+    env = ::Faraday::Env.new
+    env.status = 200
+    env.body = { "foo" => "bar" }
+    env.request = ::Faraday::RequestOptions.new
+
+    middleware.new(nil).on_complete(env)
+
+    env.body.should == { "foo" => "bar" }
+  end
+
+  it "handles string body" do
+    env = ::Faraday::Env.new
+    env.status = 200
+    env.body = JSON.generate({
+      "id" => "task-1", "contextId" => "ctx-1",
+      "status" => { "state" => "TASK_STATE_COMPLETED" }
+    })
+    env.request = ::Faraday::RequestOptions.new
+    env.request.context = { a2a_operation: operation }
+
+    middleware.new(nil).on_complete(env)
+
+    env.body.should.be.kind_of(A2A::Schema::Definition)
+    env.body.id.should == "task-1"
+  end
+end

data/lib/a2a/faraday/middleware/schema_request.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "a2a"
+require "faraday"
+require "json"
+
+module A2A
+  module Faraday
+    module Middleware
+      # Faraday request middleware that converts A2A::Schema::Definition
+      # objects into their hash representation for JSON serialization.
+      #
+      # Place this before the :json request middleware in the stack so
+      # that Schema bodies are converted to hashes before Faraday's
+      # JSON middleware serializes them to strings.
+      #
+      class SchemaRequest < ::Faraday::Middleware
+        def on_request(env)
+          body = env.body
+          return unless body.is_a?(A2A::Schema::Definition)
+
+          env.body = body.to_h
+          env.request_headers["content-type"] ||= "application/json"
+        end
+      end
+    end
+  end
+end
+
+::Faraday::Request.register_middleware(a2a_schema: A2A::Faraday::Middleware::SchemaRequest)
+
+test do
+  middleware = A2A::Faraday::Middleware::SchemaRequest
+
+  it "converts Schema::Definition to hash" do
+    schema_obj = A2A::Schema["Agent Capabilities"].new(streaming: true)
+    env = ::Faraday::Env.new
+    env.body = schema_obj
+    env.request_headers = {}
+
+    middleware.new(nil).on_request(env)
+
+    env.body.should == { "streaming" => true }
+    env.request_headers["content-type"].should == "application/json"
+  end
+
+  it "does not modify non-Schema bodies" do
+    env = ::Faraday::Env.new
+    env.body = { "foo" => "bar" }
+    env.request_headers = {}
+
+    middleware.new(nil).on_request(env)
+
+    env.body.should == { "foo" => "bar" }
+    env.request_headers["content-type"].should.be.nil
+  end
+
+  it "does not overwrite existing content-type" do
+    schema_obj = A2A::Schema["Agent Capabilities"].new(streaming: true)
+    env = ::Faraday::Env.new
+    env.body = schema_obj
+    env.request_headers = { "content-type" => "application/a2a+json" }
+
+    middleware.new(nil).on_request(env)
+
+    env.request_headers["content-type"].should == "application/a2a+json"
+  end
+end

data/lib/a2a/middleware/extract_message.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "a2a"
+
+module A2A
+  module Middleware
+    # Extracts text from the request message's parts and sets
+    # `env["a2a.message"]` to the joined text string.
+    #
+    # Replaces the common `extract_text` lambda pattern found in examples:
+    #
+    #   extract_text = ->(message) {
+    #     parts = message.parts || []
+    #     parts.filter_map { |p| p.text }.join("\n")
+    #   }
+    #
+    # Usage:
+    #
+    #   on "SendMessage" do
+    #     use A2A::Middleware::ExtractMessage
+    #     respond_with -> (env) {
+    #       text = env["a2a.message"]
+    #       # ...
+    #     }
+    #   end
+    #
+    class ExtractMessage
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = env["a2a.request"]
+        message = request.message
+        parts   = message.parts || []
+
+        env["a2a.message"] = parts.filter_map { |p|
+          p.respond_to?(:text) ? p.text : p["text"]
+        }.join("\n")
+
+        @app.call(env)
+      end
+    end
+  end
+end
+
+test do
+  describe "A2A::Middleware::ExtractMessage" do
+    it "extracts text from message parts" do
+      part1 = Object.new
+      part1.define_singleton_method(:text) { "hello" }
+      part2 = Object.new
+      part2.define_singleton_method(:text) { "world" }
+
+      message = Object.new
+      message.define_singleton_method(:parts) { [part1, part2] }
+
+      request = Object.new
+      request.define_singleton_method(:message) { message }
+
+      downstream = -> (env) { env["a2a.message"] }
+      mw = A2A::Middleware::ExtractMessage.new(downstream)
+      env = { "a2a.request" => request }
+
+      result = mw.call(env)
+      result.should == "hello\nworld"
+    end
+
+    it "handles nil parts" do
+      message = Object.new
+      message.define_singleton_method(:parts) { nil }
+
+      request = Object.new
+      request.define_singleton_method(:message) { message }
+
+      downstream = -> (env) { env["a2a.message"] }
+      mw = A2A::Middleware::ExtractMessage.new(downstream)
+      env = { "a2a.request" => request }
+
+      result = mw.call(env)
+      result.should == ""
+    end
+
+    it "skips parts without text" do
+      part1 = Object.new
+      part1.define_singleton_method(:text) { "hello" }
+      part2 = Object.new
+      part2.define_singleton_method(:text) { nil }
+
+      message = Object.new
+      message.define_singleton_method(:parts) { [part1, part2] }
+
+      request = Object.new
+      request.define_singleton_method(:message) { message }
+
+      downstream = -> (env) { env["a2a.message"] }
+      mw = A2A::Middleware::ExtractMessage.new(downstream)
+      env = { "a2a.request" => request }
+
+      result = mw.call(env)
+      result.should == "hello"
+    end
+
+    it "handles hash-style parts" do
+      message = Object.new
+      message.define_singleton_method(:parts) { [{ "text" => "from hash" }] }
+
+      request = Object.new
+      request.define_singleton_method(:message) { message }
+
+      downstream = -> (env) { env["a2a.message"] }
+      mw = A2A::Middleware::ExtractMessage.new(downstream)
+      env = { "a2a.request" => request }
+
+      result = mw.call(env)
+      result.should == "from hash"
+    end
+  end
+end