agent2agent 1.1.1 → 2.0.0

data/lib/a2a/{faraday → client}/middleware/rest/response.rb

@@ -6,7 +6,7 @@ require "faraday"
 require "json"
 
 module A2A
-  module Faraday
+  class Client
     module Middleware
       module REST
         # Faraday response middleware for the A2A HTTP+JSON/REST binding.
@@ -32,6 +32,9 @@ module A2A
                 message = parsed.to_s
                 data    = nil
               end
+              # Streaming requests consume the body via on_data, leaving
+              # nothing here — fall back to the HTTP status.
+              message = "HTTP #{env.status}" if message.to_s.empty?
               raise A2A::RestError.new(message, http_status: env.status, data: data)
             end
 
@@ -59,11 +62,12 @@ module A2A
   end
 end
 
-::Faraday::Response.register_middleware(a2a_rest: A2A::Faraday::Middleware::REST::Response)
+::Faraday::Response.register_middleware(a2a_rest: A2A::Client::Middleware::REST::Response)
 
-test do
-  middleware = A2A::Faraday::Middleware::REST::Response
-  operation = A2A::Proto.operation("GetTask")
+__END__
+describe "A2A::Client::Middleware::REST::Response" do
+  middleware = A2A::Client::Middleware::REST::Response
+  operation = A2A::Protocol::Protobuf.operation("GetTask")
 
   it "wraps response body in Schema object directly (no envelope)" do
     env = ::Faraday::Env.new
@@ -77,13 +81,13 @@ test do
 
     middleware.new(nil).on_complete(env)
 
-    env.body.should.be.kind_of(A2A::Schema::Definition)
+    env.body.should.be.kind_of(A2A::Protocol::JsonSchema::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")
+    op = A2A::Protocol::Protobuf.operation("DeleteTaskPushNotificationConfig")
     env = ::Faraday::Env.new
     env.status = 200
     env.body = {}
@@ -138,7 +142,7 @@ test do
 
     middleware.new(nil).on_complete(env)
 
-    env.body.should.be.kind_of(A2A::Schema::Definition)
+    env.body.should.be.kind_of(A2A::Protocol::JsonSchema::Definition)
     env.body.id.should == "task-1"
   end
 end

data/lib/a2a/{faraday → client}/middleware/schema_request.rb

@@ -6,9 +6,9 @@ require "faraday"
 require "json"
 
 module A2A
-  module Faraday
+  class Client
     module Middleware
-      # Faraday request middleware that converts A2A::Schema::Definition
+      # Faraday request middleware that converts A2A::Protocol::JsonSchema::Definition
       # objects into their hash representation for JSON serialization.
       #
       # Place this before the :json request middleware in the stack so
@@ -18,7 +18,7 @@ module A2A
       class SchemaRequest < ::Faraday::Middleware
         def on_request(env)
           body = env.body
-          return unless body.is_a?(A2A::Schema::Definition)
+          return unless body.is_a?(A2A::Protocol::JsonSchema::Definition)
 
           env.body = body.to_h
           env.request_headers["content-type"] ||= "application/json"
@@ -28,13 +28,14 @@ module A2A
   end
 end
 
-::Faraday::Request.register_middleware(a2a_schema: A2A::Faraday::Middleware::SchemaRequest)
+::Faraday::Request.register_middleware(a2a_schema: A2A::Client::Middleware::SchemaRequest)
 
-test do
-  middleware = A2A::Faraday::Middleware::SchemaRequest
+__END__
+describe "A2A::Client::Middleware::SchemaRequest" do
+  middleware = A2A::Client::Middleware::SchemaRequest
 
   it "converts Schema::Definition to hash" do
-    schema_obj = A2A::Schema["Agent Capabilities"].new(streaming: true)
+    schema_obj = A2A::Protocol::JsonSchema["Agent Capabilities"].new(streaming: true)
     env = ::Faraday::Env.new
     env.body = schema_obj
     env.request_headers = {}
@@ -57,7 +58,7 @@ test do
   end
 
   it "does not overwrite existing content-type" do
-    schema_obj = A2A::Schema["Agent Capabilities"].new(streaming: true)
+    schema_obj = A2A::Protocol::JsonSchema["Agent Capabilities"].new(streaming: true)
     env = ::Faraday::Env.new
     env.body = schema_obj
     env.request_headers = { "content-type" => "application/a2a+json" }

data/lib/a2a/client.rb

@@ -31,15 +31,15 @@ module A2A
 
     # GET /.well-known/agent-card.json
     #
-    # Returns an A2A::Schema["Agent Card"] instance.
+    # Returns an A2A::Protocol::JsonSchema["Agent Card"] instance.
     def agent_card
-      response = @conn.get("/.well-known/agent-card.json")
+      response = @conn.get(".well-known/agent-card.json")
       parsed = response.body
-      A2A::Schema["Agent Card"].new(parsed)
+      A2A::Protocol::JsonSchema["Agent Card"].new(parsed)
     end
 
     # Operations — each maps to a Proto operation name.
-    Proto.operations.each do |op|
+    Protocol::Protobuf.operations.each do |op|
       method_name = op.name.gsub(/([A-Z])/) { "_#{$1.downcase}" }.sub(/^_/, "")
 
       if op.server_streaming?
@@ -98,7 +98,7 @@ module A2A
         request = operation.request_schema.new(params)
         request.valid!
 
-        response = @conn.post("/") do |req|
+        response = @conn.post do |req|
           req.options.context = { a2a_operation: operation }
           req.body = request
         end
@@ -110,9 +110,9 @@ module A2A
         request = operation.request_schema.new(params)
         request.valid!
 
-        parser = A2A::SSE::EventParser.new(binding: @binding)
+        parser = A2A::Server::SSE::EventParser.new(binding: @binding)
 
-        @conn.post("/") do |req|
+        @conn.post do |req|
           req.options.context = { a2a_operation: operation }
           req.body = request
           req.headers["Accept"] = "text/event-stream"
@@ -127,13 +127,14 @@ module A2A
   end
 end
 
-test do
+__END__
+describe "A2A::Client" do
   # --- JSON-RPC binding (default) ---
 
   it "generates methods for all Proto operations" do
     client = A2A::Client.new("http://localhost:9292") do |f|
       f.adapter :test do |stub|
-        stub.post("/a2a") { |env|
+        stub.post("/") { |env|
           [200, { "content-type" => "application/json" }, JSON.generate({ "jsonrpc" => "2.0", "id" => 1, "result" => {} })]
         }
       end
@@ -172,7 +173,7 @@ test do
     end
 
     card = client.agent_card
-    card.should.be.kind_of(A2A::Schema::Definition)
+    card.should.be.kind_of(A2A::Protocol::JsonSchema::Definition)
     card.name.should == "Test Agent"
     card.version.should == "1.0.0"
   end
@@ -180,7 +181,7 @@ test do
   it "json_rpc: send_message validates, wraps in JSON-RPC, returns Schema" do
     client = A2A::Client.new("http://localhost:9292") do |f|
       f.adapter :test do |stub|
-        stub.post("/a2a") { |env|
+        stub.post("/") { |env|
           parsed = JSON.parse(env.body)
           parsed["method"].should == "SendMessage"
           parsed["params"]["message"]["role"].should == "ROLE_USER"
@@ -210,13 +211,13 @@ test do
         parts: [{ text: "Hello" }]
       }
     )
-    result.should.be.kind_of(A2A::Schema::Definition)
+    result.should.be.kind_of(A2A::Protocol::JsonSchema::Definition)
   end
 
   it "json_rpc: get_task returns a Task" do
     client = A2A::Client.new("http://localhost:9292") do |f|
       f.adapter :test do |stub|
-        stub.post("/a2a") { |env|
+        stub.post("/") { |env|
           parsed = JSON.parse(env.body)
           parsed["method"].should == "GetTask"
           parsed["params"]["id"].should == "task-123"
@@ -236,7 +237,7 @@ test do
     end
 
     result = client.get_task(id: "task-123")
-    result.should.be.kind_of(A2A::Schema::Definition)
+    result.should.be.kind_of(A2A::Protocol::JsonSchema::Definition)
     result.id.should == "task-123"
     result.context_id.should == "ctx-456"
   end
@@ -244,7 +245,7 @@ test do
   it "json_rpc: raises on JSON-RPC error" do
     client = A2A::Client.new("http://localhost:9292") do |f|
       f.adapter :test do |stub|
-        stub.post("/a2a") { |env|
+        stub.post("/") { |env|
           [200, { "content-type" => "application/json" }, JSON.generate({
             "jsonrpc" => "2.0",
             "id" => 1,
@@ -263,18 +264,18 @@ test do
   it "json_rpc: raises ValidationError on invalid params" do
     client = A2A::Client.new("http://localhost:9292") do |f|
       f.adapter :test do |stub|
-        stub.post("/a2a") { |env| [200, { "content-type" => "application/json" }, "{}"] }
+        stub.post("/") { |env| [200, { "content-type" => "application/json" }, "{}"] }
       end
     end
 
-    lambda { client.send_message(message: "not_a_hash") }.should.raise(A2A::Schema::ValidationError)
+    lambda { client.send_message(message: "not_a_hash") }.should.raise(A2A::Protocol::JsonSchema::ValidationError)
   end
 
   it "json_rpc: send_streaming_message sends correct method and Accept header" do
     captured_env = nil
     client = A2A::Client.new("http://localhost:9292") do |f|
       f.adapter :test do |stub|
-        stub.post("/a2a") { |env|
+        stub.post("/") { |env|
           captured_env = env
           [200, { "content-type" => "text/event-stream" }, ""]
         }
@@ -301,7 +302,7 @@ test do
     captured_env = nil
     client = A2A::Client.new("http://localhost:9292", binding: :rest) do |f|
       f.adapter :test do |stub|
-        stub.post("/message:send") { |env|
+        stub.post("/rest/message:send") { |env|
           captured_env = env
           [200, { "content-type" => "application/a2a+json" }, JSON.generate({
             "task" => {
@@ -323,14 +324,14 @@ test do
         parts: [{ text: "Hello" }]
       }
     )
-    result.should.be.kind_of(A2A::Schema::Definition)
+    result.should.be.kind_of(A2A::Protocol::JsonSchema::Definition)
     captured_env.request_headers["content-type"].should == "application/a2a+json"
   end
 
   it "rest: get_task uses GET /tasks/{id}" do
     client = A2A::Client.new("http://localhost:9292", binding: :rest) do |f|
       f.adapter :test do |stub|
-        stub.get("/tasks/task-123") { |env|
+        stub.get("/rest/tasks/task-123") { |env|
           [200, { "content-type" => "application/a2a+json" }, JSON.generate({
             "id" => "task-123",
             "contextId" => "ctx-456",
@@ -343,14 +344,14 @@ test do
     end
 
     result = client.get_task(id: "task-123")
-    result.should.be.kind_of(A2A::Schema::Definition)
+    result.should.be.kind_of(A2A::Protocol::JsonSchema::Definition)
     result.id.should == "task-123"
   end
 
   it "rest: list_tasks uses GET /tasks" do
     client = A2A::Client.new("http://localhost:9292", binding: :rest) do |f|
       f.adapter :test do |stub|
-        stub.get("/tasks") { |env|
+        stub.get("/rest/tasks") { |env|
           [200, { "content-type" => "application/a2a+json" }, JSON.generate({
             "tasks" => [
               { "id" => "t-1", "contextId" => "c-1", "status" => { "state" => "TASK_STATE_COMPLETED" } }
@@ -361,13 +362,13 @@ test do
     end
 
     result = client.list_tasks
-    result.should.be.kind_of(A2A::Schema::Definition)
+    result.should.be.kind_of(A2A::Protocol::JsonSchema::Definition)
   end
 
   it "rest: cancel_task uses POST /tasks/{id}:cancel" do
     client = A2A::Client.new("http://localhost:9292", binding: :rest) do |f|
       f.adapter :test do |stub|
-        stub.post("/tasks/task-123:cancel") { |env|
+        stub.post("/rest/tasks/task-123:cancel") { |env|
           [200, { "content-type" => "application/a2a+json" }, JSON.generate({
             "id" => "task-123", "contextId" => "ctx-456",
             "status" => { "state" => "TASK_STATE_CANCELED" }
@@ -377,14 +378,14 @@ test do
     end
 
     result = client.cancel_task(id: "task-123")
-    result.should.be.kind_of(A2A::Schema::Definition)
+    result.should.be.kind_of(A2A::Protocol::JsonSchema::Definition)
     result.id.should == "task-123"
   end
 
   it "rest: create_task_push_notification_config uses POST /tasks/{task_id}/pushNotificationConfigs" do
     client = A2A::Client.new("http://localhost:9292", binding: :rest) do |f|
       f.adapter :test do |stub|
-        stub.post("/tasks/task-123/pushNotificationConfigs") { |env|
+        stub.post("/rest/tasks/task-123/pushNotificationConfigs") { |env|
           [200, { "content-type" => "application/a2a+json" }, JSON.generate({
             "id" => "config-1", "taskId" => "task-123",
             "url" => "https://example.com/webhook"
@@ -396,13 +397,13 @@ test do
     result = client.create_task_push_notification_config(
       task_id: "task-123", url: "https://example.com/webhook"
     )
-    result.should.be.kind_of(A2A::Schema::Definition)
+    result.should.be.kind_of(A2A::Protocol::JsonSchema::Definition)
   end
 
   it "rest: get_task_push_notification_config uses GET /tasks/{task_id}/pushNotificationConfigs/{id}" do
     client = A2A::Client.new("http://localhost:9292", binding: :rest) do |f|
       f.adapter :test do |stub|
-        stub.get("/tasks/task-123/pushNotificationConfigs/config-1") { |env|
+        stub.get("/rest/tasks/task-123/pushNotificationConfigs/config-1") { |env|
           [200, { "content-type" => "application/a2a+json" }, JSON.generate({
             "id" => "config-1", "taskId" => "task-123",
             "url" => "https://example.com/webhook"
@@ -412,13 +413,13 @@ test do
     end
 
     result = client.get_task_push_notification_config(id: "config-1", task_id: "task-123")
-    result.should.be.kind_of(A2A::Schema::Definition)
+    result.should.be.kind_of(A2A::Protocol::JsonSchema::Definition)
   end
 
   it "rest: list_task_push_notification_configs uses GET /tasks/{task_id}/pushNotificationConfigs" do
     client = A2A::Client.new("http://localhost:9292", binding: :rest) do |f|
       f.adapter :test do |stub|
-        stub.get("/tasks/task-123/pushNotificationConfigs") { |env|
+        stub.get("/rest/tasks/task-123/pushNotificationConfigs") { |env|
           [200, { "content-type" => "application/a2a+json" }, JSON.generate({
             "pushNotificationConfigs" => []
           })]
@@ -427,13 +428,13 @@ test do
     end
 
     result = client.list_task_push_notification_configs(task_id: "task-123")
-    result.should.be.kind_of(A2A::Schema::Definition)
+    result.should.be.kind_of(A2A::Protocol::JsonSchema::Definition)
   end
 
   it "rest: delete_task_push_notification_config uses DELETE /tasks/{task_id}/pushNotificationConfigs/{id}" do
     client = A2A::Client.new("http://localhost:9292", binding: :rest) do |f|
       f.adapter :test do |stub|
-        stub.delete("/tasks/task-123/pushNotificationConfigs/config-1") { |env|
+        stub.delete("/rest/tasks/task-123/pushNotificationConfigs/config-1") { |env|
           [200, { "content-type" => "application/a2a+json" }, JSON.generate({})]
         }
       end
@@ -446,7 +447,7 @@ test do
   it "rest: get_extended_agent_card uses GET /extendedAgentCard" do
     client = A2A::Client.new("http://localhost:9292", binding: :rest) do |f|
       f.adapter :test do |stub|
-        stub.get("/extendedAgentCard") { |env|
+        stub.get("/rest/extendedAgentCard") { |env|
           [200, { "content-type" => "application/a2a+json" }, JSON.generate({
             "name" => "Extended Agent",
             "version" => "2.0.0",
@@ -460,7 +461,7 @@ test do
     end
 
     result = client.get_extended_agent_card
-    result.should.be.kind_of(A2A::Schema::Definition)
+    result.should.be.kind_of(A2A::Protocol::JsonSchema::Definition)
     result.name.should == "Extended Agent"
   end
 
@@ -468,7 +469,7 @@ test do
     captured_env = nil
     client = A2A::Client.new("http://localhost:9292", binding: :rest) do |f|
       f.adapter :test do |stub|
-        stub.get("/tasks/task-1:subscribe") { |env|
+        stub.get("/rest/tasks/task-1:subscribe") { |env|
           captured_env = env
           [200, { "content-type" => "text/event-stream" }, ""]
         }
@@ -484,7 +485,7 @@ test do
   it "rest: raises on HTTP 400 error" do
     client = A2A::Client.new("http://localhost:9292", binding: :rest) do |f|
       f.adapter :test do |stub|
-        stub.get("/tasks/bad-id") { |env|
+        stub.get("/rest/tasks/bad-id") { |env|
           [400, { "content-type" => "application/problem+json" }, JSON.generate({
             "type" => "error",
             "title" => "Bad Request","status" => 400
@@ -499,10 +500,10 @@ test do
   it "rest: raises ValidationError on invalid params" do
     client = A2A::Client.new("http://localhost:9292", binding: :rest) do |f|
       f.adapter :test do |stub|
-        stub.post("/message:send") { |env| [200, { "content-type" => "application/a2a+json" }, "{}"] }
+        stub.post("/rest/message:send") { |env| [200, { "content-type" => "application/a2a+json" }, "{}"] }
       end
     end
 
-    lambda { client.send_message(message: "not_a_hash") }.should.raise(A2A::Schema::ValidationError)
+    lambda { client.send_message(message: "not_a_hash") }.should.raise(A2A::Protocol::JsonSchema::ValidationError)
   end
 end

data/lib/a2a/errors/json_rpc_error.rb

@@ -23,7 +23,7 @@ module A2A
   end
 end
 
-test do
+__END__
   describe "A2A::JsonRpcError" do
     it "has correct code and message" do
       err = A2A::JsonRpcError.new("Task not found", code: -32001)
@@ -68,4 +68,3 @@ test do
       h[:data].should == data
     end
   end
-end

data/lib/a2a/errors/rest_error.rb

@@ -20,7 +20,7 @@ module A2A
   end
 end
 
-test do
+__END__
   describe "A2A::RestError" do
     it "has correct http_status and message" do
       err = A2A::RestError.new("Not Found", http_status: 404)
@@ -65,4 +65,3 @@ test do
       h[:data].should == data
     end
   end
-end

data/lib/a2a/errors.rb

@@ -337,7 +337,7 @@ require "a2a/errors/rest_error"
 # | ExtendedAgentCardNotConfiguredError   | The agent lacks a configured extended agent card when required.
 # | ExtensionSupportRequiredError         | A required extension was not declared as supported by the client.
 # | VersionNotSupportedError              | The requested A2A-Version is not supported by the agent.
-test do
+__END__
   describe "A2A::Error" do
     it "has code, http_status, and message" do
       err = A2A::Error.new("boom", code: -32000, http_status: 500)
@@ -532,4 +532,3 @@ test do
       err.is_a?(A2A::Error).should == true
     end
   end
-end