agent-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9d7ffbd12b2c6b7c1d24f998b6039c1bef1f347c48c4d94ef5d9fed0f23ffa45
+  data.tar.gz: 52be74c3c3cede8ea409ab054f3c1f74803f77ec4aa72319bcd2e4cf7e0d7695
+SHA512:
+  metadata.gz: d7892d9b9bc99dcc661dd6fab28c9b18254af7559e5a1f055afde012416c73fc07572a7af699123ba721bbc9bb466800fd67aa7ead10a657855965f02790a90d
+  data.tar.gz: 61ec01fc12b12e55c41cbc132f0a95b71ff17d006613169eb7c14c0390c971c907aa60451d6f8dfc95e41818721e4f4319350e4ef0036d0f32570708b3052964

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-04-11
+
+- Initial release

data/README.md

@@ -0,0 +1,90 @@
+# AgentRuby
+
+AgentRuby is a Ruby library that allows you to create and manage workflows using LLMs (Large Language Models). It provides a simple and intuitive interface for defining tasks, managing dependencies, and executing workflows.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add agent-ruby
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install agent-ruby
+```
+
+## Usage
+
+```ruby
+require 'agent-ruby'
+
+class CreateNoteTask < AgentRuby::Task
+  argument :title, String
+  argument :content, String
+  argument :folder_id, Integer
+
+  def perform(title:, content:, folder_id:)
+    Post.create(title:, content:, folder_id:)
+  end
+end
+
+class CreateFolderTask < AgentRuby::Task
+  argument :name, String
+  argument :path, String
+
+  def perform(name:, path:)
+    Folder.create(name:, path:)
+  end
+end
+
+class WikiAgent < AgentRuby::Agent
+  action CreateNoteAction
+  action CreateFolderAction
+end
+
+agent = WikiAgent.new("claude-3-7-sonnet-20250219")
+agent.hey(
+<<~TEXT
+  - Create a folder named "My Documents"
+  - Create a post titled "My First Post" with content "Hello, world!" in the folder "My Documents"
+TEXT
+)
+puts agent.messages.last.content
+
+# agent.hey("...") do |chunk|
+#   puts chunk
+# end
+```
+
+## Models
+
+```ruby
+RubyLLM.configure do |config|
+  config.openai_api_key = ENV.fetch('OPENAI_API_KEY', nil)
+  config.anthropic_api_key = ENV.fetch('ANTHROPIC_API_KEY', nil)
+  config.gemini_api_key = ENV.fetch('GEMINI_API_KEY', nil)
+  config.deepseek_api_key = ENV.fetch('DEEPSEEK_API_KEY', nil)
+
+  config.bedrock_api_key = ENV.fetch('AWS_ACCESS_KEY_ID', nil)
+  config.bedrock_secret_key = ENV.fetch('AWS_SECRET_ACCESS_KEY', nil)
+  config.bedrock_region = ENV.fetch('AWS_REGION', nil)
+  config.bedrock_session_token = ENV.fetch('AWS_SESSION_TOKEN', nil)
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/moekiorg/agent-ruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/agent-ruby/agent-ruby/blob/main/CODE_OF_CONDUCT.md).
+
+## Code of Conduct
+
+Everyone interacting in the He project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/agent-ruby/agent-ruby/blob/main/CODE_OF_CONDUCT.md).

data/lib/agent_ruby/action.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module AgentRuby
+  class Action
+    class << self
+      attr_accessor :arguments
+
+      def argument(name, type)
+        @arguments ||= []
+        @arguments << { name:, type: }
+      end
+    end
+
+    def perform(**args)
+      raise NotImplementedError, "You must implement the perform method"
+    end
+
+    def key
+      self.class.name
+    end
+  end
+end

data/lib/agent_ruby/agent.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module AgentRuby
+  class Agent
+    class << self
+      attr_reader :actions
+
+      def action(klass)
+        @actions ||= []
+        @actions << klass
+      end
+    end
+
+    attr_accessor :chat, :steps
+
+    def initialize(model = nil)
+      @chat = RubyLLM.chat(model:)
+      @steps = []
+    end
+
+    def hey(message, &block)
+      creation = nil
+      results = []
+      while 1
+        creation = Step::CreateTask.new(
+          actions: self.class.actions.map(&:new),
+          chat: @chat,
+          message:, block:,
+          results:,
+        )
+        created = creation.perform
+        task = creation.task
+        result = task.result
+        results << result
+        @steps << created
+        if creation.metadata[:continuation].to_s == "false"
+          break
+        end
+      end
+      summarize = Step::Summarize.new(
+          chat: @chat,
+          results:,
+          block:,
+        )
+      summary = summarize.perform
+      @steps << summary
+      @steps.map(&:content)
+    end
+  end
+end

data/lib/agent_ruby/configuration.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+RubyLLM.configure do |config|
+  config.openai_api_key = ENV.fetch("OPENAI_API_KEY", nil)
+  config.anthropic_api_key = ENV.fetch("ANTHROPIC_API_KEY", nil)
+  config.gemini_api_key = ENV.fetch("GEMINI_API_KEY", nil)
+  config.deepseek_api_key = ENV.fetch("DEEPSEEK_API_KEY", nil)
+
+  config.bedrock_api_key = ENV.fetch("AWS_ACCESS_KEY_ID", nil)
+  config.bedrock_secret_key = ENV.fetch("AWS_SECRET_ACCESS_KEY", nil)
+  config.bedrock_region = ENV.fetch("AWS_REGION", nil)
+  config.bedrock_session_token = ENV.fetch("AWS_SESSION_TOKEN", nil)
+end

data/lib/agent_ruby/message.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module AgentRuby
+  class Message
+    attr_accessor :messages
+
+    def initialize
+      @messages = []
+    end
+
+    def <<(message)
+      @messages << message
+    end
+
+    def to_s
+      @messages.join("\n")
+    end
+
+    def clear
+      @messages.clear
+    end
+  end
+end

data/lib/agent_ruby/prompt/create_task.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module AgentRuby
+  module Prompt
+    class CreateTask
+      def initialize(actions:, results:)
+        @actions = actions
+        @results = results
+      end
+
+      def to_s
+        <<~XML
+          <Instructions>
+            You are a workflow agent. Your task is to create a workflow based on the user's instructions.
+            `<Message>` tags contain your message to the user.
+            `<Metadata>` tags contain metadata about the workflow. If the workflow will continue, set the `continuation` key to `true`. If you think that the workflow is finished when the task is completed, set the `continuation` key to `false`.
+            `<Task>` tags contain the tasks to be performed. This tag must be present one time. Task must contain object not array.
+          </Instructions>
+
+          <Options>
+            #{
+              @actions.map { |action|
+                {
+                  key: action.key,
+                  params: action.class.arguments.map { _1.transform_values { |v| v.name } }
+                }
+              }.to_json
+            }
+          </Options>
+
+          <Example type="success">
+            <Message>
+              I will create a folder named "My Folder".
+            </Message>
+
+            <Metadata>
+              { "continuation": false | true }
+            </Metadata>
+
+            <Task>
+              {
+                "id": 1,
+                "key": "create_folder",
+                "params": {
+                  "name": "My Folder",
+                  "path": "My Folder"
+                }
+              }
+            </Task>
+          </Example>
+
+          <Example type="error">
+            <Error>
+              <Message>There was an error creating the folder</Message>
+            </Error>
+          </Example>
+        XML
+      end
+    end
+  end
+end

data/lib/agent_ruby/prompt/summarize.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module AgentRuby
+  module Prompt
+    class Summarize
+      def initialize(results:)
+        @results = results
+      end
+
+      def to_s
+        <<~XML
+          <Instruction>
+            <Item>
+              The workflow has been executed. Here are the results:
+              #{
+                @results.map { |r|
+                  "Task: #{r.action.key}, Params: #{r.action.class.arguments.to_json}, Result: #{r.result}"
+                }.join("\n")
+              }
+              Now, please summarize the results in a single JSON object
+            </Item>
+          </Instruction>
+
+          <Example type="success">
+            <Message>
+              I have created a folder named "My Folder" and a post titled "My Post" with content "This is my post" in the folder "My Folder"
+            </Message>
+          </Example>
+        XML
+      end
+    end
+  end
+end

data/lib/agent_ruby/result.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module AgentRuby
+  class Result
+    attr_reader :action, :result
+
+    def initialize(action:, result:)
+      @action = action
+      @result = result
+    end
+
+    def self.find(all, id)
+      all.find { |r| r.action.id == id.to_i }
+    end
+  end
+end

data/lib/agent_ruby/step/create_task.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module AgentRuby
+  module Step
+    class CreateTask
+      def initialize(actions:, chat:, message:, results:, block: nil)
+        @message = message
+        @results = results
+        @block = block
+        @actions = actions
+        @chat = chat
+        @response = nil
+      end
+      
+      def perform
+        @response = @chat.ask([
+          @message,
+          Prompt::CreateTask.new(actions: @actions, results: @results).to_s,
+        ].join) do |chunk|
+          @block.call(chunk) if @block
+        end
+
+        if @response.content.match?(/<Error>/)
+          raise Error, "Error: #{@response.content.match(/<Message>(.+)<\/Message>/m)[1]}"
+        end
+  
+        unless @response.content.match?(/<Message>(.+)<\/Message>/m)
+          raise NoMessageError, "Error: No message found in the response"
+        end
+  
+        unless @response.content.match?(/<Task>(.+)<\/Task>/m)
+          raise NoTaskError, "Error: No task found in the response"
+        end
+
+        @response
+      end
+
+      def task
+        Task.new(**JSON.parse(@response.content.match(/<Task>(.+)<\/Task>/m)[1], symbolize_names: true))
+      end
+
+      def message
+        @response.content.match(/<Message>(.+)<\/Message>/m)[1]
+      end
+
+      def metadata
+        if @response.content.match(/<Metadata>(.+)<\/Metadata>/m)
+          JSON.parse(@response.content.match(/<Metadata>(.+)<\/Metadata>/m)[1], symbolize_names: true)
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/agent_ruby/step/summarize.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AgentRuby
+  module Step
+    class Summarize
+      def initialize(chat:, results:, block: nil)
+        @block = block
+        @chat = chat
+        @results = results
+      end
+      
+      def perform
+        prompt = Prompt::Summarize.new(results: @results)
+        @response = @chat.ask(prompt.to_s) do |chunk|
+          @block.call(chunk) if @block
+        end
+
+        if @response.content.match?(/<Error>/)
+          raise Error, "Error: #{@response.content.match(/<Message>(.+)<\/Message>/m)[1]}"
+        end
+
+        unless @response.content.match?(/<Message>(.+)<\/Message>/m)
+          raise NoMessageError, "Error: No message found in the response"
+        end
+
+        @response
+      end
+
+      def message
+        @response.content.match(/<Message>(.+)<\/Message>/m)[1]
+      end
+    end
+  end
+end

data/lib/agent_ruby/task.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module AgentRuby
+  class Task
+    attr_accessor :id, :key, :params
+  
+    def initialize(id:, key:, params: {})
+      @id = id
+      @key = key
+      @params = params
+    end
+
+    def result
+      action = Object.const_get(key).new
+      Result.new(action:, result: action.perform(**@params))
+    end
+  end
+end

data/lib/agent_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AgentRuby
+  VERSION = "0.1.0"
+end

data/lib/agent_ruby.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require "dotenv/load"
+require_relative "agent_ruby/version"
+require_relative "agent_ruby/prompt/summarize"
+require_relative "agent_ruby/step/summarize"
+require_relative "agent_ruby/prompt/create_task"
+require_relative "agent_ruby/step/create_task"
+require_relative "agent_ruby/agent"
+require_relative "agent_ruby/task"
+require_relative "agent_ruby/message"
+require_relative "agent_ruby/configuration"
+require_relative "agent_ruby/result"
+require_relative "agent_ruby/action"
+
+module AgentRuby
+  class Error < StandardError; end
+  class NoMessageError < StandardError; end
+  class NoTaskError < StandardError; end
+
+  def self.new(model = nil)
+    AgentRuby::Agent.new(model)
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: agent-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- KAWAKAMI Moeki
+bindir: exe
+cert_chain: []
+date: 2025-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby_llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: AgentRuby is a Ruby library that allows you to create and manage workflows
+  using LLMs (Large Language Models). It provides a simple and intuitive interface
+  for defining tasks, managing dependencies, and executing workflows.
+email:
+- hi@moeki.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/agent_ruby.rb
+- lib/agent_ruby/action.rb
+- lib/agent_ruby/agent.rb
+- lib/agent_ruby/configuration.rb
+- lib/agent_ruby/message.rb
+- lib/agent_ruby/prompt/create_task.rb
+- lib/agent_ruby/prompt/summarize.rb
+- lib/agent_ruby/result.rb
+- lib/agent_ruby/step/create_task.rb
+- lib/agent_ruby/step/summarize.rb
+- lib/agent_ruby/task.rb
+- lib/agent_ruby/version.rb
+homepage: https://github.com/moekiorg/agent-ruby
+licenses: []
+metadata: {}
+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.6.6
+specification_version: 4
+summary: LLM Workflow Agent for Ruby
+test_files: []