ai-engine 0.0.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89ab47c148d5272931c77599504db1420eb055f51d66f090d2784f644cdb5c69
-  data.tar.gz: 642226bca65ab4c69598f0e4fb06557d17c9c9e41bde0588ff91ed6006e58f93
+  metadata.gz: 02cef4cd33bb5b92f49695151fa4aa9e4004c9b5383745a977f3a9dfe0e46838
+  data.tar.gz: 8f01799a009e77481da633e93c9e2a6a73101ca0c2c98004a34bdb6ecc42152b
 SHA512:
-  metadata.gz: c92718c7dbba980c2bc83bc813e8e8ddd4a7679f05a0632bacf913bdcf60afccf73d33a66effec8db920721ed9f146aa1db89bdb1b1b0fe526b6ddabece0b5c1
-  data.tar.gz: 182803f6b450d3b7cf205f6f7eccd5a3f45f99dd2766bd970d0e491199de8187b7ddbf15e493ee4e694dfb5ced7da68b78c0adbf08890ea22801ab7839e9e5aa
+  metadata.gz: a4e1801c40ba227499902b2475cd5ff06097c3d51eb3d26f417bb62e1ca17da7786934815fa251298bd62b8d066a44a574aee9073f213d2b53e4d18423edc1eb
+  data.tar.gz: 1b9960397d6bf0f234272aa21dc3780740f33de76dc39ce030d737a9cf45ec538c559d5401d362db5daafad528898a18fac86e7532a8f04f00471455c1750eb1

data/README.md

@@ -1,13 +1,65 @@
-# (Placeholder) AI::Engine
+# AI::Engine
 
-AI::Engine is a private gem - this placeholder is registered to avoid a bad actor making a public gem with the same name, which could contain malicious code.
+AI::Engine is the fastest way to get AI Assistants into your Rails app! It's a Rails Engine which sets up everything you need to start streaming from OpenAI Assistants in your Rails app.
+
+Full docs can be found at [RailsAI.com](https://railsai.com/docs/installation).
+
+A demo app can be found [here](https://github.com/alexrudall/ai-engine-starter-kit/).
+
+## Usage
+
+You can add AI::Engine to your Gemfile like this:
+
+```
+gem "ai-engine", "~> 0.3.0"
+```
+
+You then need to add the migrations for the gem:
 
 ```
-source 'AI::Engine source' do
-  gem 'ai-engine'
-end
+bundle exec rails ai_engine:install:migrations
+```
+
+And run them:
+
+```
+bundle exec rails db:migrate
+```
+
+Full docs can be found at [RailsAI.com](https://railsai.com/docs/installation).
+
+## Engine Development
+
+### Test local version in a Rails app
+
+```bash
+gem "ai-engine", path: "../ai-engine"
 ```
 
-You must have the source command above to prevent downloading this placeholder.
+### ENV
+
+The dummy app needs a .env file in the root of the engine for manual and RSpec testing - see .env.example.
+
+### Dummy app
+
+Run the dummy app from the root of the project with `bin/dev` in one tab and `bin/rails s` in another (so debugger will work).
+
+### Tests
+
+Run the tests from the root of the project with `rspec`.
+
+### VCR
+
+AI::Engine uses VCR to record HTTP requests and responses. By default, specs are run against recorded 'cassette' fixtures.
+
+Set OPENAI_ACCESS_TOKEN= in your .env file to run the specs against a live API and re-record all cassettes - this will cost you money!
+
+### Release
+
+First run the specs without VCR so they actually hit the API. This will cost 2 cents or more. Set OPENAI_ACCESS_TOKEN in your environment or pass it in like this:
+
+```
+OPENAI_ACCESS_TOKEN=123abc bundle exec rspec
+```
 
-You can find the real AI::Engine and documentation at [insertrobot.com](https://insertrobot.com)!
+Then update the version number in `version.rb`, update `CHANGELOG.md`, run `bundle install` to update Gemfile.lock, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

data/Rakefile

@@ -1,2 +1,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
 require "bundler/gem_tasks"
-task :default => :spec

data/app/models/ai/engine/application_record.rb

@@ -0,0 +1,7 @@
+module AI
+  module Engine
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/app/models/ai/engine/assistant.rb

@@ -0,0 +1,15 @@
+module AI::Engine
+  class Assistant < ApplicationRecord
+    include RemoteIdValidatable
+
+    MIN_PROMPT_TOKENS = 256
+    MIN_COMPLETION_TOKENS = 16
+
+    belongs_to :assistable, polymorphic: true
+    has_many :runs, class_name: "AI::Engine::Run", foreign_key: "ai_engine_assistant_id", dependent: :nullify
+
+    def to_partial_path
+      "assistants/assistant"
+    end
+  end
+end

data/app/models/ai/engine/assistant_thread.rb

@@ -0,0 +1,32 @@
+module AI::Engine
+  class AssistantThread < ApplicationRecord
+    include RemoteIdValidatable
+
+    belongs_to :threadable, polymorphic: true
+    has_many :runs, class_name: "AI::Engine::Run", foreign_key: "ai_engine_assistant_thread_id", dependent: :nullify
+    has_many :messages, as: :messageable, class_name: "AI::Engine::Message", foreign_key: "messageable_id", dependent: :nullify
+
+    before_create :create_openai_thread
+
+    def run(assistant_id:, content:)
+      # Create the request Message, locally and remotely on OpenAI.
+      AI::Engine::Message.create(messageable: self, content: content, role: "user")
+
+      # Run the Thread using the selected Assistant.
+      runs.create(ai_engine_assistant_id: assistant_id)
+    end
+
+    def to_partial_path
+      "assistant_threads/assistant_thread"
+    end
+
+    private
+
+    def create_openai_thread
+      self.remote_id = AI::Engine::OpenAI::Threads::Create.call
+    rescue Faraday::Error => e
+      errors.add(:base, e.message)
+      throw(:abort)
+    end
+  end
+end

data/app/models/ai/engine/chat.rb

@@ -0,0 +1,45 @@
+module AI::Engine
+  class Chat < ApplicationRecord
+    belongs_to :chattable, polymorphic: true
+    has_many :messages, as: :messageable, class_name: "AI::Engine::Message", foreign_key: "messageable_id", dependent: :nullify
+
+    def run(model:)
+      # Run the Chat, sending the complete message history to OpenAI.
+      AI::Engine::OpenAI::Chats::Stream.call(chat_id: id, stream: stream(model: model), model: model)
+    end
+
+    def messages_for_openai
+      messages.order(:created_at).map do |message|
+        {
+          role: message.role,
+          content: message.content
+        }
+      end.filter { |message| message[:content].present? }
+    end
+
+    def stream(model:)
+      response_message = messages.create(
+        role: "assistant",
+        content: "",
+        model: model
+      )
+
+      proc do |chunk, _bytesize|
+        if chunk["object"] == "chat.completion.chunk"
+          new_content = chunk.dig("choices", 0, "delta", "content")
+          response_message.update(content: response_message.content + new_content) if new_content
+        end
+        if chunk["usage"]
+          response_message.update(
+            prompt_token_usage: chunk.dig("usage", "prompt_tokens"),
+            completion_token_usage: chunk.dig("usage", "completion_tokens")
+          )
+        end
+      end
+    end
+
+    def to_partial_path
+      "chats/chat"
+    end
+  end
+end

data/app/models/ai/engine/message.rb

@@ -0,0 +1,73 @@
+module AI::Engine
+  class Message < ApplicationRecord
+    include RemoteIdValidatable
+
+    belongs_to :messageable, polymorphic: true # AI::Engine::Chat or AI::Engine::AssistantThread
+    belongs_to :run, class_name: "AI::Engine::Run", foreign_key: "ai_engine_run_id", optional: true
+
+    enum role: {system: 0, assistant: 10, user: 20}
+
+    before_create :create_openai_message,
+      if: -> { in_assistant_thread? }, # Chat messages are only stored locally.
+      unless: -> { assistant? } # Checking the role - assistant messages on the OpenAI side are created by a Run.
+    after_create :on_create
+    after_update :on_update
+
+    def input_cost
+      return unless assistant?
+
+      return unless prompt_token_usage.present? && model.present?
+
+      (prompt_token_usage.to_i * AI::Engine::DOLLAR_COST_PER_1K_TOKENS[model]["input"] / 1000).round(4)
+    end
+
+    def output_cost
+      return unless assistant?
+
+      return unless completion_token_usage.present? && model.present?
+
+      (completion_token_usage.to_i * AI::Engine::DOLLAR_COST_PER_1K_TOKENS[model]["output"] / 1000).round(4)
+    end
+
+    def user
+      in_chat? ? messageable.chattable : messageable.threadable
+    end
+
+    def in_chat?
+      messageable.is_a?(AI::Engine::Chat)
+    end
+
+    def in_assistant_thread?
+      messageable.is_a?(AI::Engine::AssistantThread)
+    end
+
+    def on_create
+      if in_chat?
+        messageable.chattable.ai_engine_on_message_create(message: self)
+      else
+        messageable.threadable.ai_engine_on_message_create(message: self)
+      end
+    end
+
+    def on_update
+      if in_chat?
+        messageable.chattable.ai_engine_on_message_update(message: self)
+      else
+        messageable.threadable.ai_engine_on_message_update(message: self)
+      end
+    end
+
+    def to_partial_path
+      "messages/message"
+    end
+
+    private
+
+    def create_openai_message
+      self.remote_id = AI::Engine::OpenAI::Messages::Create.call(thread_id: messageable.remote_id, content: content, role: role)
+    rescue Faraday::Error => e
+      errors.add(:base, e.message)
+      throw(:abort)
+    end
+  end
+end

data/app/models/ai/engine/run.rb

@@ -0,0 +1,58 @@
+module AI::Engine
+  class Run < ApplicationRecord
+    include AI::Engine::RemoteIdValidatable
+
+    belongs_to :assistant, class_name: "AI::Engine::Assistant", foreign_key: "ai_engine_assistant_id"
+    belongs_to :assistant_thread, class_name: "AI::Engine::AssistantThread", foreign_key: "ai_engine_assistant_thread_id"
+    has_many :messages, class_name: "AI::Engine::Message", foreign_key: "ai_engine_run_id", dependent: :nullify
+
+    after_create :create_openai_run
+
+    def to_partial_path
+      "runs/run"
+    end
+
+    private
+
+    def create_openai_run
+      AI::Engine::OpenAI::Runs::Create.call(
+        assistant_id: assistant.remote_id,
+        thread_id: assistant_thread.remote_id,
+        stream: stream
+      )
+    rescue Faraday::Error => e
+      errors.add(:base, e.message)
+      throw(:abort)
+    end
+
+    def stream
+      response_message = assistant_thread.messages.create(
+        ai_engine_run_id: id,
+        model: assistant.assistable.model,
+        role: "assistant",
+        content: ""
+      )
+      proc do |chunk, _bytesize|
+        if chunk["object"] == "thread.message.delta"
+          new_content = chunk.dig("delta", "content", 0, "text", "value")
+          response_message.update(content: response_message.content + new_content) if new_content
+        elsif chunk["status"] == "completed"
+          if chunk["run_id"].present? && !remote_id.present?
+            update(remote_id: chunk["run_id"])
+            remote_run = AI::Engine::OpenAI::Runs::Retrieve.call(remote_id: chunk["run_id"], thread_id: assistant_thread.remote_id)
+            if remote_run.present?
+              response_message.update(
+                prompt_token_usage: remote_run.dig("usage", "prompt_tokens"),
+                completion_token_usage: remote_run.dig("usage", "completion_tokens")
+              )
+            end
+          end
+
+          if chunk["id"].present? && chunk["id"].start_with?(AI::Engine::Message.remote_id_prefix) && !response_message.remote_id.present?
+            response_message.update(remote_id: chunk["id"])
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/ai/engine/assistable.rb

@@ -0,0 +1,48 @@
+module AI
+  module Engine
+    module Assistable
+      extend ActiveSupport::Concern
+
+      included do
+        has_one :assistant, as: :assistable, class_name: "AI::Engine::Assistant"
+
+        before_create :create_openai_assistant
+        before_update :update_openai_assistant
+
+        # Default. Override in including model to customize.
+        def ai_engine_assistant
+          Logger.new($stdout).info("ai_engine_assistant called - add `def ai_engine_assistant` to your #{self.class.name} model to define the Assistant params. The method should return a Hash of: {name:, model:, description:, instructions:}.")
+          {
+            name: "Assistant for #{self.class.name} #{id}",
+            model: AI::Engine::MODEL_OPTIONS.first,
+            description: "Assistant for #{self.class.name} #{id}",
+            instructions: "Assistant for #{self.class.name} #{id}"
+          }
+        end
+
+        def ai_engine_run(assistant_thread:, content:)
+          assistant_thread.run(assistant_id: assistant.id, content: content)
+        end
+
+        private
+
+        def create_openai_assistant
+          build_assistant
+          begin
+            assistant.remote_id = AI::Engine::OpenAI::Assistants::Create.call(ai_engine_assistant)
+          rescue Faraday::Error => e
+            errors.add(:base, e.message)
+            throw(:abort)
+          end
+        end
+
+        def update_openai_assistant
+          AI::Engine::OpenAI::Assistants::Update.call(remote_id: assistant&.remote_id, parameters: ai_engine_assistant)
+        rescue Faraday::Error => e
+          errors.add(:base, e.message)
+          throw(:abort)
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/ai/engine/chattable.rb

@@ -0,0 +1,23 @@
+module AI
+  module Engine
+    module Chattable
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :chats, as: :chattable, class_name: "AI::Engine::Chat"
+
+        def ai_engine_on_message_create(message:)
+          # This is a hook for the AI Engine to notify the Chattable that a Message has been updated.
+          # Override this method in your Chattable model to handle the event.
+          Logger.new($stdout).info("ai_engine_on_message_create called - add `def ai_engine_on_message_create(message:)` to your Chattable model to handle this event.")
+        end
+
+        def ai_engine_on_message_update(message:)
+          # This is a hook for the AI Engine to notify the Chattable that a Message has been updated.
+          # Override this method in your Chattable model to handle the event.
+          Logger.new($stdout).info("ai_engine_on_message_update called - add `def ai_engine_on_message_update(message:)` to your Chattable model to handle this event.")
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/ai/engine/remote_id_validatable.rb

@@ -0,0 +1,32 @@
+module AI
+  module Engine
+    module RemoteIdValidatable
+      extend ActiveSupport::Concern
+
+      REMOTE_ID_PREFIXES = {
+        run: "run_",
+        message: "msg_",
+        assistant: "asst_",
+        assistant_thread: "thread_"
+      }.freeze
+
+      included do
+        # Validate the remote_id format is correct.
+        validate :remote_id_format
+
+        def remote_id_format
+          prefix = self.class.remote_id_prefix
+          return if remote_id.nil? || remote_id.start_with?(prefix)
+
+          errors.add(:remote_id, "ID '#{remote_id}' must start with '#{prefix}'")
+        end
+      end
+
+      class_methods do
+        def remote_id_prefix
+          REMOTE_ID_PREFIXES[name.demodulize.underscore.to_sym]
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/ai/engine/threadable.rb

@@ -0,0 +1,23 @@
+module AI
+  module Engine
+    module Threadable
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :assistant_threads, as: :threadable, class_name: "AI::Engine::AssistantThread"
+
+        def ai_engine_on_message_create(message:)
+          # This is a hook for the AI Engine to notify the AssistantThreadtable that a Message has been updated.
+          # Override this method in your AssistantThreadtable model to handle the event.
+          Logger.new($stdout).info("ai_engine_on_message_create called - add `def ai_engine_on_message_create(message:)` to your Threadable model to handle this event.")
+        end
+
+        def ai_engine_on_message_update(message:)
+          # This is a hook for the AI Engine to notify the AssistantThreadtable that a Message has been updated.
+          # Override this method in your AssistantThreadtable model to handle the event.
+          Logger.new($stdout).info("ai_engine_on_message_update called - add `def ai_engine_on_message_update(message:)` to your Threadable model to handle this event.")
+        end
+      end
+    end
+  end
+end

data/app/services/ai/engine/openai/assistants/create.rb

@@ -0,0 +1,20 @@
+class AI::Engine::OpenAI::Assistants::Create
+  # Creates a new Assistant on the OpenAI API.
+  # Returns the OpenAI ID of the new Assistant.
+  def self.call(parameters)
+    response = client.assistants.create(
+      parameters: parameters
+    )
+
+    response["id"]
+  end
+
+  private_class_method def self.client
+    @client ||= OpenAI::Client.new(
+      access_token: AI::Engine::Engine.config.openai_access_token,
+      organization_id: AI::Engine::Engine.config.openai_organization_id,
+      log_errors: Rails.env.development? || Rails.env.test?,
+      request_timeout: 2.minutes.to_i
+    )
+  end
+end

data/app/services/ai/engine/openai/assistants/retrieve.rb

@@ -0,0 +1,15 @@
+class AI::Engine::OpenAI::Assistants::Retrieve
+  # Retrieves an OpenAI Assistant by its ID.
+  def self.call(remote_id:)
+    client.assistants.retrieve(id: remote_id)
+  end
+
+  private_class_method def self.client
+    @client ||= OpenAI::Client.new(
+      access_token: AI::Engine::Engine.config.openai_access_token,
+      organization_id: AI::Engine::Engine.config.openai_organization_id,
+      log_errors: Rails.env.development? || Rails.env.test?,
+      request_timeout: 2.minutes.to_i
+    )
+  end
+end

data/app/services/ai/engine/openai/assistants/update.rb

@@ -0,0 +1,20 @@
+class AI::Engine::OpenAI::Assistants::Update
+  # Updates an OpenAI Assistant with the given parameters.
+  def self.call(remote_id:, parameters:)
+    parameters = parameters.compact
+
+    client.assistants.modify(
+      id: remote_id,
+      parameters: parameters
+    )
+  end
+
+  private_class_method def self.client
+    @client ||= OpenAI::Client.new(
+      access_token: AI::Engine::Engine.config.openai_access_token,
+      organization_id: AI::Engine::Engine.config.openai_organization_id,
+      log_errors: Rails.env.development? || Rails.env.test?,
+      request_timeout: 2.minutes.to_i
+    )
+  end
+end

data/app/services/ai/engine/openai/chats/stream.rb

@@ -0,0 +1,24 @@
+class AI::Engine::OpenAI::Chats::Stream
+  # Gets the next message response to a set of messages.
+  def self.call(chat_id:, stream:, model:)
+    chat = AI::Engine::Chat.find(chat_id)
+
+    client.chat(
+      parameters: {
+        model: model,
+        messages: chat.messages_for_openai,
+        stream: stream,
+        stream_options: {include_usage: true}
+      }
+    )
+  end
+
+  private_class_method def self.client
+    @client ||= OpenAI::Client.new(
+      access_token: AI::Engine::Engine.config.openai_access_token,
+      organization_id: AI::Engine::Engine.config.openai_organization_id,
+      log_errors: Rails.env.development? || Rails.env.test?,
+      request_timeout: 2.minutes.to_i
+    )
+  end
+end

data/app/services/ai/engine/openai/messages/create.rb

@@ -0,0 +1,23 @@
+class AI::Engine::OpenAI::Messages::Create
+  # Gets the OpenAI ID of a new Message.
+  def self.call(thread_id:, content:, role:)
+    response = client.messages.create(
+      thread_id: thread_id,
+      parameters: {
+        content: content,
+        role: role
+      }
+    )
+
+    response["id"]
+  end
+
+  private_class_method def self.client
+    @client ||= OpenAI::Client.new(
+      access_token: AI::Engine::Engine.config.openai_access_token,
+      organization_id: AI::Engine::Engine.config.openai_organization_id,
+      log_errors: Rails.env.development? || Rails.env.test?,
+      request_timeout: 2.minutes.to_i
+    )
+  end
+end

data/app/services/ai/engine/openai/runs/create.rb

@@ -0,0 +1,21 @@
+class AI::Engine::OpenAI::Runs::Create
+  # Creates a new Run on the OpenAI API.
+  def self.call(assistant_id:, thread_id:, stream: false)
+    client.runs.create(
+      thread_id: thread_id,
+      parameters: {
+        assistant_id: assistant_id,
+        stream: stream
+      }
+    )
+  end
+
+  private_class_method def self.client
+    @client ||= OpenAI::Client.new(
+      access_token: AI::Engine::Engine.config.openai_access_token,
+      organization_id: AI::Engine::Engine.config.openai_organization_id,
+      log_errors: Rails.env.development? || Rails.env.test?,
+      request_timeout: 2.minutes.to_i
+    )
+  end
+end

data/app/services/ai/engine/openai/runs/retrieve.rb

@@ -0,0 +1,15 @@
+class AI::Engine::OpenAI::Runs::Retrieve
+  # Retrieves an OpenAI Run by its ID.
+  def self.call(remote_id:, thread_id:)
+    client.runs.retrieve(id: remote_id, thread_id: thread_id)
+  end
+
+  private_class_method def self.client
+    @client ||= OpenAI::Client.new(
+      access_token: AI::Engine::Engine.config.openai_access_token,
+      organization_id: AI::Engine::Engine.config.openai_organization_id,
+      log_errors: Rails.env.development? || Rails.env.test?,
+      request_timeout: 2.minutes.to_i
+    )
+  end
+end

data/app/services/ai/engine/openai/threads/create.rb

@@ -0,0 +1,17 @@
+class AI::Engine::OpenAI::Threads::Create
+  # Gets the OpenAI ID of a new Thread.
+  def self.call
+    response = client.threads.create(parameters: {})
+
+    response["id"]
+  end
+
+  private_class_method def self.client
+    @client ||= OpenAI::Client.new(
+      access_token: AI::Engine::Engine.config.openai_access_token,
+      organization_id: AI::Engine::Engine.config.openai_organization_id,
+      log_errors: Rails.env.development? || Rails.env.test?,
+      request_timeout: 2.minutes.to_i
+    )
+  end
+end

data/config/initializers/inflections.rb

@@ -0,0 +1,4 @@
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.acronym "AI"
+  inflect.acronym "OpenAI"
+end

data/config/initializers/openai.rb

@@ -0,0 +1 @@
+require "openai"

data/db/migrate/20240528153439_create_ai_engine_assistants.rb

@@ -0,0 +1,12 @@
+class CreateAIEngineAssistants < ActiveRecord::Migration[7.1]
+  def change
+    create_table :ai_engine_assistants do |t|
+      t.string :remote_id
+      t.belongs_to :assistable, polymorphic: true
+
+      t.timestamps
+    end
+
+    add_index :ai_engine_assistants, %i[assistable_type assistable_id remote_id], unique: true, name: "ai_engine_assistants_unique_index"
+  end
+end

data/db/migrate/20240530121855_create_ai_engine_assistant_threads.rb

@@ -0,0 +1,10 @@
+class CreateAIEngineAssistantThreads < ActiveRecord::Migration[7.1]
+  def change
+    create_table :ai_engine_assistant_threads do |t|
+      t.string :remote_id
+      t.belongs_to :threadable, polymorphic: true
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20240530130834_create_ai_engine_runs.rb

@@ -0,0 +1,11 @@
+class CreateAIEngineRuns < ActiveRecord::Migration[7.1]
+  def change
+    create_table :ai_engine_runs do |t|
+      t.string :remote_id
+      t.references :ai_engine_assistant, foreign_key: true
+      t.references :ai_engine_assistant_thread, foreign_key: true
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20240530135629_create_ai_engine_messages.rb

@@ -0,0 +1,16 @@
+class CreateAIEngineMessages < ActiveRecord::Migration[7.1]
+  def change
+    create_table :ai_engine_messages do |t|
+      t.string :remote_id
+      t.references :ai_engine_run, foreign_key: true
+      t.references :messageable, polymorphic: true
+      t.integer :role, null: false, default: 0
+      t.string :content, null: false
+      t.string :model
+      t.integer :prompt_token_usage
+      t.integer :completion_token_usage
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20240619150010_create_ai_engine_chats.rb

@@ -0,0 +1,9 @@
+class CreateAIEngineChats < ActiveRecord::Migration[7.1]
+  def change
+    create_table :ai_engine_chats do |t|
+      t.belongs_to :chattable, polymorphic: true
+
+      t.timestamps
+    end
+  end
+end

data/lib/ai/engine/engine.rb

@@ -0,0 +1,58 @@
+module AI
+  module Engine
+    DOLLAR_COST_PER_1K_TOKENS = {
+      "gpt-3.5-turbo" => {
+        "input" => 0.0005,
+        "output" => 0.0015
+      },
+      "gpt-4" => {
+        "input" => 0.03,
+        "output" => 0.06
+      },
+      "gpt-4-turbo" => {
+        "input" => 0.01,
+        "output" => 0.03
+      },
+      "gpt-4o" => {
+        "input" => 0.005,
+        "output" => 0.015
+      }
+    }.freeze
+    MODEL_OPTIONS = DOLLAR_COST_PER_1K_TOKENS.keys.freeze
+
+    def self.setup(&)
+      Engine.setup(&)
+    end
+
+    class Engine < ::Rails::Engine
+      isolate_namespace AI::Engine
+
+      class Configuration
+        attr_accessor :openai_access_token, :openai_organization_id
+
+        def initialize
+          @openai_access_token = nil
+          @openai_organization_id = nil
+        end
+      end
+
+      config.generators do |g|
+        g.test_framework :rspec
+        g.fixture_replacement :factory_bot
+        g.factory_bot dir: "spec/factories"
+      end
+
+      def self.setup(&block)
+        @config ||= AI::Engine::Engine::Configuration.new
+
+        yield @config if block
+
+        @config
+      end
+
+      def self.config
+        @config || setup
+      end
+    end
+  end
+end

data/lib/ai/engine/version.rb

@@ -1,5 +1,5 @@
-module Ai
+module AI
   module Engine
-    VERSION = "0.0.1"
+    VERSION = "0.4.0"
   end
 end

data/lib/ai/engine.rb

@@ -1,6 +1,7 @@
 require "ai/engine/version"
+require "ai/engine/engine"
 
-module Ai
+module AI
   module Engine
     # Your code goes here...
   end

metadata

@@ -1,67 +1,74 @@
 --- !ruby/object:Gem::Specification
 name: ai-engine
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Alex Rudall
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2024-06-10 00:00:00.000000000 Z
+date: 2024-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: ruby-openai
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
-  type: :development
+        version: 7.1.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.2'
-description: You're probably looking for the real ai-engine gem at https://insertrobot.com
+        version: 7.1.0
+description: The fastest way to get AI Assistants into your Rails app!
 email:
-- alex@insertrobot.com
+- hello@alexrudall.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- Gemfile
-- LICENSE.txt
 - README.md
 - Rakefile
-- ai-engine.gemspec
-- bin/console
-- bin/setup
+- app/models/ai/engine/application_record.rb
+- app/models/ai/engine/assistant.rb
+- app/models/ai/engine/assistant_thread.rb
+- app/models/ai/engine/chat.rb
+- app/models/ai/engine/message.rb
+- app/models/ai/engine/run.rb
+- app/models/concerns/ai/engine/assistable.rb
+- app/models/concerns/ai/engine/chattable.rb
+- app/models/concerns/ai/engine/remote_id_validatable.rb
+- app/models/concerns/ai/engine/threadable.rb
+- app/services/ai/engine/openai/assistants/create.rb
+- app/services/ai/engine/openai/assistants/retrieve.rb
+- app/services/ai/engine/openai/assistants/update.rb
+- app/services/ai/engine/openai/chats/stream.rb
+- app/services/ai/engine/openai/messages/create.rb
+- app/services/ai/engine/openai/runs/create.rb
+- app/services/ai/engine/openai/runs/retrieve.rb
+- app/services/ai/engine/openai/threads/create.rb
+- config/initializers/inflections.rb
+- config/initializers/openai.rb
+- db/migrate/20240528153439_create_ai_engine_assistants.rb
+- db/migrate/20240530121855_create_ai_engine_assistant_threads.rb
+- db/migrate/20240530130834_create_ai_engine_runs.rb
+- db/migrate/20240530135629_create_ai_engine_messages.rb
+- db/migrate/20240619150010_create_ai_engine_chats.rb
 - lib/ai/engine.rb
+- lib/ai/engine/engine.rb
 - lib/ai/engine/version.rb
-homepage: https://github.com/alexrudall/ai-engine-placeholder
+homepage: https://railsai.com/docs/installation
 licenses:
 - MIT
 metadata:
-  allowed_push_host: https://rubygems.org
-post_install_message: "/!\\ ಠ‿ಠ Watch out ! This is not the real ai-engine gem - get
-  the real one from insertrobot.com! /!\\"
+  homepage_uri: https://railsai.com/docs/installation
+  source_code_uri: https://github.com/alexrudall/ai-engine/
+  changelog_uri: https://github.com/alexrudall/ai-engine/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -69,7 +76,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -79,5 +86,5 @@ requirements: []
 rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
-summary: Placeholder for the official ai-engine gem
+summary: The fastest way to get AI Assistants into your Rails app!
 test_files: []

data/.gitignore

@@ -1,9 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in ai-engine.gemspec
-gemspec

data/LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2024 Alex Rudall
-
-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/ai-engine.gemspec

@@ -1,37 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'ai/engine/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "ai-engine"
-  spec.version       = Ai::Engine::VERSION
-  spec.authors       = ["Alex Rudall"]
-  spec.email         = ["alex@insertrobot.com"]
-
-  spec.summary       = %q{Placeholder for the official ai-engine gem}
-  spec.description   = %q{You're probably looking for the real ai-engine gem at https://insertrobot.com}
-  spec.homepage      = "https://github.com/alexrudall/ai-engine-placeholder"
-  spec.license       = "MIT"
-
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # to allow pushing to a single host or delete this section to allow pushing to any host.
-  if spec.respond_to?(:metadata)
-    spec.metadata['allowed_push_host'] = "https://rubygems.org"
-  else
-    raise "RubyGems 2.0 or newer is required to protect against " \
-      "public gem pushes."
-  end
-
-  spec.post_install_message = "/!\\ ಠ‿ಠ Watch out ! This is not the real ai-engine gem - get the real one from insertrobot.com! /!\\"
-
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 2.5"
-  spec.add_development_dependency "rake", "~> 13.2"
-end

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "ai/engine"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here