raix 0.1.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87fae4c480456492bf09a09b45843820038052a9c1eb48d24d2b677cd627b754
-  data.tar.gz: 16138c511c83b121dd0a23058fc46c278de437034b8d51ca44b9b1fc515ff3c3
+  metadata.gz: eaf67088dabee6158ede28a1a2279124257313326c9bea8ef3791efe3649e7ca
+  data.tar.gz: b35022cc748f4ab851044300ee57dcc5ee317d133bdbf68fb3aeb2a6cbaa4bcd
 SHA512:
-  metadata.gz: 931376cc102cee9b3c5e6b9be75132133c9c05ad06cebb56292d5bbe415fa6972c15ab10474e83afaf71d83a32d5440c9d1c9e644a421dd63fc82a1a3e151d5e
-  data.tar.gz: f510d6af1463f0519d4934dee67fcb3154389cd3b0911a96fe789dd12542b26c027d6f8a1f8910b8de2ba063b0829dc83187f0d0d493a110586be7eb78dbef45
+  metadata.gz: 8aa98c05854a5697de357f75bacb649e17f51be6a4fe183dfb227aedb803c01f8001ffed29948af2883f726950fd58706d93410abded42cf25e6139c5fde88a2
+  data.tar.gz: f7eda9fc1aaf073d874b9c9d3c3c243605d6799d7c0778f701ae53d8ea339e4ca11ed358a0b66894675d774cdd2561cbdf38471bcd577e3e2638f3db947db609

data/.rubocop.yml

@@ -1,5 +1,6 @@
 AllCops:
-  TargetRubyVersion: 2.6
+  SuggestExtensions: false
+  TargetRubyVersion: 3.2.1
 
 Style/StringLiterals:
   Enabled: true
@@ -11,3 +12,21 @@ Style/StringLiteralsInInterpolation:
 
 Layout/LineLength:
   Max: 120
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false

data/CHANGELOG.md

@@ -2,4 +2,9 @@
 
 ## [0.1.0] - 2024-04-03
 
-- Initial release
+- Initial release, placeholder gem
+
+## [0.2.0] - tbd
+- adds `ChatCompletion` module
+- adds `PromptDeclarations` module
+- adds `FunctionDispatch` module

data/Gemfile

@@ -2,11 +2,23 @@
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in raix.gemspec
+# Specify your gem's dependencies in raix-rails.gemspec
 gemspec
 
-gem "rake", "~> 13.0"
+gem "activesupport", ">= 6.0"
+gem "faraday-retry"
+gem "open_router", "~> 0.3"
+gem "ruby-openai", "~> 7.0"
 
-gem "rspec", "~> 3.0"
-
-gem "rubocop", "~> 1.21"
+group :development do
+  gem "dotenv", ">= 2"
+  gem "guard"
+  gem "guard-rspec"
+  gem "pry", ">= 0.14"
+  gem "rake", "~> 13.0"
+  gem "rspec", "~> 3.0"
+  gem "rubocop", "~> 1.21"
+  gem "solargraph-rails", "~> 0.2.0.pre"
+  gem "sorbet"
+  gem "tapioca", require: false
+end

data/Gemfile.lock

@@ -2,22 +2,112 @@ PATH
   remote: .
   specs:
     raix (0.1.0)
+      activesupport (>= 6.0)
+      open_router (~> 0.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (7.1.3.4)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
     ast (2.4.2)
+    backport (1.2.0)
+    base64 (0.2.0)
+    benchmark (0.3.0)
+    bigdecimal (3.1.8)
+    coderay (1.1.3)
+    concurrent-ruby (1.3.3)
+    connection_pool (2.4.1)
     diff-lcs (1.5.1)
+    dotenv (3.1.2)
+    drb (2.2.1)
+    e2mmap (0.1.0)
+    erubi (1.13.0)
+    event_stream_parser (1.0.0)
+    faraday (2.9.2)
+      faraday-net_http (>= 2.0, < 3.2)
+    faraday-multipart (1.0.4)
+      multipart-post (~> 2)
+    faraday-net_http (3.1.0)
+      net-http
+    faraday-retry (2.2.1)
+      faraday (~> 2.0)
+    ffi (1.17.0-arm64-darwin)
+    formatador (1.1.0)
+    guard (2.18.1)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (>= 1.0.12, < 2.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.13.0)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    i18n (1.14.5)
+      concurrent-ruby (~> 1.0)
+    jaro_winkler (1.6.0)
     json (2.7.1)
+    kramdown (2.4.0)
+      rexml
+    kramdown-parser-gfm (1.1.0)
+      kramdown (~> 2.0)
     language_server-protocol (3.17.0.3)
+    listen (3.9.0)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    lumberjack (1.2.10)
+    method_source (1.1.0)
+    minitest (5.24.0)
+    multipart-post (2.4.1)
+    mutex_m (0.2.0)
+    nenv (0.3.0)
+    net-http (0.4.1)
+      uri
+    netrc (0.11.0)
+    nokogiri (1.16.6-arm64-darwin)
+      racc (~> 1.4)
+    notiffany (0.1.3)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    open_router (0.3.3)
+      activesupport (>= 6.0)
+      dotenv (>= 2)
+      faraday (>= 1)
+      faraday-multipart (>= 1)
     parallel (1.24.0)
     parser (3.3.0.5)
       ast (~> 2.4.1)
       racc
+    prism (0.30.0)
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
     racc (1.7.3)
     rainbow (3.1.1)
     rake (13.2.0)
+    rb-fsevent (0.11.2)
+    rb-inotify (0.11.1)
+      ffi (~> 1.0)
+    rbi (0.1.13)
+      prism (>= 0.18.0, < 1.0.0)
+      sorbet-runtime (>= 0.5.9204)
+    rbs (2.8.4)
     regexp_parser (2.9.0)
+    reverse_markdown (2.1.1)
+      nokogiri
     rexml (3.2.6)
     rspec (3.13.0)
       rspec-core (~> 3.13.0)
@@ -45,17 +135,82 @@ GEM
       unicode-display_width (>= 2.4.0, < 3.0)
     rubocop-ast (1.31.2)
       parser (>= 3.3.0.4)
+    ruby-openai (7.1.0)
+      event_stream_parser (>= 0.3.0, < 2.0.0)
+      faraday (>= 1)
+      faraday-multipart (>= 1)
     ruby-progressbar (1.13.0)
+    shellany (0.0.1)
+    solargraph (0.50.0)
+      backport (~> 1.2)
+      benchmark
+      bundler (~> 2.0)
+      diff-lcs (~> 1.4)
+      e2mmap
+      jaro_winkler (~> 1.5)
+      kramdown (~> 2.3)
+      kramdown-parser-gfm (~> 1.1)
+      parser (~> 3.0)
+      rbs (~> 2.0)
+      reverse_markdown (~> 2.0)
+      rubocop (~> 1.38)
+      thor (~> 1.0)
+      tilt (~> 2.0)
+      yard (~> 0.9, >= 0.9.24)
+    solargraph-rails (0.2.2.pre.4)
+      activesupport
+      solargraph (>= 0.41.1)
+    sorbet (0.5.11447)
+      sorbet-static (= 0.5.11447)
+    sorbet-runtime (0.5.11447)
+    sorbet-static (0.5.11447-universal-darwin)
+    sorbet-static-and-runtime (0.5.11447)
+      sorbet (= 0.5.11447)
+      sorbet-runtime (= 0.5.11447)
+    spoom (1.3.2)
+      erubi (>= 1.10.0)
+      prism (>= 0.19.0)
+      sorbet-static-and-runtime (>= 0.5.10187)
+      thor (>= 0.19.2)
+    tapioca (0.14.4)
+      bundler (>= 2.2.25)
+      netrc (>= 0.11.0)
+      parallel (>= 1.21.0)
+      rbi (>= 0.1.4, < 0.2)
+      sorbet-static-and-runtime (>= 0.5.11087)
+      spoom (>= 1.2.0)
+      thor (>= 1.2.0)
+      yard-sorbet
+    thor (1.3.1)
+    tilt (2.3.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
     unicode-display_width (2.5.0)
+    uri (0.13.0)
+    yard (0.9.36)
+    yard-sorbet (0.8.1)
+      sorbet-runtime (>= 0.5)
+      yard (>= 0.9)
 
 PLATFORMS
   arm64-darwin-21
 
 DEPENDENCIES
+  activesupport (>= 6.0)
+  dotenv (>= 2)
+  faraday-retry
+  guard
+  guard-rspec
+  open_router (~> 0.3)
+  pry (>= 0.14)
   raix!
   rake (~> 13.0)
   rspec (~> 3.0)
   rubocop (~> 1.21)
+  ruby-openai (~> 7.0)
+  solargraph-rails (~> 0.2.0.pre)
+  sorbet
+  tapioca
 
 BUNDLED WITH
    2.4.12

data/README.md

@@ -1,34 +1,233 @@
-# Raix
+# Ruby AI eXtensions
 
-TODO: Delete this and the text below, and describe your gem
+## What's Raix
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/raix`. To experiment with that code, run `bin/console` for an interactive prompt.
+Raix (pronounced "ray" because the x is silent) is a library that gives you everything you need to add discrete large-language model (LLM) AI components to your Ruby applications. Raix consists of proven code that has been extracted from [Olympia](https://olympia.chat), the world's leading virtual AI team platform, and probably one of the biggest and most successful AI chat projects written completely in Ruby.
 
-## Installation
+Understanding the how to use discrete AI components in otherwise normal code is key to productively leveraging Raix, and the subject of a book written by Raix's author Obie Fernandez, titled [Patterns of Application Development Using AI](https://leanpub.com/patterns-of-application-development-using-ai). You can easily support the ongoing development of this project by buying the book at Leanpub.
+
+At the moment, Raix natively supports use of either OpenAI or OpenRouter as its underlying AI provider. Eventually you will be able to specify your AI provider via an adapter, kind of like ActiveRecord maps to databases. Note that you can also use Raix to add AI capabilities to non-Rails applications as long as you include ActiveSupport as a dependency. Extracting the base code to its own standalone library without Rails dependencies is on the roadmap, but not a high priority.
+
+### Chat Completions
+
+Raix consists of three modules that can be mixed in to Ruby classes to give them AI powers. The first (and mandatory) module is `ChatCompletion`, which provides `transcript` and `chat_completion` methods.
+
+```ruby
+class MeaningOfLife
+  include Raix::ChatCompletion
+end
+
+>> ai = MeaningOfLife.new
+>> ai.transcript << { user: "What is the meaning of life?" }
+>> ai.chat_completion
+
+=> "The question of the meaning of life is one of the most profound and enduring inquiries in philosophy, religion, and science.
+    Different perspectives offer various answers..."
+
+```
+
+#### Transcript Format
+
+The transcript accepts both abbreviated and standard OpenAI message hash formats. The abbreviated format, suitable for system, assistant, and user messages is simply a mapping of `role => content`, as show in the example above.
+
+```ruby
+transcript << { user: "What is the meaning of life?" }
+```
+
+As mentioned, Raix also understands standard OpenAI messages hashes. The previous example could be written as:
+
+```ruby
+transcript << { role: "user", content: "What is the meaning of life?" }
+```
+
+One of the advantages of OpenRouter and the reason that it is used by default by this library is that it handles mapping message formats from the OpenAI standard to whatever other model you're wanting to use (Anthropic, Cohere, etc.)
+
+### Use of Tools/Functions
+
+The second (optional) module that you can add to your Ruby classes after `ChatCompletion` is `FunctionDispatch`. It lets you declare and implement functions to be called at the AI's discretion as part of a chat completion "loop" in a declarative, Rails-like "DSL" fashion.
+
+Most end-user facing AI components that include functions should be invoked using `chat_completion(loop: true)`, so that the results of each function call are added to the transcript and chat completion is triggered again. The looping will continue until the AI generates a plain text response.
+
+```ruby
+class WhatIsTheWeather
+  include Raix::ChatCompletion
+  include Raix::FunctionDispatch
+
+  function :check_weather, "Check the weather for a location", location: { type: "string" } do |arguments|
+    "The weather in #{arguments[:location]} is hot and sunny"
+  end
+end
+
+RSpec.describe WhatIsTheWeather do
+  subject { described_class.new }
+
+  it "can call a function and loop to provide text response" do
+    subject.transcript << { user: "What is the weather in Zipolite, Oaxaca?" }
+    response = subject.chat_completion(openai: "gpt-4o", loop: true)
+    expect(response).to include("hot and sunny")
+  end
+end
+```
+
+#### Manually Stopping a Loop
+
+To loop AI components that don't interact with end users, at least one function block should invoke `stop_looping!` whenever you're ready to stop processing.
+
+```ruby
+class OrderProcessor
+  include Raix::ChatCompletion
+  include Raix::FunctionDispatch
+
+  SYSTEM_DIRECTIVE = "You are an order processor, tasked with order validation, inventory check,
+                      payment processing, and shipping."
+
+  attr_accessor :order
+
+  def initialize(order)
+    self.order = order
+    transcript << { system: SYSTEM_DIRECTIVE }
+    transcript << { user: order.to_json }
+  end
+
+  def perform
+    # will continue looping until `stop_looping!` is called
+    chat_completion(loop: true)
+  end
+
+
+  # implementation of functions that can be called by the AI
+  # entirely at its discretion, depending on the needs of the order.
+  # The return value of each `perform` method will be added to the
+  # transcript of the conversation as a function result.
+
+  function :validate_order do
+    OrderValidationWorker.perform(@order)
+  end
+
+  function :check_inventory do
+    InventoryCheckWorker.perform(@order)
+  end
+
+  function :process_payment do
+    PaymentProcessingWorker.perform(@order)
+  end
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+  function :schedule_shipping do
+    ShippingSchedulerWorker.perform(@order)
+  end
+
+  function :send_confirmation do
+    OrderConfirmationWorker.perform(@order)
+  end
+
+  function :finished_processing do
+    order.update!(transcript:, processed_at: Time.current)
+    stop_looping!
+  end
+end
+```
+
+### Prompt Declarations
+
+The third (also optional) module that you can add mix in along with `ChatCompletion` is `PromptDeclarations`. It provides the ability to declare a "Prompt Chain" (series of prompts to be called in a sequence), and also features a declarative, Rails-like "DSL" of its own. Prompts can be defined inline or delegate to callable prompt objects, which themselves implement `ChatCompletion`.
+
+The following example is a rough excerpt of the main "Conversation Loop" in Olympia, which pre-processes user messages to check for
+the presence of URLs and scan memory before submitting as a prompt to GPT-4. Note that prompt declarations are executed in the order
+that they are declared. The `FetchUrlCheck` callable prompt class is included for instructional purposes. Note that it is passed the
+an instance of the object that is calling it in its initializer as its `context`. The passing of context means that you can assemble
+composite prompt structures of arbitrary depth.
+
+```ruby
+class PromptSubscriber
+  include Raix::ChatCompletion
+  include Raix::PromptDeclarations
+
+  attr_accessor :conversation, :bot_message, :user_message
+
+  # many other declarations ommitted...
+
+  prompt call: FetchUrlCheck
+
+  prompt call: MemoryScan
+
+  prompt text: -> { user_message.content }, stream: -> { ReplyStream.new(self) }, until: -> { bot_message.complete? }
+
+  def initialize(conversation)
+    self.conversation = conversation
+  end
+
+  def message_created(user_message)
+    self.user_message = user_message
+    self.bot_message = conversation.bot_message!(responding_to: user_message)
+
+    chat_completion(loop: true, openai: "gpt-4o")
+  end
+
+  ...
+
+end
+
+class FetchUrlCheck
+  include ChatCompletion
+  include FunctionDispatch
+
+  REGEX = %r{\b(?:http(s)?://)?(?:www\.)?[a-zA-Z0-9-]+(\.[a-zA-Z]{2,})+(/[^\s]*)?\b}
+
+  attr_accessor :context, :conversation
+
+  delegate :user_message, to: :context
+  delegate :content, to: :user_message
+
+  def initialize(context)
+    self.context = context
+    self.conversation = context.conversation
+    self.model = "anthropic/claude-3-haiku"
+  end
+
+  def call
+    return unless content&.match?(REGEX)
+
+    transcript << { system: "Call the `fetch` function if the user mentions a website, otherwise say nil" }
+    transcript << { user: content }
+
+    chat_completion # TODO: consider looping to fetch more than one URL per user message
+  end
+
+  function :fetch, "Gets the plain text contents of a web page", url: { type: "string" } do |arguments|
+    Tools::FetchUrl.fetch(arguments[:url]).tap do |result|
+      parent = conversation.function_call!("fetch_url", arguments, parent: user_message)
+      conversation.function_result!("fetch_url", result, parent:)
+    end
+  end
+
+```
+
+Notably, Olympia does not use the `FunctionDispatch` module in its primary conversation loop because it does not have a fixed set of tools that are included in every single prompt. Functions are made available dynamically based on a number of factors including the user's plan tier and capabilities of the assistant with whom the user is conversing.
+
+Streaming of the AI's response to the end user is handled by the `ReplyStream` class, passed to the final prompt declaration as its `stream` parameter. [Patterns of Application Development Using AI](https://leanpub.com/patterns-of-application-development-using-ai) devotes a whole chapter to describing how to write your own `ReplyStream` class.
+
+## Installation
 
 Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+    $ bundle add raix
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+    $ gem install raix
 
-## Usage
-
-TODO: Write usage instructions here
 
 ## 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.
 
+Specs require `OR_ACCESS_TOKEN` and `OAI_ACCESS_TOKEN` environment variables, for access to OpenRouter and OpenAI, respectively. You can add those keys to a local unversionsed `.env` file and they will be picked up by the `dotenv` gem.
+
 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/[USERNAME]/raix. 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/[USERNAME]/raix/blob/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/[OlympiaAI]/raix. 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/[OlympiaAI]/raix/blob/main/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -36,4 +235,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Raix project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/raix/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the Raix::Rails project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[OlympiaAI]/raix/blob/main/CODE_OF_CONDUCT.md).

data/lib/raix/version.rb

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

data/lib/raix.rb

@@ -1,8 +1,54 @@
 # frozen_string_literal: true
 
 require_relative "raix/version"
+require_relative "raix/chat_completion"
+require_relative "raix/function_dispatch"
+require_relative "raix/prompt_declarations"
 
+# The Raix module provides configuration options for the Raix gem.
 module Raix
-  class Error < StandardError; end
-  # Your code goes here...
+  # The Configuration class holds the configuration options for the Raix gem.
+  class Configuration
+    # The temperature option determines the randomness of the generated text.
+    # Higher values result in more random output.
+    attr_accessor :temperature
+
+    # The max_tokens option determines the maximum number of tokens to generate.
+    attr_accessor :max_tokens
+
+    # The model option determines the model to use for text generation. This option
+    # is normally set in each class that includes the ChatCompletion module.
+    attr_accessor :model
+
+    # The openrouter_client option determines the default client to use for communicatio.
+    attr_accessor :openrouter_client
+
+    # The openai_client option determines the OpenAI client to use for communication.
+    attr_accessor :openai_client
+
+    DEFAULT_MAX_TOKENS = 1000
+    DEFAULT_MODEL = "meta-llama/llama-3-8b-instruct:free"
+    DEFAULT_TEMPERATURE = 0.0
+
+    # Initializes a new instance of the Configuration class with default values.
+    def initialize
+      self.temperature = DEFAULT_TEMPERATURE
+      self.max_tokens = DEFAULT_MAX_TOKENS
+      self.model = DEFAULT_MODEL
+    end
+  end
+
+  class << self
+    attr_writer :configuration
+  end
+
+  # Returns the current configuration instance.
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Configures the Raix gem using a block.
+  def self.configure
+    yield(configuration)
+  end
 end

data/raix.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary = "Ruby AI eXtensions"
   spec.homepage = "https://github.com/OlympiaAI/raix"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.2.1"
+  spec.required_ruby_version = ">= 3.2.2"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/OlympiaAI/raix"
@@ -28,9 +28,6 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.add_dependency "activesupport", ">= 6.0"
+  spec.add_dependency "open_router", "~> 0.2"
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: raix
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Obie Fernandez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-03 00:00:00.000000000 Z
-dependencies: []
+date: 2024-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: open_router
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 description:
 email:
 - obiefernandez@gmail.com
@@ -45,14 +73,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.1
+      version: 3.2.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Ruby AI eXtensions