agent99 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 827e521c4a6580cfe954cf07cf04f1a822c00b9ed6eebf75598d925aeb555626
-  data.tar.gz: 1b3e9b499610b9b3853757432fd4e3e39acab8fb70e29feb94eae1d22f6097aa
+  metadata.gz: eeb28a9ea8730c5ff33d5722f4dad0d0bcec6a54d58784203d1c147b64b17223
+  data.tar.gz: c27cb24f7ee720f758b94a32bd5d33e1ea5a92dc490022122cc40eaaa736620e
 SHA512:
-  metadata.gz: ce549f64fb88cd2f152e7af27b9724dbfedfda0f6255033ea1773dda7eaf89dd71a6b622667d023b3093ae1eca72ae3a55e7bd6b1f538e3035fe889ab52ac7c4
-  data.tar.gz: 959b0c9c342738bb9ee75f2dd82a4caaa825a13656f6d12dba2a11434857c08f11d746c1754f03ce1902f9e4ced1f3b7e1067ab1cdbe39c054250b23592ae94f
+  metadata.gz: dc796885c649aa669f77954eb25c5a9e8667d5aff6958054b53ca589fd3e620bb03ba3fce5a4b707bc6d2bd67ee2672291d1e4a0e0ff32b5d1d06912766492b0
+  data.tar.gz: f01c4e6d5a3353c722f87c965faaa6abede17ed57861a9b4fc82829e0c5a33d4bb483eb47420b9cef22bd697fb17d2e7e437bf9a2e5314fc07ab208bfb9d374d

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
-## [0.1.0] - 2024-11-28
+
+## Released
+
+### [0.0.2] - 2024-12-07
+
+- Added examples/control.rb
+    - request status from all agents
+    - other control messages not worked on yet
+
+### [0.0.1] - 2024-11-28
 
 - Initial release

data/README.md

@@ -4,6 +4,48 @@
 
 Agent99 is a Ruby-based framework for building and managing AI agents in a distributed system. It provides a robust foundation for creating intelligent agents that can communicate, discover each other, and perform various tasks.
 
+## Hype!
+
+🌟 **Introducing Agent99**: Your Friendly Ruby Sidekick for Building Intelligent Software Agents! 🌟
+
+Do you ever miss the charm and wit of Barbara Feldon's iconic character from *Get Smart*? Just as Agent 99 was always ready to tackle mischief and save the day, **Agent99** is here to help you create your very own software agents that can communicate, collaborate, and conquer tasks in a smart and efficient way!
+
+### Why Choose Agent99?
+
+🔍 **Independent Agents, Unified Communication**: Say goodbye to complex service orchestration! Agent99 empowers you to build micro-services that communicate seamlessly through a robust peer-to-peer messaging network. Each agent operates independently while working together like a well-oiled machine!
+
+🤖 **Smart Automation for the Modern Age**: In the era of AI, why settle for less? With Agent99, you can develop software agents that respond intelligently to incoming requests—just like a secret agent reacting to their next mission! Deploy your own digital spies to gather data, complete tasks, and more.
+
+📦 **Quick Setup & Easy Integration**: Just like Agent 99’s quick thinking, our library is designed for rapid development. Get up and running in no time, whether you’re building a small project or an enterprise-level solution!
+
+
+### Features that Make Agent99 a Must-Have:
+
+- 🌐 **Peer-to-Peer Messaging**: Ensure that your agents can communicate effortlessly, just like Agent 99 and Max.
+- 🚀 **Agile Development**: Design and deploy agents at lightning speed, giving you the freedom to innovate.
+- 🔒 **Secure Communication**: Built with security in mind, because even our agents deserve to keep their secrets safe.
+- 📊 **Scalability**: Expand your network of agents as your needs grow—no mission is too big!
+
+### Get Smart! Join the Revolution!
+
+Whether you’re a seasoned Ruby developer or just getting started, Agent99 provides the tools you need to build your very own quirky, intelligent agents. Just like Agent 99, your agents will be clever, adaptable, and ready to tackle any challenge!
+
+### How to Get Started:
+
+1. **Install**: Simply add Agent99 to your Gemfile and run `bundle install`.
+2. **Create an Agent**: Use our simple API to define and deploy your first agent.
+3. **Watch Them Work**: Sit back and relax as your agents spring into action, communicating with one another to accomplish tasks that would impress even the chief of CONTROL!
+
+### Spread the Word!
+
+**Join the Agent99 community** on GitHub and share your experiences, tips, and feedback. Let’s build a world of smart agents together! And remember, just like Agent 99 always had Max’s back, we’ve got yours during your development journey.
+
+🕵️‍♂️ **Become an Agent!** Dive into the world of Agent99 today: [GitHub Repository](#) 📖
+
+**Agent99** – Because when it comes to building software agents, it's all about being smart!
+
+... end of the Hype; now back to normal.
+
 ## Features
 
 - Agent Lifecycle Management: Easy setup and teardown of agents

data/examples/README.md

@@ -1,41 +1,36 @@
-# Agent99 Framework Examples
-
-- TODO
-    - Review and edit
-    - Add instructions for brew install rabbitmq nats-server boxes
-    - review example agents to see code can be tightened
+# Agent99 Framework Examples - 86 and the Chief
 
 This folder contains example implementations using the Agent99 framework. The framework provides a foundation for building AI agents that can communicate with each other through a message-based system.
 
 ## Files
 
-### 1. hello_world.rb
+### 1. maxwell_agent86.rb
 
-This file demonstrates a basic AI agent implementation using the Agent99 framework.
+This file demonstrates a basic agent implementation using the Agent99 framework.
 
-- Class: `HelloWorld < Agent99::Base`
+- Class: `MaxwellAgent86 < Agent99::Base`
 - Functionality: Responds to "hello world" requests
 - Key methods:
   - `receive_request`: Handles incoming requests
   - `validate_request`: Validates the request against a schema
   - `process`: Generates the response
 
-### 2. hello_world_client.rb
+### 2. chief_agent.rb
 
-This file shows how to create a client that interacts with the HelloWorld agent.
+This file shows how to create a client that interacts with the MaxwellAgent86 agent.
 
-- Class: `HelloWorldClient < Agent99::Base`
-- Functionality: Sends a request to a HelloWorld agent and processes the response
+- Class: `ChiefAgent < Agent99::Base`
+- Functionality: Sends a request to an agent who can be a greeter and processes the response
 - Key methods:
   - `init`: Initiates the request sending process
   - `send_request`: Builds and sends the request
   - `receive_response`: Handles the response from the HelloWorld agent
 
-### 3. hello_world_request.rb
+### 3. mexwell_request.rb
 
-This file defines the schema for HelloWorld requests using SimpleJsonSchemaBuilder.
+This file defines the schema for MaxwellAgent86 requests using SimpleJsonSchemaBuilder.
 
-- Class: `HelloWorldRequest < SimpleJsonSchemaBuilder::Base`
+- Class: `MaxwellRequest < SimpleJsonSchemaBuilder::Base`
 - Defines the structure of a valid HelloWorld request
 
 ### 4. registry.rb
@@ -52,28 +47,20 @@ This file implements a simple registry service for AI agents using Sinatra.
 
 ## Usage
 
-1. Start the registry service:
-   ```
-   ruby registry.rb
-   ```
+From the examples directory you will need to start three different processes.  You will want to keep them all in the forgound so it would be best to start them in different terminal windows.
+
+Start the sample registry first: `./registry.rb`
+
+Then start the service agent: `./maxwell_agent86.rb`
+Maxwell will will register itself, get its UUID and setup a message queue to which it will listen for its service requests.
 
-2. Run the HelloWorld agent:
-   ```
-   ruby hello_world.rb
-   ```
+Finally start the chief agent in charge: `./chief_agent.rb`
+The Chief also registers itself but no other agent can give the Chief missions.  That's his job.  The chief gets his mission UUID, sets up a message queue to listen for the reports from the field after he sends out his request (aka order)
 
-3. Run the HelloWorld client:
-   ```
-   ruby hello_world_client.rb
-   ```
+But first the Chief asks the registry for the UUIDs of all agents who can handle a "greeter" request.  The Chief selects one of those agents and sends the agent a greet request.  The Chief then waits for a response to the request.  When it comes in, the chiefs displays the response and terminates.
 
-## Dependencies
+Run the chief a few times in a roll.  Some times the agent to whom the Chief issues his requests does not always respond the you would expect.
 
-- Ruby 3.3+
-- Gems: json, json_schema, sinatra, bunny, securerandom
+![Agent99 Framework Diagram](diagram.png)
 
-## Notes
 
-- The framework uses modern Ruby 3.3 syntax, especially for hashes and method signatures with named parameters.
-- The examples demonstrate basic usage of the Agent99 framework, including request/response handling, validation, and agent discovery.
-- The registry service uses an in-memory store (AGENT_REGISTRY) for simplicity, but it's recommended to use a more robust solution like SQLite for production use.

data/examples/chief_agent.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+# examples/chief_agent.rb
+#
+# This program is a type :client agent.
+#
+# This program calls a CLI program named boxes to highlight
+# the response received to the request that it sent.
+#
+# brew install boxes
+#
+# Run this program several times to see if Maxwell Agent86
+# messes up his mission which he is prone to do half the time.
+
+require_relative '../lib/agent99'
+
+class ChiefAgent < Agent99::Base
+  TYPE = :client
+
+  # init is called at the end of the initialization process.
+  # It may be only something that a :client type agent would do.
+  #
+  # For this client it sends out a request as its first order of
+  # business and expects to receive a response.
+  #
+  def init
+    action  = 'greeter'
+    agent   = discover_agent(
+                capability: action, 
+                how_many:   1
+              ).first[:uuid]
+
+    send_request(agent:)
+
+  rescue Exception => e
+    logger.warn "No Agents are available as #{action}"
+    exit(1)
+  end
+
+
+  ##################################################
+  private
+
+  def send_request(agent:)
+    request = build_request(
+                to_uuid:  agent,
+                greeting: 'Hey',
+                name:     'MadBomber'
+              )
+
+    result = @message_client.publish(request)
+    logger.info "Sent request: #{request.inspect}; status? #{result.inspect}"
+  end
+
+
+  def build_request(
+                to_uuid:,
+                greeting: 'Hello',
+                name:     'World'
+              )
+
+    {
+      header: {
+        type:       'request',
+        from_uuid:  @id,
+        to_uuid:    ,
+        event_uuid: SecureRandom.uuid,
+        timestamp:  Agent99::Timestamp.new.to_i
+      },
+      greeting:,
+      name:
+    }
+  end
+
+
+  def receive_response
+    logger.info "Received response: #{payload.inspect}"
+    result = payload[:result]
+
+    puts
+    puts `echo "#{result}" | boxes -d info`
+    puts
+
+    exit(0)
+  end
+
+
+  def capabilities
+    ['Chief of Control']
+  end
+end
+
+
+# Example usage
+client = ChiefAgent.new
+client.run
+

data/examples/control.rb

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+# control.rb
+
+require_relative '../lib/agent99'
+
+class Control < Agent99::Base
+  TYPE = :hybrid
+
+  attr_accessor :statuses
+
+  def init
+    @agents = @registry_client.fetch_all_agents
+    @statuses = {}
+  end
+
+
+  def capabilities
+    ['control', 'headquarters', 'secret underground base']
+  end
+
+
+  def send_control_message(message:, payload: {})
+    @agents.each do |agent|
+      response = @message_client.publish(
+        header: {
+          to_uuid: agent[:uuid],
+          from_uuid: @id,
+          event_uuid: SecureRandom.uuid,
+          type: 'control',
+          timestamp: Agent99::Timestamp.new.to_i
+        },
+        action: message,
+        payload: payload
+      )
+      puts "Sent #{message} to #{agent[:name]}: #{response[:success] ? 'Success' : 'Failed'}"
+    end
+  end
+
+
+  def pause_all
+    send_control_message(message: 'pause')
+  end
+
+
+  def resume_all
+    send_control_message(message: 'resume')
+  end
+
+
+  def stop_all
+    send_control_message(message: 'stop')
+  end
+
+  def get_all_status
+    @statuses.clear  # Reset statuses before new request
+    
+    @agents.each do |agent|
+      @message_client.publish(
+        header: {
+          to_uuid:    agent[:uuid],
+          from_uuid:  @id,
+          event_uuid: SecureRandom.uuid,
+          type:       'control',
+          timestamp:  Agent99::Timestamp.new.to_i
+        },
+        action: 'status'
+      )
+    end
+
+    # Wait for responses (with timeout)
+    sleep 2  # Give agents time to respond
+    @statuses
+  end
+
+  def receive_response
+    if payload[:action] == 'response' && payload[:data][:type] == 'status'
+      agent_name = payload[:header][:from_uuid]
+      @statuses[agent_name] = payload[:data]
+      logger.info "Received status from #{agent_name}: #{payload[:data]}"
+    elsif payload[:action] == 'status' && payload[:header][:from_uuid] == @id
+      # Handle our own status request
+      handle_status_request
+    end
+  end
+
+
+end
+
+
+if __FILE__ == $PROGRAM_NAME
+  control = Control.new
+  
+  # Start the message processing in a separate thread
+  dispatcher_thread = Thread.new do
+    control.run
+  end
+
+  # UI thread
+  begin
+    loop do
+      puts "\n1. Pause all agents"
+      puts "2. Resume all agents"
+      puts "3. Stop all agents"
+      puts "4. Get all agents status"
+      puts "5. Exit"
+      print "\nEnter your choice: "
+      
+      choice = gets.chomp.to_i
+
+      case choice
+      when 1
+        control.pause_all
+      when 2
+        control.resume_all
+      when 3
+        control.stop_all
+      when 4
+        statuses = control.get_all_status
+        sleep 2 # Give time for responses to arrive
+        puts JSON.pretty_generate(control.statuses)
+      when 5
+        puts "Exiting..."
+        Thread.exit
+        break
+      else
+        puts "Invalid choice. Please try again."
+      end
+    end
+  rescue Interrupt
+    puts "\nShutting down..."
+  ensure
+    dispatcher_thread.exit
+    control.fini
+  end
+end
+

data/examples/diagram.dot

@@ -0,0 +1,22 @@
+digraph agent_interaction {
+    rankdir=LR; // Left to right layout
+
+    // Define nodes for each component
+    node [shape=box];
+    ChiefAgent [label="ChiefAgent"];
+    MaxwellAgent86 [label="MaxwellAgent86"];
+    Registry [label="Registry Service"];
+
+    // Define edges for interactions
+    ChiefAgent -> Registry [label="GET /discover (greeter)"];
+    Registry -> ChiefAgent [label="Agent UUIDs"];
+
+    ChiefAgent -> MaxwellAgent86 [label="Send greet request"];
+    MaxwellAgent86 -> ChiefAgent [label="Response (Hello World)"];
+    
+    MaxwellAgent86 -> Registry [label="POST /register"];
+    Registry -> MaxwellAgent86 [label="ACK (registration)"];
+
+    ChiefAgent -> Registry [label="POST /register"];
+    Registry -> ChiefAgent [label="ACK (registration)"];
+}

data/examples/{hello_world.rb → maxwell_agent86.rb}

@@ -1,22 +1,31 @@
 #!/usr/bin/env ruby
-# examples/hello_world.rb
+# examples/maxwell_agent86.rb
 
-require 'json'
-require 'json_schema'
+# There are three types of agents: Server, Client and Hybrid.
+# A Server receives a requests and _may_ send a response.
+# A Client sends a request and _may_ expect a response.
+# A Hybrid _may_ act like a Server or a Client
 
 require_relative '../lib/agent99'
-require_relative 'hello_world_request'
+require_relative 'maxwell_request'
+
+class MaxwellAgent86 < Agent99::Base
+  REQUEST_SCHEMA  = MaxwellRequest.schema
+  TYPE            = :server
 
-class HelloWorld < Agent99::Base
-  REQUEST_SCHEMA  = HelloWorldRequest.schema
   # RESPONSE_SCHEMA = Agent99::RESPONSE.schema
   # ERROR_SCHEMA    = Agent99::ERROR.schema
 
+
+  #######################################
+  private
+
   # The request is in @payload
   def receive_request
     send_response( validate_request || process )
   end
 
+
   # This method validates the incoming request and returns any errors found
   # or nil if there are no errors.
   # It allows for returning an array of errors.
@@ -44,6 +53,7 @@ class HelloWorld < Agent99::Base
       }
     end
 
+
     # Validate the incoming request body against the schema
     validation_errors = validate_schema
     unless validation_errors.empty?
@@ -57,6 +67,7 @@ class HelloWorld < Agent99::Base
     responses.empty? ? nil : responses
   end
 
+
   # Returns the response value
   # All response message have the same schema in that
   # they have a header (all messages have headers) and
@@ -64,9 +75,13 @@ class HelloWorld < Agent99::Base
   # a JSON string, sure but then we would need a 
   # RESPONSE_SCHEMA constant for the class.
   def process
-    {
-      result: get(:greeting) + ' ' + get(:name)
-    }
+    result  = if 50 <= rand(100)
+                get(:greeting) + ' ' + get(:name)
+              else
+                'Missed it by that >< much.'
+              end
+
+    { result: result }
   end
 
 
@@ -76,16 +91,21 @@ class HelloWorld < Agent99::Base
     loger.warn("Unexpected response type message: response.inspect")
   end
 
-  private
 
-  # NOTE: what I'm thinking about here is similar to the
-  #       prompt tool (aka function) callback facility
-  #       where descriptive text is used to describe
-  #       what the tool does.
+  # Phase One Implementation is to do a search
+  # using the String#include? and the Array#include?
+  # methods.  If you want discrete word-based selection
+  # then use an Array of Strings to define the different
+  # things this agent can do.
+  #
+  # If you want to match on sub-strings then define the
+  # the capabilities as a String.
+  #
+  # Subsequent implementations may use a semantic search
+  # to find the agents to use in which case capabilities may
+  # be constrained to be a String.
   #
-  # TODO: scale this idea back to just keywords
-  #       until the registry program gets more
-  #       stuff added to its discovery process.
+  # For now, lets just go with the Array of Strings.
   #
   def capabilities
     %w[ greeter hello_world hello-world hello]   
@@ -93,5 +113,5 @@ class HelloWorld < Agent99::Base
 end
 
 # Example usage
-agent = HelloWorld.new
+agent = MaxwellAgent86.new
 agent.run # Starts listening for messages

data/examples/{hello_world_request.rb → maxwell_request.rb}

@@ -1,8 +1,8 @@
-# examples/hello_world_request.rb
+# examples/maxwell_request.rb
 
 require_relative '../lib/agent99/header_schema'
 
-class HelloWorldRequest < SimpleJsonSchemaBuilder::Base
+class MaxwellRequest < SimpleJsonSchemaBuilder::Base
   object do
     object :header, schema: Agent99::HeaderSchema
 

data/examples/registry.rb

@@ -6,7 +6,6 @@ include DebugMe
 
 require 'sinatra'
 require 'json'
-require 'bunny'
 require 'securerandom'
 
 # In-memory registry to store agent capabilities

data/examples/start_rabbitmq_and_registry.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# examples/start_rabbitmq_and_registry.sh
+#
+# brew install rabbitmq-server
+#
+# Start up the AMQP message broker (RabbitM@) in the background
+
+echo "Starting rabbitmq-server in background ..."
+rabbitmq-server &
+sleep 2
+open http://localhost:15672/#/queues
+
+echo
+echo
+echo "Starting example registry in forground ..."
+echo "http://localhost:4567"
+echo
+ruby registry.rb  # blocks until control-C
+
+# You may have to do control-c twice to stop both
+
+echo "#"
+echo "##"
+echo "###"
+echo "####"
+echo "#####"
+echo "registry is stopped"
+echo "stopping the rabbitmq server ...."
+rabbitmqctl stop

data/lib/agent99/agent_lifecycle.rb

@@ -48,9 +48,21 @@ module Agent99::AgentLifecycle
   end
 
 
+  # Performs cleanup operations when the agent is shutting down.
+  #
+  def fini
+    if id
+      queue_name = id
+      withdraw
+      @message_client&.delete_queue(queue_name)
+    else
+      logger.warn('fini called with a nil id')
+    end
+  end
+
   ################################################
   private
-
+  
   # Checks if the agent is currently paused.
   #
   # @return [Boolean] True if the agent is paused, false otherwise
@@ -71,17 +83,4 @@ module Agent99::AgentLifecycle
       end
     end
   end
-
-
-  # Performs cleanup operations when the agent is shutting down.
-  #
-  def fini
-    if id
-      queue_name = id
-      withdraw
-      @message_client&.delete_queue(queue_name)
-    else
-      logger.warn('fini called with a nil id')
-    end
-  end
-end
+end

data/lib/agent99/amqp_message_client.rb

@@ -6,6 +6,19 @@ require 'json_schema'
 require 'logger'
 
 class Agent99::AmqpMessageClient
+  CONFIG = {
+    host:           "127.0.0.1",
+    port:           5672,
+    ssl:            false,
+    vhost:          "/",
+    user:           "guest",
+    pass:           "guest",
+    heartbeat:      :server, # will use RabbitMQ setting
+    frame_max:      131072,
+    auth_mechanism: "PLAIN"
+  }
+
+
   QUEUE_TTL = 60_000 # 60 seconds TTL
   @instance = nil
 
@@ -17,16 +30,21 @@ class Agent99::AmqpMessageClient
 
   attr_accessor :logger, :channel, :exchange
 
-  def initialize(logger: Logger.new($stdout))
+  def initialize(
+      config: CONFIG,
+      logger: Logger.new($stdout))
+    @config     = config
     @connection = create_amqp_connection
-    @channel  = @connection.create_channel
-    @exchange = @channel.default_exchange
-    @logger   = logger
+    @channel    = @connection.create_channel
+    @exchange   = @channel.default_exchange
+    @logger     = logger
   end
 
   def setup(agent_id:, logger:)
     queue = create_queue(agent_id)
     
+    logger.info "Created queue for agent_id: #{agent_id}"
+
     # Returning the queue to be used in the Base class
     queue
   end
@@ -66,26 +84,39 @@ class Agent99::AmqpMessageClient
     queue_name = message.dig(:header, :to_uuid)
 
     begin
+      # FIXME: message.to_json
       json_payload = JSON.generate(message)
 
       exchange.publish(json_payload, routing_key: queue_name)
 
-      logger.info "Message published successfully to queue: #{queue_name}"
+      logger.info "#{message.dig(:header,:type).to_s.upcase} message published successfully to queue: #{queue_name}"
       
       # Return a success status
-      { success: true, message: "Message published successfully" }
+      { 
+        success: true, 
+        message: "Message published successfully" 
+      }
     
     rescue JSON::GeneratorError => e
       logger.error "Failed to convert payload to JSON: #{e.message}"
-      { success: false, error: "JSON conversion error: #{e.message}" }
+      { 
+        success: false, 
+        error: "JSON conversion error: #{e.message}" 
+      }
     
     rescue Bunny::ConnectionClosedError, Bunny::ChannelAlreadyClosed => e
       logger.error "Failed to publish message: #{e.message}"
-      { success: false, error: "Publishing error: #{e.message}" }
+      { 
+        success: false, 
+        error: "Publishing error: #{e.message}" 
+      }
     
     rescue StandardError => e
       logger.error "Unexpected error while publishing message: #{e.message}"
-      { success: false, error: "Unexpected error: #{e.message}" }
+      { 
+        success:  false, 
+        error:    "Unexpected error: #{e.message}" 
+      }
     end
   end
 
@@ -109,7 +140,7 @@ class Agent99::AmqpMessageClient
   private
   
   def create_amqp_connection
-    Bunny.new.tap(&:start)
+    Bunny.new(@config).tap(&:start)
   rescue Bunny::TCPConnectionFailed, StandardError => e
     logger.error "Failed to connect to AMQP: #{e.message}"
     raise "AMQP Connection Error: #{e.message}. Please check your AMQP server and try again."

data/lib/agent99/base.rb

@@ -36,14 +36,6 @@ class Agent99::Base
   include Agent99::MessageProcessing
 
   MESSAGE_TYPES = %w[request response control]
-  
-  CONTROL_HANDLERS = {
-    'shutdown' => :handle_shutdown,
-    'pause' => :handle_pause,
-    'resume' => :handle_resume,
-    'update_config' => :handle_update_config,
-    'status' => :handle_status_request
-  }
 
   attr_reader :id, :capabilities, :name, :payload, :header, :logger, :queue
   attr_accessor :registry_client, :message_client
@@ -56,6 +48,12 @@ class Agent99::Base
     logger.error "#{message}: #{error.message}"
     logger.debug error.backtrace.join("\n")
   end
+
+
+  # the final rescue block
+  rescue StandardError => e
+    handle_error("Unhandled error in Agent99::Base", e)
+    exit(2)
 end
 
 

data/lib/agent99/control_actions.rb

@@ -1,56 +1,89 @@
 # lib/agent99/control_actions.rb
 
 
-module Agent99::ControlActions
-
-
-  ################################################
-  private
-  
-  # Handles the shutdown control message.
-  #
-  def handle_shutdown
-    logger.info "Received shutdown command. Initiating graceful shutdown..."
-    send_control_response("Shutting down")
-    fini
-    exit(0)
-  end
+module Agent99
+  CONTROL_HANDLERS = {
+    'shutdown'      => :handle_shutdown,
+    'pause'         => :handle_pause,
+    'resume'        => :handle_resume,
+    'update_config' => :handle_update_config,
+    'status'        => :handle_status_request,
+    'response'      => :handle_control_response,
+  }
 
-  # Handles the pause control message.
-  #
-  def handle_pause
-    @paused = true
-    logger.info "Agent paused"
-    send_control_response("Paused")
-  end
+  module ControlActions
 
-  # Handles the resume control message.
-  #
-  def handle_resume
-    @paused = false
-    logger.info "Agent resumed"
-    send_control_response("Resumed")
-  end
 
-  # Handles the update_config control message.
-  #
-  def handle_update_config
-    new_config = payload[:config]
-    @config = new_config
-    logger.info "Configuration updated: #{@config}"
-    send_control_response("Configuration updated")
-  end
+    ################################################
+    private
+    
+    def handle_control_response
+      logger.info "Received control response: #{payload}"
+      response_type = payload.dig(:data, :type)
+      response_data = payload[:data]
+
+      case response_type
+      when 'status'
+        logger.info "Status update from agent: #{response_data}"
+      when 'error'
+        logger.error "Error from agent: #{response_data[:error]}"
+      else
+        logger.info "Generic control response: #{payload[:message]}"
+      end
+    end
+
+
+    # Handles the shutdown control message.
+    #
+    def handle_shutdown
+      logger.info "Received shutdown command. Initiating graceful shutdown..."
+      send_control_response("Shutting down")
+      fini
+      exit(0)
+    end
+
 
-  # Handles the status request control message.
-  #
-  def handle_status_request
-    status = {
-      id: @id,
-      name: @name,
-      paused: @paused,
-      config: @config,
-      uptime: (Time.now - @start_time).to_i
-    }
-    send_control_response("Status", status)
+    # Handles the pause control message.
+    #
+    def handle_pause
+      @paused = true
+      logger.info "Agent paused"
+      send_control_response("Paused")
+    end
+
+
+    # Handles the resume control message.
+    #
+    def handle_resume
+      @paused = false
+      logger.info "Agent resumed"
+      send_control_response("Resumed")
+    end
+
+
+    # Handles the update_config control message.
+    #
+    def handle_update_config
+      new_config = payload[:config]
+      @config = new_config
+      logger.info "Configuration updated: #{@config}"
+      send_control_response("Configuration updated")
+    end
+
+
+    # Handles the status request control message.
+    #
+    def handle_status_request
+      status = {
+        type: 'status',
+        id: @id,
+        name: @name,
+        paused: @paused,
+        config: @config,
+        uptime: (Time.now - @start_time).to_i
+      }
+      send_control_response(status)
+    end
   end
 end
+

data/lib/agent99/header_management.rb

@@ -4,7 +4,7 @@ module Agent99::HeaderManagement
 
 
   ################################################
-  private
+  # private
   
   def header      = @payload[:header]
   def to_uuid     = header[:to_uuid]
@@ -14,9 +14,11 @@ module Agent99::HeaderManagement
   def type        = header[:type]
 
   def return_address
-    header.merge(
-      to_uuid:    from_uuid,
-      from_uuid:  to_uuid,
+    return_address = payload[:header].dup
+
+    return_address.merge(
+      to_uuid:    return_address[:from_uuid],
+      from_uuid:  return_address[:to_uuid],
       timestamp:  Agent99::Timestamp.new.to_i,
       type:       'response'
     )

data/lib/agent99/message_processing.rb

@@ -16,14 +16,15 @@ module Agent99::MessageProcessing
   #
   def dispatcher
     @start_time = Time.now
-    @paused = false
-    @config = {}
+    @paused     = false
+    @config     = {}
+
 
     message_client.listen_for_messages(
       queue,
-      request_handler: ->(message) { process_request(message) unless paused? },
+      request_handler:  ->(message) { process_request(message) unless paused? },
       response_handler: ->(message) { process_response(message) unless paused? },
-      control_handler: ->(message) { process_control(message) }
+      control_handler:  ->(message) { process_control(message) }
     )
   end
 
@@ -33,8 +34,8 @@ module Agent99::MessageProcessing
   # @param message [Hash] The incoming message
   #
   def process_request(message)
-    @payload = message
-    @header = payload[:header]
+    @payload  = message
+    @header   = payload[:header]
     return unless validate_schema.empty?
     receive_request
   end
@@ -54,11 +55,14 @@ module Agent99::MessageProcessing
   #
   def process_control(message)
     @payload = message
-    receive_control
+    if payload[:action] == 'response'
+      receive_response
+    else
+      receive_control
+    end
   end
 
 
-
   # Handles incoming request messages (to be overridden by subclasses).
   #
   def receive_request
@@ -78,8 +82,9 @@ module Agent99::MessageProcessing
   # @raise [StandardError] If there's an error processing the control message
   #
   def receive_control
-    action = payload[:action]
-    handler = CONTROL_HANDLERS[action]
+
+    action  = payload[:action]
+    handler = Agent99::CONTROL_HANDLERS[action]
     
     if handler
       send(handler)
@@ -89,7 +94,7 @@ module Agent99::MessageProcessing
   
   rescue StandardError => e
     logger.error "Error processing control message: #{e.message}"
-    send_control_response("Error", { error: e.message })
+    send_control_response({ error: e.message })
   end
 
 
@@ -108,15 +113,16 @@ module Agent99::MessageProcessing
   # @param message [String] The response message
   # @param data [Hash, nil] Additional data to include in the response
   #
-  def send_control_response(message, data = nil)
+  def send_control_response(data)
     response = {
       header: return_address.merge(type: 'control'),
-      message: message,
+      action: 'response',
       data: data
     }
     @message_client.publish(response)
   end
 
+
   # Validates the incoming message against the defined schema.
   #
   # @return [Array] An array of validation errors, empty if validation succeeds
@@ -135,6 +141,7 @@ module Agent99::MessageProcessing
     e.messages
   end
 
+
   # Retrieves a field from the payload or returns a default value.
   #
   # @param field [Symbol] The field to retrieve
@@ -144,6 +151,7 @@ module Agent99::MessageProcessing
     payload[field] || default(field)
   end
 
+
   # Returns the default value for a field from the schema.
   #
   # @param field [Symbol] The field to get the default for

data/lib/agent99/registry_client.rb

@@ -35,6 +35,12 @@ class Agent99::RegistryClient
     send_request(request)
   end
 
+
+  def fetch_all_agents
+    request = create_request(:get, "/")
+    response = send_request(request)
+  end
+
   ################################################
   private
 
@@ -48,9 +54,11 @@ class Agent99::RegistryClient
     response = @http_client.request(request)
 
     handle_response(response)
+  
   rescue JSON::ParserError => e
     logger.error "JSON parsing error: #{e.message}"
     nil
+  
   rescue StandardError => e
     logger.error "Request error: #{e.message}"
     nil

data/lib/agent99/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Agent99
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 
   def self.version  = VERSION
 end

data/lib/agent99.rb

@@ -3,6 +3,10 @@
 require 'debug_me'
 include DebugMe
 
+require 'json'
+require 'json_schema'
+require 'securerandom'
+
 module Agent99; end  # Establish a namespace
 
 require_relative 'agent99/base'

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: agent99
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Dewayne VanHoozer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-05 00:00:00.000000000 Z
+date: 2024-12-07 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: ai_client
-  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: bunny
   requirement: !ruby/object:Gem::Requirement
@@ -154,11 +140,14 @@ files:
 - Rakefile
 - docs/todo.md
 - examples/README.md
-- examples/hello_world.rb
-- examples/hello_world_client.rb
-- examples/hello_world_request.rb
+- examples/chief_agent.rb
+- examples/control.rb
+- examples/diagram.dot
+- examples/diagram.png
+- examples/maxwell_agent86.rb
+- examples/maxwell_request.rb
 - examples/registry.rb
-- examples/start_agents.sh
+- examples/start_rabbitmq_and_registry.sh
 - lib/agent99.rb
 - lib/agent99/.irbrc
 - lib/agent99/agent_discovery.rb

data/examples/hello_world_client.rb

@@ -1,70 +0,0 @@
-#!/usr/bin/env ruby
-# examples/hello_world_client.rb
-
-require 'json'
-require 'json_schema'
-require 'securerandom'
-require_relative '../lib/agent99'
-
-class HelloWorldClient < Agent99::Base
-  def init
-    send_request
-  end
-
-  def send_request
-    to_uuid = discover_agent(capability: 'greeter', how_many: 1).first[:uuid]
-
-    request = build_request(
-                to_uuid:,
-                greeting: 'Hey',
-                name:     'MadBomber'
-              )
-
-    result = @message_client.publish(request)
-    logger.info "Sent request: #{request.inspect}; status? #{result.inspect}"
-  end
-
-  def build_request(
-                to_uuid:,
-                greeting: 'Hello',
-                name:     'World'
-              )
-
-    {
-      header: {
-        type:       'request',
-        from_uuid:  @id,
-        to_uuid:,
-        event_uuid: SecureRandom.uuid,
-        timestamp:  Agent99::Timestamp.new.to_i
-      },
-      greeting:,
-      name:
-    }
-  end
-
-
-  def receive_response
-    logger.info "Received response: #{payload.inspect}"
-    result = payload[:result]
-
-    puts
-    puts `echo "#{result}" | boxes -d info`
-    puts
-
-    exit(0)
-  end
-
-  #####################################################
-  private
-
-  def capabilities
-    ['hello_world_client']
-  end
-end
-
-
-# Example usage
-client = HelloWorldClient.new
-client.run
-

data/examples/start_agents.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-# Start the registry server
-echo "Starting registry server..."
-# Assuming the registry server is a separate process, replace with actual command
-# e.g., ruby registry_server.rb &
-# Replace 'registry_server_command' with the actual command to start your registry server
-# Example: ruby registry_server.rb &
-./registry.rb &
-
-# Start the HelloWorld agent
-echo "Starting HelloWorld agent..."
-./hello_world.rb &
-
-# Start the HelloWorldClient agent
-echo "Starting HelloWorldClient agent..."
-./hello_world_client.rb &
-
-# Wait for all background processes to finish
-wait