a2a-ruby 1.0.0

data/lib/a2a/rails/generators/templates/push_notification_config_model.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+##
+# <%= model_class_name("push_notification_config") %>
+#
+# ActiveRecord model for A2A push notification configurations.
+# This model stores webhook URLs and authentication details for task notifications.
+#
+class <%= model_class_name("push_notification_config") %> < ApplicationRecord
+  self.table_name = "<%= push_notification_configs_table_name %>"
+  self.primary_key = "id"
+
+  # Associations
+  belongs_to :<%= model_file_name("task") %>, 
+             foreign_key: :task_id, 
+             class_name: "<%= model_class_name("task") %>"
+
+  # Validations
+  validates :id, presence: true, uniqueness: true
+  validates :task_id, presence: true
+  validates :url, presence: true, format: { with: URI::DEFAULT_PARSER.make_regexp(%w[http https]) }
+  validates :retry_count, presence: true, numericality: { greater_than_or_equal_to: 0 }
+
+  # Scopes
+  scope :active, -> { where(active: true, deleted_at: nil) }
+  scope :inactive, -> { where(active: false) }
+  scope :by_task, ->(task_id) { where(task_id: task_id) }
+  scope :failed_recently, -> { where("last_failure_at > ?", 1.hour.ago) }
+  scope :needs_retry, -> { where("retry_count < ? AND (last_failure_at IS NULL OR last_failure_at < ?)", max_retries, retry_delay.ago) }
+
+  # Callbacks
+  before_create :ensure_id
+  after_create :log_creation
+  after_update :log_status_change, if: :saved_change_to_active?
+
+  # Configuration
+  MAX_RETRIES = 5
+  RETRY_DELAY = 5.minutes
+
+  def self.max_retries
+    MAX_RETRIES
+  end
+
+  def self.retry_delay
+    RETRY_DELAY
+  end
+
+  # Soft delete
+  def soft_delete!
+    update!(deleted_at: Time.now, active: false)
+  end
+
+  def deleted?
+    deleted_at.present?
+  end
+
+  # Status management
+  def mark_success!
+    update!(
+      last_success_at: Time.now,
+      last_failure_at: nil,
+      last_error: nil,
+      retry_count: 0
+    )
+  end
+
+  def mark_failure!(error_message)
+    update!(
+      last_failure_at: Time.now,
+      last_error: error_message,
+      retry_count: retry_count + 1,
+      active: retry_count < self.class.max_retries
+    )
+  end
+
+  def can_retry?
+    active && retry_count < self.class.max_retries && 
+    (last_failure_at.nil? || last_failure_at < self.class.retry_delay.ago)
+  end
+
+  def should_disable?
+    retry_count >= self.class.max_retries
+  end
+
+  # Convert to A2A types
+  def to_a2a_push_notification_config
+    A2A::Types::PushNotificationConfig.new(
+      id: id,
+      url: url,
+      token: token,
+      authentication: authentication || {}
+    )
+  end
+
+  def to_a2a_task_push_notification_config
+    A2A::Types::TaskPushNotificationConfig.new(
+      task_id: task_id,
+      push_notification_config: to_a2a_push_notification_config
+    )
+  end
+
+  # Create from A2A types
+  def self.from_a2a_config(task_id, config)
+    if config.is_a?(A2A::Types::TaskPushNotificationConfig)
+      pn_config = config.push_notification_config
+      task_id = config.task_id
+    elsif config.is_a?(A2A::Types::PushNotificationConfig)
+      pn_config = config
+    else
+      raise ArgumentError, "Invalid config type"
+    end
+
+    new(
+      id: pn_config.id || SecureRandom.uuid,
+      task_id: task_id,
+      url: pn_config.url,
+      token: pn_config.token,
+      authentication: pn_config.authentication || {}
+    )
+  end
+
+  # Webhook delivery
+  def deliver_notification(event_data)
+    return false unless active? && !deleted?
+
+    begin
+      response = send_webhook_request(event_data)
+      
+      if response.success?
+        mark_success!
+        true
+      else
+        mark_failure!("HTTP #{response.code}: #{response.body}")
+        false
+      end
+    rescue => e
+      mark_failure!(e.message)
+      false
+    end
+  end
+
+  # Authentication helpers
+  def has_authentication?
+    authentication.present? && authentication.any?
+  end
+
+  def authentication_type
+    return nil unless has_authentication?
+    
+    if authentication["type"].present?
+      authentication["type"]
+    elsif token.present?
+      "bearer"
+    else
+      "custom"
+    end
+  end
+
+  # Statistics
+  def success_rate
+    total_attempts = retry_count + (last_success_at.present? ? 1 : 0)
+    return 0.0 if total_attempts == 0
+    
+    successful_attempts = last_success_at.present? ? 1 : 0
+    (successful_attempts.to_f / total_attempts * 100).round(2)
+  end
+
+  def last_activity
+    [last_success_at, last_failure_at].compact.max
+  end
+
+  private
+
+  def ensure_id
+    self.id ||= SecureRandom.uuid
+  end
+
+  def log_creation
+    Rails.logger.info "Created push notification config #{id} for task #{task_id}"
+  end
+
+  def log_status_change
+    status = active? ? "activated" : "deactivated"
+    Rails.logger.info "Push notification config #{id} #{status}"
+  end
+
+  def send_webhook_request(event_data)
+    require 'faraday'
+    
+    conn = Faraday.new do |f|
+      f.request :json
+      f.response :json
+      f.adapter Faraday.default_adapter
+    end
+
+    headers = build_request_headers
+    
+    conn.post(url) do |req|
+      req.headers.merge!(headers)
+      req.body = event_data
+    end
+  end
+
+  def build_request_headers
+    headers = {
+      'Content-Type' => 'application/json',
+      'User-Agent' => "A2A-Ruby/#{A2A::VERSION}",
+      'X-A2A-Task-ID' => task_id,
+      'X-A2A-Config-ID' => id
+    }
+
+    # Add authentication headers
+    case authentication_type
+    when "bearer"
+      headers['Authorization'] = "Bearer #{token}"
+    when "api_key"
+      headers['X-API-Key'] = token
+    when "custom"
+      # Add custom authentication headers from authentication hash
+      authentication.each do |key, value|
+        next if %w[type].include?(key)
+        headers[key] = value
+      end
+    end
+
+    headers
+  end
+end

data/lib/a2a/rails/generators/templates/task_model.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+##
+# <%= model_class_name("task") %>
+#
+# ActiveRecord model for A2A tasks with JSON serialization and validation.
+# This model provides persistence for A2A task data including status, artifacts,
+# and message history.
+#
+class <%= model_class_name("task") %> < ApplicationRecord
+  self.table_name = "<%= tasks_table_name %>"
+  self.primary_key = "id"
+
+  # Associations
+  has_many :<%= model_file_name("push_notification_config").pluralize %>, 
+           foreign_key: :task_id, 
+           dependent: :destroy,
+           class_name: "<%= model_class_name("push_notification_config") %>"
+
+  # Validations
+  validates :id, presence: true, uniqueness: true
+  validates :context_id, presence: true
+  validates :kind, presence: true, inclusion: { in: %w[task] }
+  validates :status_state, presence: true, inclusion: { 
+    in: %w[submitted working input-required completed canceled failed rejected auth-required unknown] 
+  }
+
+  # Scopes
+  scope :active, -> { where(deleted_at: nil) }
+  scope :by_status, ->(status) { where(status_state: status) }
+  scope :by_context, ->(context_id) { where(context_id: context_id) }
+  scope :by_type, ->(type) { where(type: type) }
+  scope :recent, -> { order(created_at: :desc) }
+  scope :processing, -> { where(status_state: %w[submitted working]) }
+  scope :completed, -> { where(status_state: %w[completed canceled failed rejected]) }
+
+  # Callbacks
+  before_create :ensure_id
+  before_save :update_status_timestamp
+  after_update :notify_status_change, if: :saved_change_to_status_state?
+
+  # Soft delete
+  def soft_delete!
+    update!(deleted_at: Time.now)
+  end
+
+  def deleted?
+    deleted_at.present?
+  end
+
+  # Status management
+  def status
+    A2A::Types::TaskStatus.new(
+      state: status_state,
+      message: status_message,
+      progress: status_progress,
+      result: status_result,
+      error: status_error,
+      updated_at: status_updated_at&.iso8601
+    )
+  end
+
+  def status=(new_status)
+    if new_status.is_a?(A2A::Types::TaskStatus)
+      self.status_state = new_status.state
+      self.status_message = new_status.message
+      self.status_progress = new_status.progress
+      self.status_result = new_status.result
+      self.status_error = new_status.error
+      self.status_updated_at = Time.now
+    elsif new_status.is_a?(Hash)
+      self.status = A2A::Types::TaskStatus.from_h(new_status)
+    else
+      raise ArgumentError, "Status must be TaskStatus or Hash"
+    end
+  end
+
+  # Artifact management
+  def artifacts_objects
+    return [] unless artifacts.present?
+    
+    artifacts.map { |artifact_data| A2A::Types::Artifact.from_h(artifact_data) }
+  end
+
+  def add_artifact(artifact)
+    artifact_data = artifact.is_a?(A2A::Types::Artifact) ? artifact.to_h : artifact
+    
+    self.artifacts = (artifacts || []) + [artifact_data]
+    save!
+  end
+
+  def update_artifact(artifact_id, new_artifact, append: false)
+    return unless artifacts.present?
+    
+    artifact_index = artifacts.find_index { |a| a["artifact_id"] == artifact_id }
+    return unless artifact_index
+    
+    new_artifact_data = new_artifact.is_a?(A2A::Types::Artifact) ? new_artifact.to_h : new_artifact
+    
+    if append && artifacts[artifact_index]["parts"].present?
+      # Append parts to existing artifact
+      existing_parts = artifacts[artifact_index]["parts"] || []
+      new_parts = new_artifact_data["parts"] || []
+      artifacts[artifact_index]["parts"] = existing_parts + new_parts
+    else
+      # Replace entire artifact
+      artifacts[artifact_index] = new_artifact_data
+    end
+    
+    save!
+  end
+
+  # Message history management
+  def history_objects
+    return [] unless history.present?
+    
+    history.map { |message_data| A2A::Types::Message.from_h(message_data) }
+  end
+
+  def add_message(message)
+    message_data = message.is_a?(A2A::Types::Message) ? message.to_h : message
+    
+    self.history = (history || []) + [message_data]
+    
+    # Limit history length if configured
+    max_history = A2A.config.max_history_length || 100
+    if history.length > max_history
+      self.history = history.last(max_history)
+    end
+    
+    save!
+  end
+
+  # Convert to A2A::Types::Task
+  def to_a2a_task
+    A2A::Types::Task.new(
+      id: id,
+      context_id: context_id,
+      kind: kind,
+      status: status,
+      artifacts: artifacts_objects,
+      history: history_objects,
+      metadata: metadata || {}
+    )
+  end
+
+  # Create from A2A::Types::Task
+  def self.from_a2a_task(task)
+    new(
+      id: task.id,
+      context_id: task.context_id,
+      kind: task.kind,
+      status_state: task.status.state,
+      status_message: task.status.message,
+      status_progress: task.status.progress,
+      status_result: task.status.result,
+      status_error: task.status.error,
+      status_updated_at: task.status.updated_at ? Time.parse(task.status.updated_at) : Time.now,
+      artifacts: task.artifacts&.map(&:to_h),
+      history: task.history&.map(&:to_h),
+      metadata: task.metadata
+    )
+  end
+
+  # Search and filtering
+  def self.search(query)
+    return all if query.nil? || (respond_to?(:empty?) && empty?) || (is_a?(String) && strip.empty?)
+    
+    where(
+      "status_message ILIKE ? OR metadata::text ILIKE ?", 
+      "%#{query}%", "%#{query}%"
+    )
+  end
+
+  def self.by_metadata(key, value)
+    <% if postgresql? %>
+    where("metadata->? = ?", key, value.to_json)
+    <% else %>
+    where("JSON_EXTRACT(metadata, ?) = ?", "$.#{key}", value.to_s)
+    <% end %>
+  end
+
+  private
+
+  def ensure_id
+    self.id ||= SecureRandom.uuid
+    self.context_id ||= SecureRandom.uuid
+  end
+
+  def update_status_timestamp
+    if status_state_changed?
+      self.status_updated_at = Time.now
+    end
+  end
+
+  def notify_status_change
+    # Trigger push notifications and events
+    A2A::Server::TaskManager.instance.notify_task_status_change(self) if A2A.config.push_notifications_enabled
+  end
+end

data/lib/a2a/rails/tasks/a2a.rake

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+namespace :a2a do
+  desc "Show A2A configuration"
+  task config: :environment do
+    puts "A2A Configuration:"
+    puts "=================="
+    puts "Rails Integration: #{A2A.config.rails_integration}"
+    puts "Mount Path: #{A2A.config.mount_path}"
+    puts "Authentication Required: #{A2A.config.authentication_required}"
+    puts "CORS Enabled: #{A2A.config.cors_enabled}"
+    puts "Rate Limiting Enabled: #{A2A.config.rate_limiting_enabled}"
+    puts "Logging Enabled: #{A2A.config.logging_enabled}"
+    puts "Version: #{A2A::VERSION}"
+  end
+
+  desc "List all registered A2A agents and capabilities"
+  task agents: :environment do
+    puts "Registered A2A Agents:"
+    puts "====================="
+
+    agent_count = 0
+    capability_count = 0
+
+    ObjectSpace.each_object(Class) do |klass|
+      next unless klass < ActionController::Base && klass.included_modules.include?(A2A::Server::Agent)
+
+      agent_count += 1
+      puts "\n#{klass.name}:"
+
+      capabilities = klass._a2a_capabilities || []
+      capability_count += capabilities.length
+
+      if capabilities.any?
+        capabilities.each do |capability|
+          puts "  - #{capability.name}: #{capability.description}"
+        end
+      else
+        puts "  (no capabilities defined)"
+      end
+
+      methods = klass._a2a_methods || {}
+      next unless methods.any?
+
+      puts "  Methods:"
+      methods.each_key do |method_name|
+        puts "    - #{method_name}"
+      end
+    end
+
+    puts "\nSummary:"
+    puts "--------"
+    puts "Total Agents: #{agent_count}"
+    puts "Total Capabilities: #{capability_count}"
+  end
+
+  desc "Generate agent card for all registered agents"
+  task agent_cards: :environment do
+    puts "Agent Cards:"
+    puts "============"
+
+    ObjectSpace.each_object(Class) do |klass|
+      next unless klass < ActionController::Base && klass.included_modules.include?(A2A::Server::Agent)
+
+      puts "\n#{klass.name}:"
+      puts "-" * (klass.name.length + 1)
+
+      begin
+        # Create a mock controller instance to generate the card
+        controller = klass.new
+        controller.request = ActionDispatch::Request.new({})
+
+        card = controller.send(:generate_agent_card)
+        puts JSON.pretty_generate(card.to_h)
+      rescue StandardError => e
+        puts "Error generating card: #{e.message}"
+      end
+    end
+  end
+
+  desc "Validate A2A protocol compliance"
+  task validate: :environment do
+    puts "A2A Protocol Validation:"
+    puts "======================="
+
+    errors = []
+    warnings = []
+
+    # Check Rails version compatibility
+    errors << "Rails version #{Rails.version} is not supported. Minimum version is 6.0" if Rails.version < "6.0"
+
+    # Check required dependencies
+    required_gems = %w[faraday json jwt redis concurrent-ruby]
+    required_gems.each do |gem_name|
+      require gem_name
+    rescue LoadError
+      errors << "Required gem '#{gem_name}' is not available"
+    end
+
+    # Validate configuration
+    config = A2A.config
+    errors << "Mount path must start with '/'" if config.mount_path && !config.mount_path.start_with?("/")
+
+    # Check for registered agents
+    agent_classes = []
+    ObjectSpace.each_object(Class) do |klass|
+      agent_classes << klass if klass < ActionController::Base && klass.included_modules.include?(A2A::Server::Agent)
+    end
+
+    warnings << "No A2A agents found. Consider creating some with 'rails generate a2a:agent'" if agent_classes.empty?
+
+    # Validate agent implementations
+    agent_classes.each do |klass|
+      capabilities = klass._a2a_capabilities || []
+      methods = klass._a2a_methods || {}
+
+      warnings << "#{klass.name} has no capabilities defined" if capabilities.empty?
+
+      warnings << "#{klass.name} has no A2A methods defined" if methods.empty?
+    end
+
+    # Report results
+    if errors.any?
+      puts "❌ Validation failed with #{errors.length} error(s):"
+      errors.each { |error| puts "  - #{error}" }
+    else
+      puts "✅ Validation passed!"
+    end
+
+    if warnings.any?
+      puts "\n⚠️  #{warnings.length} warning(s):"
+      warnings.each { |warning| puts "  - #{warning}" }
+    end
+
+    puts "\nSummary:"
+    puts "--------"
+    puts "Agents found: #{agent_classes.length}"
+    puts "Total capabilities: #{agent_classes.sum { |k| (k._a2a_capabilities || []).length }}"
+    puts "Total methods: #{agent_classes.sum { |k| (k._a2a_methods || {}).length }}"
+  end
+
+  desc "Start A2A development server"
+  task server: :environment do
+    puts "Starting A2A development server..."
+    puts "A2A endpoints will be available at: #{A2A.config.mount_path}"
+    puts "Press Ctrl+C to stop"
+
+    # This would typically start a development server
+    # For now, just show the configuration
+    Rake::Task["a2a:config"].invoke
+    puts "\nUse 'rails server' to start the full Rails application"
+  end
+
+  namespace :db do
+    desc "Create A2A database tables"
+    task migrate: :environment do
+      puts "Creating A2A database tables..."
+
+      # Check if migrations exist
+      migration_path = Rails.root.join("db", "migrate")
+      a2a_migrations = Dir.glob(migration_path.join("*_create_a2a_*.rb"))
+
+      if a2a_migrations.empty?
+        puts "No A2A migrations found. Run 'rails generate a2a:migration' first."
+      else
+        puts "Found #{a2a_migrations.length} A2A migration(s)"
+        Rake::Task["db:migrate"].invoke
+      end
+    end
+
+    desc "Seed A2A database with sample data"
+    task seed: :environment do
+      puts "Seeding A2A database..."
+
+      # Create sample tasks for development
+      if Rails.env.development?
+        task_manager = A2A::Server::TaskManager.instance
+
+        3.times do |i|
+          task = task_manager.create_task(
+            type: "sample_task_#{i + 1}",
+            params: { message: "Sample task #{i + 1}" }
+          )
+          puts "Created sample task: #{task.id}"
+        end
+      else
+        puts "Seeding is only available in development environment"
+      end
+    end
+  end
+
+  namespace :test do
+    desc "Run A2A protocol compliance tests"
+    task compliance: :environment do
+      puts "Running A2A protocol compliance tests..."
+
+      # This would run specific compliance tests
+      # For now, just validate the setup
+      Rake::Task["a2a:validate"].invoke
+    end
+
+    desc "Test A2A endpoints"
+    task endpoints: :environment do
+      puts "Testing A2A endpoints..."
+
+      require "net/http"
+      require "uri"
+
+      base_url = "http://localhost:3000#{A2A.config.mount_path}"
+
+      endpoints = [
+        { path: "/health", method: "GET" },
+        { path: "/agent-card", method: "GET" },
+        { path: "/capabilities", method: "GET" }
+      ]
+
+      endpoints.each do |endpoint|
+        uri = URI("#{base_url}#{endpoint[:path]}")
+        response = Net::HTTP.get_response(uri)
+
+        status = response.code.to_i < 400 ? "✅" : "❌"
+        puts "#{status} #{endpoint[:method]} #{endpoint[:path]} - #{response.code}"
+      rescue StandardError => e
+        puts "❌ #{endpoint[:method]} #{endpoint[:path]} - Error: #{e.message}"
+      end
+    end
+  end
+end