ruby-agents 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ca0396754afd0be4aac5df2f2c120e72d2898eea74f52df8fdfc8c414a941e70
+  data.tar.gz: 8805783b3594ed85b56658d2a0f8e9386ce6e9cdf1f18c4a9eaa0d12c6f7a7f6
+SHA512:
+  metadata.gz: 1b08f556416b78e11f9ab6d13f25c3f7f6b7a5c841c859b70d674fe37c91f62f36a3734ee0a388aea0584a5786e495e38b8ab3eb513265a95bfadc46cb1af8db
+  data.tar.gz: 5dba6e632f9d6cf3c452a796297fbcb191a02296cb0197889bfdc69b28d581f454b74882f47b0a56126ca015b0ce5be2bbb7dd250fa3d316d3af6ca65cd24e47

data/.gitignore

@@ -0,0 +1,59 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*
+
+.idea
+.DS_Store

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    ruby-agents (0.1.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    attr_extras (7.1.0)
+    base64 (0.1.1)
+    concurrent-ruby (1.2.2)
+    diff-lcs (1.5.0)
+    event_stream_parser (0.3.0)
+    faraday (2.7.11)
+      base64
+      faraday-net_http (>= 2.0, < 3.1)
+      ruby2_keywords (>= 0.0.4)
+    faraday-multipart (1.0.4)
+      multipart-post (~> 2)
+    faraday-net_http (3.0.2)
+    multipart-post (2.3.0)
+    optimist (3.1.0)
+    patience_diff (1.2.0)
+      optimist (~> 3.0)
+    ruby-openai (6.0.0)
+      event_stream_parser (>= 0.3.0, < 1.0.0)
+      faraday (>= 1)
+      faraday-multipart (>= 1)
+    ruby2_keywords (0.0.5)
+    super_diff (0.10.0)
+      attr_extras (>= 6.2.4)
+      diff-lcs
+      patience_diff
+    tldr (0.9.5)
+      concurrent-ruby (~> 1.2)
+      super_diff (~> 0.10)
+
+PLATFORMS
+  arm64-darwin-21
+  arm64-darwin-22
+
+DEPENDENCIES
+  ruby-agents!
+  ruby-openai (>= 5.1)
+  tldr (>= 0.9.5)
+
+BUNDLED WITH
+   2.4.19

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jeff McFadden
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# agents
+
+A ruby library for building and managing AI agents within your application.
+
+## Getting Started
+
+Gemfile:
+
+```ruby
+gem 'agents', git: "jeffmcfadden/agents"
+```
+
+`bundle install`
+
+## Usage
+
+```ruby
+  require 'agents'
+```
+
+### Built-in Agents
+
+### Building Your Own Agents
+
+### Using a Dispatcher
+
+### Running Actions
+
+
+## Testing
+
+Use `tldr` to run the tests.
+
+```shell
+$ bundle install
+$ tldr --watch
+```
+
+By default, no network calls are made while testing. If you want to test the full path into OpenAI, you can run that with:
+
+```shell
+$ OPENAI_ACCESS_TOKEN="sk-123YourToken" bundle exec ruby test/test_openai.rb
+```

data/agents.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
+require 'logger'
+require_relative 'lib/version'
+
+Gem::Specification.new do |s|
+  s.name = "ruby-agents"
+  s.version     = Agents::VERSION
+  s.platform    = Gem::Platform::RUBY
+
+  s.authors = ["Jeff McFadden"]
+  s.date = "2023-11-05"
+  s.description = "Put AI to Work."
+  s.email = "55709+jeffmcfadden@users.noreply.github.com"
+  s.files = `git ls-files`.split("\n")
+
+  s.homepage = "https://github.com/jeffmcfadden/agents"
+  s.require_paths = ["lib"]
+  s.rubygems_version = Agents::VERSION
+  s.summary = "Setup and organize requests between multiple AI agents."
+
+  s.add_development_dependency "tldr", ">= 0.9.5"
+  s.add_development_dependency "ruby-openai", ">= 5.1"
+end

data/lib/actions/action.rb

@@ -0,0 +1,43 @@
+module Agents
+
+  # Takes a block and executes it when the action is called.
+  class Action
+    attr_reader :name, :description, :arguments, :examples
+
+    # Create a new action
+    # @param [String] name
+    # @param [String] description
+    # @param [Array<ActionArgument>] arguments
+    # @param [Array<ActionExample>] examples
+    # @param [Block] block
+    def initialize(name:, description: "", arguments: [], examples: [], &block)
+      @name = name
+      @description = description
+      @arguments = arguments
+      @examples = examples
+      @block = block
+    end
+
+    # Execute the block with the given arguments.
+    def call(args)
+      @block.call(args)
+    end
+
+    def for_prompt
+      s = "#{name}: #{description}\n"
+
+      unless arguments.empty?
+        s << "  Arguments:\n"
+        s << arguments.collect(&:for_prompt).join("\n") << "\n"
+      end
+
+      unless examples.empty?
+        s << "  For example:\n"
+        s << examples.collect(&:for_prompt).join("\n") << "\n"
+      end
+
+      s
+    end
+
+  end
+end

data/lib/actions/action_argument.rb

@@ -0,0 +1,14 @@
+module Agents
+  class ActionArgument
+    attr_reader :name, :type, :description
+    def initialize(name:, type:, description:)
+      @name = name
+      @type = type
+      @description = description
+    end
+
+    def for_prompt
+      "    #{name}: #{description}"
+    end
+  end
+end

data/lib/actions/action_example.rb

@@ -0,0 +1,14 @@
+module Agents
+  class ActionExample
+    attr_reader :input, :output
+    def initialize(input:, output:)
+      @input = input
+      @output = output
+    end
+
+    def for_prompt
+      "    Input: #{input}\n    Output: #{output}"
+    end
+
+  end
+end

data/lib/agents/agent.rb

@@ -0,0 +1,24 @@
+module Agents
+  class Agent
+    attr_reader :actions
+
+    def initialize(actions: [])
+      @actions = actions
+    end
+
+    # @param [Request] request
+    # @return [Response] response
+    def handle(request:)
+      Response.new("Sorry, this agent doesn't know how to handle requests.")
+    end
+
+    def register(action:)
+      @actions << action
+    end
+
+    def unregister(action:)
+      @actions.delete(action)
+    end
+
+  end
+end

data/lib/agents/dispatcher.rb

@@ -0,0 +1,29 @@
+module Agents
+  class Dispatcher < Agent
+    attr_reader :agents
+    def initialize(agents: [], **args)
+      super(**args)
+      @agents = agents
+    end
+
+    def register(agent)
+      @agents << agent
+    end
+
+    def unregister(agent)
+      @agents.delete(agent)
+    end
+
+    def handle(request:)
+      agent = agent_for_request(request: request)
+      agent.handle(request: request)
+    end
+
+    # Default behavior is a random agent. Use a subclass to specify behavior.
+    def agent_for_request(request:)
+      return UnhandleableRequestAgent.new if agents.empty?
+
+      @agents.shuffle.first
+    end
+  end
+end

data/lib/agents/echo_agent.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Agents
+    # An agent that echoes back the request text. Useful for testing.
+    class EchoAgent < Agent
+
+      # @param [Request] request
+      def handle(request:)
+        Response.new(request.request_text)
+      end
+    end
+end

data/lib/agents/gpt_agents/calendar_gpt_agent.rb

@@ -0,0 +1,17 @@
+module Agents
+  class CalendarGptAgent < GptAgent
+
+    attr_reader :system_prompt
+    def initialize(**args)
+      super(**args)
+      @description = "I am an AI Assistant that specializes in Calendar and Scheduling Management for Appointments, meetings, etc."
+      @system_prompt = <<~EOS
+        You are a helpful assistant.
+      EOS
+    end
+
+    def handle(request:)
+      gpt_client.chat system_prompt: system_prompt, prompt: request.request_text
+    end
+  end
+end

data/lib/agents/gpt_agents/categorizing_gpt_agent.rb

@@ -0,0 +1,19 @@
+module Agents
+  class CategorizingGptAgent < GptAgent
+
+    attr_reader :system_prompt
+    def initialize(**args)
+      super(**args)
+      @system_prompt = <<~EOS
+        You are a helpful assistant specializing in categorization. For each request to follow,
+        please respond with a JSON object with a single key, 'category'. Each request will include
+        the valid values for the category key.
+      EOS
+    end
+
+    # @return [GPTResponse] response
+    def handle(request:)
+      gpt_client.chat system_prompt: system_prompt, prompt: request.request_text
+    end
+  end
+end

data/lib/agents/gpt_agents/dispatching_gpt_agent.rb

@@ -0,0 +1,27 @@
+module Agents
+  class DispatchingGptAgent < Dispatcher
+    attr_reader :gpt_client
+
+    def initialize(gpt_client:, **args)
+      super(**args)
+      @gpt_client = gpt_client
+    end
+    def agent_for_request(request:)
+      categorize_request = Request.new(prompt_for_categorizing_request(request: request))
+
+      response_data = CategorizingGptAgent.new(gpt_client: gpt_client)
+                                          .handle(request: categorize_request).data
+
+      agent_class = response_data["category"]
+      agents.find{ _1.class.name == agent_class } || UnhandleableRequestAgent.new
+    end
+
+    def prompt_for_categorizing_request(request:)
+      prompt = "The following is a list of Assistants and a description of what each can do: \n\n"
+      prompt << agents.collect{ "#{_1.class.name}: #{_1.description}" }.join("\n\n")
+      prompt << "If you are not sure which Assistant to use, it's okay to ask for more information.\n\n"
+      prompt << "Please categorize the request by typing the name of the Assistant that best fits the request.\n\n"
+      prompt << "Request: #{request.request_text}"
+    end
+  end
+end

data/lib/agents/gpt_agents/echo_gpt_agent.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Agents
+  # An agent that echoes back the request text. Useful for testing.
+  class EchoGptAgent < Agent
+
+    # @param [Request] request
+    def handle(request:)
+      GptResponse.new(request.request_text)
+    end
+  end
+end

data/lib/agents/gpt_agents/gpt_agent.rb

@@ -0,0 +1,29 @@
+module Agents
+  class GptAgent < Agent
+    attr_reader :gpt_client
+    attr_reader :description
+    attr_reader :system_prompt
+
+    def initialize(gpt_client:, description: "An AI Chatbot", system_prompt: "", **args)
+      super(**args)
+      @gpt_client = gpt_client
+      @description = description
+      @system_prompt = system_prompt
+    end
+
+    def handle(request:)
+      response = gpt_client.chat system_prompt: system_prompt, prompt: "#{prompt_prefix}#{request.request_text}"
+
+      response.suggested_actions.each do |action|
+        actions.find{ |a| a.name == action["name"] }&.call(action["args"])
+      end
+
+      response
+    end
+
+    def prompt_prefix
+      ""
+    end
+
+  end
+end

data/lib/agents/gpt_agents/information_retrieval_gpt_agent.rb

@@ -0,0 +1,17 @@
+module Agents
+  class InformationRetrievalGptAgent < GptAgent
+
+    attr_reader :system_prompt
+    def initialize(**args)
+      super(**args)
+      @description = "I am an AI Assistant that specializes in fetching information and answering general questions, etc."
+      @system_prompt = <<~EOS
+        You are a helpful assistant.
+      EOS
+    end
+
+    def handle(request:)
+      gpt_client.chat system_prompt: system_prompt, prompt: request.request_text
+    end
+  end
+end

data/lib/agents/gpt_agents/promptless_gpt_agent.rb

@@ -0,0 +1,10 @@
+module Agents
+  # An agent that does not add a prompt to the request, but simply passes it through.
+  # Use if your test _is _the prompt, for example.
+  class PromptlessGptAgent < GptAgent
+    def handle(request:)
+      Response.new(response_text: gpt_client.chat(prompt: request.request_text))
+    end
+
+  end
+end

data/lib/agents/gpt_agents/todo_gpt_agent.rb

@@ -0,0 +1,31 @@
+module Agents
+  class TodoGptAgent < GptAgent
+
+    def initialize(**args)
+      super(**args)
+      @description = "I am an AI Assistant that specializes in Todo List and Reminders Management."
+      @system_prompt = <<~EOS
+        You are a helpful assistant specializing in Todo List and Reminders Management. Please do your best to complete
+        any requests you are given. For each request, please respond ONLY with a JSON object. The JSON object should have
+        two top-level keys: `response` and `actions`. The `response` key should be a short string that summarizes the actions
+        to be taken. The `actions` key should be an array of JSON objects, each of which has a `name` key and an `args` key.
+        If you aren't sure what actions should be taken, or you don't think there's anything relevant, then respond with
+        an empty array for the `actions` key.
+        
+        
+      EOS
+    end
+
+    def system_prompt
+      prompt = @system_prompt
+
+      unless self.actions.empty?
+        prompt << "The following actions are supported: \n"
+        prompt << self.actions.collect(&:for_prompt).join("\n\n")
+      end
+
+      prompt << "\n\n"
+    end
+
+  end
+end

data/lib/agents/unhandleable_request_agent.rb

@@ -0,0 +1,8 @@
+module Agents
+  class UnhandleableRequestAgent
+    def handle(request:)
+      return UnhandleableRequestResponse.new(request: request)
+    end
+  end
+
+end

data/lib/agents.rb

@@ -0,0 +1,39 @@
+require_relative 'logger'
+require_relative 'version'
+
+require 'openai' rescue nil # OpenAI is optional
+
+require_relative 'gpt_clients/gpt_client'
+require_relative 'gpt_clients/echo_gpt_client'
+
+if defined?(::OpenAI::Client)
+  require_relative 'gpt_clients/open_ai_gpt_client'
+end
+
+require_relative 'agents/agent'
+require_relative 'agents/dispatcher'
+require_relative 'agents/echo_agent'
+
+require_relative 'agents/gpt_agents/gpt_agent'
+require_relative 'agents/gpt_agents/calendar_gpt_agent'
+require_relative 'agents/gpt_agents/categorizing_gpt_agent'
+require_relative 'agents/gpt_agents/dispatching_gpt_agent'
+require_relative 'agents/gpt_agents/information_retrieval_gpt_agent'
+require_relative 'agents/gpt_agents/promptless_gpt_agent'
+require_relative 'agents/gpt_agents/todo_gpt_agent'
+
+require_relative 'agents/unhandleable_request_agent'
+
+require_relative 'requests/request'
+
+require_relative 'responses/response'
+require_relative 'responses/gpt_response'
+require_relative 'responses/unhandleable_request_response'
+
+require_relative 'actions/action'
+require_relative 'actions/action_argument'
+require_relative 'actions/action_example'
+
+module Agents
+
+end

data/lib/gpt_clients/echo_gpt_client.rb

@@ -0,0 +1,11 @@
+module Agents
+  class EchoGptClient < GptClient
+
+    # Returns the input prompt as the output.
+    # @param [String] prompt
+    # @return [GPTResponse] response The response will be the same as the prompt.
+    def chat(prompt: "", **args)
+      GptResponse.new(prompt.to_s)
+    end
+  end
+end

data/lib/gpt_clients/gpt_client.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Agents
+  class GptClient
+    def initialize()
+    end
+
+    # Chats via the GPT Client, returns a GPTResponse
+    # @return [GPTResponse] response
+    def chat(prompt: "", **args)
+      GptResponse.new("Error: No GPT Client Setup.")
+    end
+  end
+end

data/lib/gpt_clients/open_ai_gpt_client.rb

@@ -0,0 +1,40 @@
+module Agents
+  class OpenAiGptClient < GptClient
+    attr_reader :open_ai_client
+    attr_reader :default_params
+
+    def initialize(open_ai_client:, default_params: {}, **args)
+      super(**args)
+      @open_ai_client = open_ai_client
+      @default_params = {
+        model: "gpt-3.5-turbo-1106",
+        temperature: 0.7,
+      }.merge(default_params)
+    end
+
+    def chat(prompt: "", **args)
+      messages = []
+      messages << { role: "system", content: "#{args[:system_prompt] || 'You are a helpful assistant.'}" }
+      messages << { role: "user", content: "#{prompt}" }
+
+      Agents.logger.debug("Sending to ChatGPT:")
+      Agents.logger.debug(messages)
+
+      parameters = default_params.merge({messages: messages})
+
+      completions = open_ai_client.chat parameters: parameters
+
+      Agents.logger.debug("ChatGPT Responded:")
+      Agents.logger.debug(completions)
+
+      text = completions.dig("choices", 0, "message", "content")
+
+      Agents.logger.debug("-" * 80)
+      Agents.logger.debug text
+      Agents.logger.debug("-" * 80)
+
+      GptResponse.new(text)
+    end
+
+  end
+end

data/lib/logger.rb

@@ -0,0 +1,13 @@
+#frozen_string_literal: true
+
+require 'logger'
+
+module Agents
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+end

data/lib/requests/request.rb

@@ -0,0 +1,8 @@
+module Agents
+  class Request
+    attr_reader :request_text
+    def initialize(request_text)
+      @request_text = request_text
+    end
+  end
+end

data/lib/responses/gpt_response.rb

@@ -0,0 +1,51 @@
+module Agents
+  # The response from a GPT request.
+  class GptResponse < Response
+
+    attr_reader :raw_text
+    attr_reader :response_text
+    attr_reader :suggested_actions
+    attr_reader :data
+
+
+    # @param [String] raw_text The raw text the GPT service returned.
+    def initialize(raw_text)
+      @raw_text = raw_text
+
+      begin
+        @data = extract_json_data(raw_text)
+        @response_text   = data["response"] || raw_text
+        @suggested_actions = data["actions"] || []
+      rescue
+        @data = {}
+        @response_text   = raw_text
+        @suggested_actions = []
+      end
+    end
+
+    # TODO: Extract this into an object:
+    def extract_json_data(string)
+      # Check if the string is valid JSON.
+      begin
+        json_obj = JSON.parse(string)
+        return json_obj
+      rescue JSON::ParserError => error
+        Agents.logger.info "Whole string was not pure JSON. #{error}"
+      end
+
+      # Search for JSON using regular expression
+      match_data = string.match(/\{.*\}/m)
+      if match_data
+        begin
+          Agents.logger.info "Found some JSON in the string."
+
+          json_obj = JSON.parse(match_data[0])
+          return json_obj
+        rescue JSON::ParserError
+          Agents.logger.info "Extracted string was not pure JSON. #{error}"
+        end
+      end
+    end
+
+  end
+end

data/lib/responses/response.rb

@@ -0,0 +1,8 @@
+module Agents
+  class Response
+    attr_reader :response_text
+    def initialize(response_text)
+      @response_text = response_text
+    end
+  end
+end

data/lib/responses/unhandleable_request_response.rb

@@ -0,0 +1,8 @@
+module Agents
+  class UnhandleableRequestResponse < Response
+    def initialize(request:)
+      super("Sorry, I'm not sure how to handle that.")
+    end
+  end
+
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Agents
+  VERSION = "0.1.2"
+end

data/test/test_actions.rb

@@ -0,0 +1,87 @@
+require 'agents'
+
+module Agents
+  class TestActions < TLDR
+
+    def setup
+      @gpt_client = EchoGptClient.new
+      @dispatcher = DispatchingGptAgent.new(gpt_client: @gpt_client)
+      @agent = TodoGptAgent.new(gpt_client: @gpt_client)
+
+      @dispatcher.register(@agent)
+    end
+
+    def test_dispatching_prompt
+      test_action = Action.new(name: "test_action") do |args|
+        puts "This is a test action"
+      end
+
+      @agent.register(action: test_action)
+
+      # This is a JSON payload because the EchoGPTClient will echo this back as the response
+      test_payload = {
+        "response": "I added peanut butter to your grocery list.",
+        "actions": [
+          {
+            "name": "test_action",
+            "args": [
+              {
+                "todo_list": "Grocery",
+                "item_title": "peanut butter"
+              }
+            ]
+          }
+        ]
+      }
+
+      test_request = Request.new(test_payload.to_json)
+
+      response = @agent.handle(request: test_request)
+
+      assert_equal "{\"response\":\"I added peanut butter to your grocery list.\",\"actions\":[{\"name\":\"test_action\",\"args\":[{\"todo_list\":\"Grocery\",\"item_title\":\"peanut butter\"}]}]}", response.raw_text
+      # assert_equal "I added peanut butter to your grocery list.", response.response_text
+      # assert_equal response.suggested_actions.size, 1
+    end
+
+
+    class TestablePerformingAction < Action
+
+      attr_reader :was_performed
+      def initialize(**args)
+        super(**args)
+        @was_performed = false
+      end
+
+      def call(args)
+        super(args)
+        @was_performed = true
+      end
+    end
+
+    class TestActionPerformingGptAgent < GptAgent
+
+    end
+
+    def test_performing_action
+      test_action = TestablePerformingAction.new(name: "test_action") do
+        return "This is a test action"
+      end
+
+      agent = TestActionPerformingGptAgent.new(gpt_client: @gpt_client, system_prompt: "This is a test prompt", description: "This is a test description")
+
+      assert_equal false, test_action.was_performed
+
+      agent.register(action: test_action)
+
+      # This is a JSON payload because the EchoGPTClient will echo this back as the response
+      test_payload = { response: "I performed the test action for you", actions: [{ name: "test_action", args: {} }] }
+
+      test_request = Request.new(test_payload.to_json)
+      response = agent.handle(request: test_request)
+
+      assert_equal true, test_action.was_performed
+      assert_equal "I performed the test action for you", response.response_text
+    end
+
+  end
+end

data/test/test_dispatcher.rb

@@ -0,0 +1,38 @@
+require 'agents'
+
+module Agents
+  class TestDispatcher < TLDR
+
+    def setup
+      @dispatcher = Dispatcher.new
+      @agent1 = Agent.new
+      @agent2 = Agent.new
+
+      @echo_agent = EchoAgent.new
+    end
+
+    def test_registration
+      @dispatcher.register(@agent1)
+      @dispatcher.register(@agent2)
+      assert_equal(@dispatcher.agents, [@agent1, @agent2])
+    end
+
+    def test_unregistration
+      @dispatcher.register(@agent1)
+      @dispatcher.register(@agent2)
+      @dispatcher.unregister(@agent1)
+      assert_equal(@dispatcher.agents, [@agent2])
+    end
+
+    def test_default_handling
+      @dispatcher.register(@echo_agent)
+
+      # Default handling is to select a random agent. In this case we have a single
+      # echoing agent, so we expect the codepath to be exercised, but we know it will
+      # always be that one agent.
+      response = @dispatcher.handle(request: Request.new("Test Request"))
+      assert_equal("Test Request", response.response_text )
+    end
+
+  end
+end

data/test/test_gpt_dispatcher.rb

@@ -0,0 +1,25 @@
+require 'agents'
+
+module Agents
+  class TestGptDispatcher < TLDR
+
+    def setup
+      @gpt_client = EchoGptClient.new
+      @dispatcher = DispatchingGptAgent.new(gpt_client: @gpt_client)
+      @agent1 = TodoGptAgent.new(gpt_client: @gpt_client)
+      @agent2 = CalendarGptAgent.new(gpt_client: @gpt_client)
+
+      @dispatcher.register(@agent1)
+      @dispatcher.register(@agent2)
+    end
+
+    def test_dispatching_prompt
+      request = Request.new("I need to buy some bread")
+
+      expected = "The following is a list of Assistants and a description of what each can do: \n\nAgents::TodoGptAgent: I am an AI Assistant that specializes in Todo List and Reminders Management.\n\nAgents::CalendarGptAgent: I am an AI Assistant that specializes in Calendar and Scheduling Management for Appointments, meetings, etc.Please categorize the request by typing the name of the Assistant that best fits the request.\n\nRequest: I need to buy some bread"
+
+      assert_equal(expected, @dispatcher.prompt_for_categorizing_request(request: request))
+    end
+
+  end
+end

data/test/test_openai.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# This actually tests the full Open AI call path. It can be slow, and tldr will
+# fail after 1.8 seconds, so you need to run this separately.
+
+# Run this file with:
+# OPENAI_ACCESS_TOKEN="sk-123YourToken" bundle exec ruby test/test_openai.rb
+require 'openai'
+require 'agents'
+
+module Agents
+
+  class ActionPerformingGptAgent < GptAgent
+  end
+
+  class TestOpenAi
+    def initialize
+      @openai_client = OpenAI::Client.new(access_token: ENV['OPENAI_ACCESS_TOKEN'])
+      @gpt_client = Agents::OpenAiGptClient.new(open_ai_client: @openai_client)
+    end
+
+    def test_basic_chat
+      puts "-" * 60
+      puts "test_basic_chat:"
+      @agent = Agents::PromptlessGptAgent.new(gpt_client: @gpt_client)
+      response = @agent.handle(request: Request.new("Tell me a joke"))
+      puts response.response_text
+    end
+
+    def test_dispatching_chat
+      puts "-" * 60
+      puts "test_dispatching_chat:"
+      dispatcher = Agents::DispatchingGptAgent.new(gpt_client: @gpt_client)
+      dispatcher.register(Agents::TodoGptAgent.new(gpt_client: @gpt_client))
+      dispatcher.register(Agents::CalendarGptAgent.new(gpt_client: @gpt_client))
+      dispatcher.register(Agents::InformationRetrievalGptAgent.new(gpt_client: @gpt_client))
+
+      response = dispatcher.handle(request: Request.new("I need to buy break and milk"))
+      puts response
+    end
+
+    def test_todo_action
+      puts "-" * 60
+      puts "test_dispatching_chat:"
+
+      todo_agent = Agents::TodoGptAgent.new(gpt_client: @gpt_client)
+
+      add_todo_action = Action.new(name: "add_todo",
+                                   description: "Add a todo to a list",
+                                   arguments: [{name: "todo_list",  description: "The name of the todo list to add the item to"},
+                                               {name: "item_title", description: "The title of the item to add to the list"}]
+      ) do |**args|
+        puts "I added the todo"
+      end
+
+      todo_agent.register(action: add_todo_action)
+
+      dispatcher = Agents::DispatchingGptAgent.new(gpt_client: @gpt_client)
+      dispatcher.register(todo_agent)
+
+      response = dispatcher.handle(request: Request.new("I need to buy break and milk"))
+      puts response.response_text
+    end
+
+  end
+end
+
+# Skip this test if we don't have an access token
+unless ENV['OPENAI_ACCESS_TOKEN'].nil?
+  # Agents::TestOpenAi.new.test_basic_chat
+  # Agents::TestOpenAi.new.test_dispatching_chat
+  Agents::TestOpenAi.new.test_todo_action
+end

data/test/test_todo_gpt_agent.rb

@@ -0,0 +1,51 @@
+require 'agents'
+
+module Agents
+  class TestTodoGptAgent < TLDR
+
+    def setup
+      @agent = TodoGptAgent.new(gpt_client: EchoGptClient.new)
+
+      add_todo_action = Action.new(name: "add_todo",
+                                   description: "Add a todo to a list",
+                                   arguments: [ActionArgument.new(name: "todo_list",  type: "String", description: "The name of the todo list to add the item to"),
+                                               ActionArgument.new(name: "item_title", type: "String", description: "The title of the item to add to the list")],
+                                   examples: [ActionExample.new(input: "I'm out of milk and bread",
+                                                                output: { response: "I added milk and bread to your grocery list.",
+                                                                          actions: [{name: "add_item", args:[{todo_list: "Grocery", "item_title": "milk"}]},
+                                                                                    {name: "add_item", args:[{todo_list: "Grocery", "item_title": "bread"}]}
+                                                                          ]}.to_json  )]
+      ) do |**args|
+        return "I added the todo"
+      end
+
+      @agent.register(action: add_todo_action)
+    end
+
+    def test_prompt
+      expected_prompt = <<~EOS
+You are a helpful assistant specializing in Todo List and Reminders Management. Please do your best to complete
+any requests you are given. For each request, please respond ONLY with a JSON object. The JSON object should have
+two top-level keys: `response` and `actions`. The `response` key should be a short string that summarizes the actions
+to be taken. The `actions` key should be an array of JSON objects, each of which has a `name` key and an `args` key.
+If you aren't sure what actions should be taken, or you don't think there's anything relevant, then respond with
+an empty array for the `actions` key.
+
+
+The following actions are supported: 
+add_todo: Add a todo to a list
+  Arguments:
+    todo_list: The name of the todo list to add the item to
+    item_title: The title of the item to add to the list
+  For example:
+    Input: I'm out of milk and bread
+    Output: {"response":"I added milk and bread to your grocery list.","actions":[{"name":"add_item","args":[{"todo_list":"Grocery","item_title":"milk"}]},{"name":"add_item","args":[{"todo_list":"Grocery","item_title":"bread"}]}]}
+
+
+EOS
+      assert_equal(expected_prompt, @agent.system_prompt)
+    end
+
+
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: ruby-agents
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Jeff McFadden
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-11-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tldr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+description: Put AI to Work.
+email: 55709+jeffmcfadden@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- agents.gemspec
+- lib/actions/action.rb
+- lib/actions/action_argument.rb
+- lib/actions/action_example.rb
+- lib/agents.rb
+- lib/agents/agent.rb
+- lib/agents/dispatcher.rb
+- lib/agents/echo_agent.rb
+- lib/agents/gpt_agents/calendar_gpt_agent.rb
+- lib/agents/gpt_agents/categorizing_gpt_agent.rb
+- lib/agents/gpt_agents/dispatching_gpt_agent.rb
+- lib/agents/gpt_agents/echo_gpt_agent.rb
+- lib/agents/gpt_agents/gpt_agent.rb
+- lib/agents/gpt_agents/information_retrieval_gpt_agent.rb
+- lib/agents/gpt_agents/promptless_gpt_agent.rb
+- lib/agents/gpt_agents/todo_gpt_agent.rb
+- lib/agents/unhandleable_request_agent.rb
+- lib/gpt_clients/echo_gpt_client.rb
+- lib/gpt_clients/gpt_client.rb
+- lib/gpt_clients/open_ai_gpt_client.rb
+- lib/logger.rb
+- lib/requests/request.rb
+- lib/responses/gpt_response.rb
+- lib/responses/response.rb
+- lib/responses/unhandleable_request_response.rb
+- lib/version.rb
+- test/test_actions.rb
+- test/test_dispatcher.rb
+- test/test_gpt_dispatcher.rb
+- test/test_openai.rb
+- test/test_todo_gpt_agent.rb
+homepage: https://github.com/jeffmcfadden/agents
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Setup and organize requests between multiple AI agents.
+test_files: []