agent2agent 1.1.1 → 2.0.0

data/lib/traces/provider/a2a/agent.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../../../a2a/agent"
+require "traces/provider"
+
+Traces::Provider(A2A::Agent) do
+  def call(env)
+    attributes = {
+      "a2a.operation" => env["a2a.operation"],
+    }
+
+    Traces.trace("a2a.agent.call", attributes: attributes) do |span|
+      super.tap do |result|
+        if result.is_a?(A2A::Error)
+          span["a2a.response_type"] = "error"
+          span["a2a.error.code"]    = result.code
+        elsif env["a2a.stream"].is_a?(A2A::Server::SSE::Stream)
+          span["a2a.response_type"] = "stream"
+        else
+          span["a2a.response_type"] = "result"
+        end
+      end
+    end
+  end
+end

data/lib/traces/provider/a2a.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "a2a/agent"
 require_relative "a2a/server"
-require_relative "a2a/server/dispatcher"
 require_relative "a2a/server/triage"
 require_relative "a2a/server/bindings/json_rpc"
 require_relative "a2a/server/bindings/rest"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agent2agent
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 2.0.0
 platform: ruby
 authors:
 - A2A Contributors
@@ -51,20 +51,6 @@ dependencies:
     - - "~>"
       - !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
@@ -191,6 +177,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.55'
+- !ruby/object:Gem::Dependency
+  name: scampi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Abstraction to help work with A2A protocol
 executables: []
 extensions: []
@@ -204,42 +204,44 @@ files:
 - lib/a2a.rb
 - lib/a2a/agent.rb
 - lib/a2a/client.rb
+- lib/a2a/client/middleware/json_rpc/request.rb
+- lib/a2a/client/middleware/json_rpc/response.rb
+- lib/a2a/client/middleware/rest/request.rb
+- lib/a2a/client/middleware/rest/response.rb
+- lib/a2a/client/middleware/schema_request.rb
 - lib/a2a/errors.rb
 - lib/a2a/errors/json_rpc_error.rb
 - lib/a2a/errors/rest_error.rb
-- lib/a2a/faraday/middleware/json_rpc/request.rb
-- lib/a2a/faraday/middleware/json_rpc/response.rb
-- lib/a2a/faraday/middleware/rest/request.rb
-- lib/a2a/faraday/middleware/rest/response.rb
-- lib/a2a/faraday/middleware/schema_request.rb
-- lib/a2a/middleware.rb
-- lib/a2a/middleware/extract_message.rb
-- lib/a2a/middleware/fetch_task.rb
-- lib/a2a/middleware/limit_history_length.rb
-- lib/a2a/middleware/limit_pagination_size.rb
-- lib/a2a/middleware/sse_stream.rb
-- lib/a2a/proto.rb
-- lib/a2a/schema.rb
-- lib/a2a/schema/definition.rb
-- lib/a2a/schema/validation_error.rb
+- lib/a2a/protocol.rb
+- lib/a2a/protocol/json_schema.rb
+- lib/a2a/protocol/json_schema/definition.rb
+- lib/a2a/protocol/json_schema/validation_error.rb
+- lib/a2a/protocol/protobuf.rb
 - lib/a2a/server.rb
+- lib/a2a/server/bindings/grpc.rb
 - lib/a2a/server/bindings/json_rpc.rb
 - lib/a2a/server/bindings/rest.rb
-- lib/a2a/server/dispatcher.rb
 - lib/a2a/server/env.rb
+- lib/a2a/server/middleware.rb
+- lib/a2a/server/middleware/extract_message.rb
+- lib/a2a/server/middleware/fetch_task.rb
+- lib/a2a/server/middleware/limit_history_length.rb
+- lib/a2a/server/middleware/limit_pagination_size.rb
+- lib/a2a/server/middleware/sse_stream.rb
+- lib/a2a/server/sse.rb
+- lib/a2a/server/sse/event_parser.rb
+- lib/a2a/server/sse/json_rpc_stream.rb
+- lib/a2a/server/sse/rest_stream.rb
+- lib/a2a/server/sse/stream.rb
 - lib/a2a/server/triage.rb
-- lib/a2a/sse.rb
-- lib/a2a/sse/event_parser.rb
-- lib/a2a/sse/json_rpc_stream.rb
-- lib/a2a/sse/rest_stream.rb
-- lib/a2a/sse/stream.rb
+- lib/a2a/server/well_known.rb
 - lib/a2a/test_helpers.rb
 - lib/a2a/version.rb
 - lib/traces/provider/a2a.rb
+- lib/traces/provider/a2a/agent.rb
 - lib/traces/provider/a2a/server.rb
 - lib/traces/provider/a2a/server/bindings/json_rpc.rb
 - lib/traces/provider/a2a/server/bindings/rest.rb
-- lib/traces/provider/a2a/server/dispatcher.rb
 - lib/traces/provider/a2a/server/triage.rb
 licenses:
 - MIT

data/lib/a2a/middleware/extract_message.rb

@@ -1,120 +0,0 @@
-# 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

data/lib/a2a/middleware/sse_stream.rb

@@ -1,235 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "a2a"
-require "a2a/sse"
-require "async"
-
-module A2A
-  module Middleware
-    # Sets up an SSE stream builder on `env["a2a.stream"]`.
-    #
-    # The builder detects the protocol binding (REST vs JSON-RPC) from
-    # env and creates the correct stream subclass when `open` is called.
-    # The `open` block runs inside an Async fiber and the stream is
-    # automatically finished when the block exits (even on exception).
-    #
-    # If the handler never calls `open`, the builder is removed from env
-    # so the binding layer doesn't mistake it for a real stream.
-    #
-    # Usage:
-    #
-    #   on "SendStreamingMessage" do
-    #     use A2A::Middleware::SSEStream
-    #     use A2A::Middleware::ExtractMessage
-    #     respond_with -> (env) {
-    #       env["a2a.stream"].open(task_id: "t1", context_id: "c1") do |s|
-    #         s.task(status: { state: "TASK_STATE_WORKING" })
-    #         s.status_update(status: { state: "TASK_STATE_COMPLETED" })
-    #       end
-    #     }
-    #   end
-    #
-    class SSEStream
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        builder = StreamBuilder.new(env)
-        env["a2a.stream"] = builder
-
-        result = @app.call(env)
-
-        # If open was never called, clear the builder so the binding
-        # layer doesn't mistake it for a real stream.
-        env.delete("a2a.stream") if env["a2a.stream"].equal?(builder)
-
-        result
-      end
-    end
-
-    # Factory that creates the correct SSE stream subclass based on the
-    # protocol binding, then runs the caller's block inside Async with
-    # automatic finish on exit.
-    #
-    # Created by SSEStream middleware — not intended for direct use.
-    #
-    class StreamBuilder
-      def initialize(env)
-        @env = env
-      end
-
-      # Create and open an SSE stream for the current request.
-      #
-      # Detects REST vs JSON-RPC from the env, constructs the correct
-      # stream subclass, and yields it to the block. The block runs
-      # inside an Async fiber. The stream is automatically finished
-      # when the block exits, even if an exception is raised.
-      #
-      # @param task_id    [String] the task identifier for this stream
-      # @param context_id [String] the context identifier for this stream
-      # @yieldparam stream [A2A::SSE::Stream] the opened stream
-      # @return [nil]
-      #
-      def open(task_id:, context_id:, &block)
-        stream = if @env["a2a.json_rpc_id"]
-          A2A::SSE::JsonRpcStream.new(
-            task_id: task_id, context_id: context_id,
-            json_rpc_id: @env["a2a.json_rpc_id"]
-          )
-        else
-          A2A::SSE::RestStream.new(
-            task_id: task_id, context_id: context_id
-          )
-        end
-
-        @env["a2a.stream"] = stream
-
-        Async do
-          block.call(stream)
-        ensure
-          stream.finish
-        end
-
-        nil
-      end
-    end
-  end
-end
-
-test do
-  describe "A2A::Middleware::SSEStream" do
-    it "sets a StreamBuilder on env[\"a2a.stream\"]" do
-      seen_stream = nil
-      downstream = ->(env) { seen_stream = env["a2a.stream"]; :ok }
-
-      mw = A2A::Middleware::SSEStream.new(downstream)
-      env = {}
-      mw.call(env)
-
-      seen_stream.should.be.kind_of(A2A::Middleware::StreamBuilder)
-    end
-
-    it "auto-clears builder if open was never called" do
-      downstream = ->(env) { :ok }
-
-      mw = A2A::Middleware::SSEStream.new(downstream)
-      env = {}
-      mw.call(env)
-
-      env.key?("a2a.stream").should == false
-    end
-
-    it "preserves env[\"a2a.stream\"] when open was called" do
-      downstream = ->(env) {
-        env["a2a.stream"].open(task_id: "t1", context_id: "c1") do |s|
-          # no-op
-        end
-      }
-
-      mw = A2A::Middleware::SSEStream.new(downstream)
-      env = {}
-      mw.call(env)
-
-      env["a2a.stream"].should.be.kind_of(A2A::SSE::RestStream)
-    end
-
-    it "returns the downstream result" do
-      downstream = ->(env) { :result_value }
-
-      mw = A2A::Middleware::SSEStream.new(downstream)
-      result = mw.call({})
-
-      result.should == :result_value
-    end
-  end
-
-  describe "A2A::Middleware::StreamBuilder" do
-    it "creates a RestStream when no JSON-RPC ID" do
-      env = {}
-      builder = A2A::Middleware::StreamBuilder.new(env)
-
-      builder.open(task_id: "t1", context_id: "c1") do |s|
-        s.should.be.kind_of(A2A::SSE::RestStream)
-      end
-
-      env["a2a.stream"].should.be.kind_of(A2A::SSE::RestStream)
-    end
-
-    it "creates a JsonRpcStream when JSON-RPC ID is present" do
-      env = { "a2a.json_rpc_id" => 42 }
-      builder = A2A::Middleware::StreamBuilder.new(env)
-
-      builder.open(task_id: "t1", context_id: "c1") do |s|
-        s.should.be.kind_of(A2A::SSE::JsonRpcStream)
-      end
-
-      env["a2a.stream"].should.be.kind_of(A2A::SSE::JsonRpcStream)
-    end
-
-    it "passes task_id and context_id to the stream" do
-      env = {}
-      builder = A2A::Middleware::StreamBuilder.new(env)
-
-      builder.open(task_id: "t1", context_id: "c1") do |s|
-        s.task_id.should == "t1"
-        s.context_id.should == "c1"
-      end
-    end
-
-    it "auto-finishes the stream when block completes" do
-      env = {}
-      builder = A2A::Middleware::StreamBuilder.new(env)
-
-      builder.open(task_id: "t1", context_id: "c1") do |s|
-        s.task(status: { state: "TASK_STATE_WORKING" })
-      end
-
-      stream = env["a2a.stream"]
-      # After finish, read drains remaining data then returns nil
-      stream.read  # the task event
-      stream.read.should.be.nil
-    end
-
-    it "auto-finishes even when block raises" do
-      env = {}
-      builder = A2A::Middleware::StreamBuilder.new(env)
-
-      builder.open(task_id: "t1", context_id: "c1") do |s|
-        s.task(status: { state: "TASK_STATE_WORKING" })
-        raise "boom"
-      end
-
-      stream = env["a2a.stream"]
-      stream.read  # the task event
-      stream.read.should.be.nil
-    end
-
-    it "returns nil" do
-      env = {}
-      builder = A2A::Middleware::StreamBuilder.new(env)
-
-      result = builder.open(task_id: "t1", context_id: "c1") do |s|
-        # no-op
-      end
-
-      result.should.be.nil
-    end
-
-    it "typed methods inject task_id and context_id" do
-      env = {}
-      builder = A2A::Middleware::StreamBuilder.new(env)
-
-      builder.open(task_id: "t1", context_id: "c1") do |s|
-        s.status_update(status: { state: "TASK_STATE_COMPLETED", timestamp: "2025-01-01T00:00:00Z" })
-      end
-
-      stream = env["a2a.stream"]
-      chunk = stream.read
-      parsed = JSON.parse(chunk.sub(/\Adata: /, "").strip)
-      parsed["statusUpdate"]["taskId"].should == "t1"
-      parsed["statusUpdate"]["contextId"].should == "c1"
-    end
-  end
-end