Create & manage LanguageModels and APIService (+add Llama 3)

app/controllers/settings/api_services_controller.rb

@@ -0,0 +1,50 @@
+class Settings::APIServicesController < Settings::ApplicationController
+  before_action :set_api_service, only: [:edit, :update, :destroy]
+
+  def index
+    @api_services = Current.user.api_services.ordered
+  end
+
+  def edit
+  end
+
+  def new
+    @api_service = APIService.new
+  end
+
+  def create
+    @api_service = Current.user.api_services.new(api_service_params)
+
+    if @api_service.save
+      redirect_to settings_api_services_path, notice: "Saved", status: :see_other
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def update
+    if @api_service.update(api_service_params)
+      redirect_to settings_api_services_path, notice: "Saved", status: :see_other
+    else
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    @api_service.deleted!
+    redirect_to settings_api_services_path, notice: "Deleted", status: :see_other
+  end
+
+  private
+
+  def set_api_service
+    @api_service = Current.user.api_services.find_by(id: params[:id])
+    if @api_service.nil?
+      redirect_to settings_api_services_path, alert: "The API Service could not be found", status: :see_other
+    end
+  end
+
+  def api_service_params
+    params.require(:api_service).permit(:name, :url, :token, :driver)
+  end
+end

app/controllers/settings/application_controller.rb

@@ -20,8 +20,15 @@ def set_settings_menu
         |assistant| [ assistant, edit_settings_assistant_path(assistant) ]
       }.to_h.merge({
         "New Assistant": new_settings_assistant_path
-      })
+      }),
 
+      language_models: {
+        "Language Models": settings_language_models_path,
+      },
+
+      api_services: {
+        "API Services": settings_api_services_path,
+      },
     }
   end
 end

app/controllers/settings/language_models_controller.rb

@@ -0,0 +1,58 @@
+class Settings::LanguageModelsController < Settings::ApplicationController
+  before_action :set_users_language_model, only: [:edit, :update, :destroy]
+  before_action :set_system_language_model, only: [:show]
+
+  def index
+    @language_models = LanguageModel.for_user(Current.user).order(updated_at: :desc)
+  end
+
+  def edit
+  end
+
+  def show
+  end
+
+  def new
+    @language_model = LanguageModel.new
+  end
+
+  def create
+    @language_model = Current.user.language_models.new(language_model_params)
+
+    if @language_model.save
+      redirect_to settings_language_models_path, notice: "Saved", status: :see_other
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def update
+    if @language_model.update(language_model_params)
+      redirect_to settings_language_models_path, notice: "Saved", status: :see_other
+    else
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    @language_model.deleted!
+    redirect_to settings_language_models_path, notice: "Deleted", status: :see_other
+  end
+
+  private
+
+  def set_users_language_model
+    @language_model = Current.user.language_models.find_by(id: params[:id])
+    if @language_model.nil?
+      redirect_to settings_language_models_path, status: :see_other, alert: "The Language Model could not be found"
+    end
+  end
+
+  def set_system_language_model
+    @language_model = LanguageModel.where(user_id: nil).find_by(id: params[:id])
+  end
+
+  def language_model_params
+    params.require(:language_model).permit(:api_name, :name, :supports_images, :api_service_id)
+  end
+end

app/controllers/settings/people_controller.rb

@@ -16,7 +16,7 @@ def update
 
   def person_params
     h = params.require(:person).permit(:email, personable_attributes: [
-      :id, :first_name, :last_name, :password, :openai_key, :anthropic_key, preferences: [:dark_mode],
+      :id, :first_name, :last_name, :password, preferences: [:dark_mode],
       credentials_attributes: [ :id, :type, :password ]
     ]).to_h
     format_and_strip_all_but_first_valid_credential(h)

app/helpers/application_helper.rb

@@ -93,4 +93,7 @@ def viewport_tag(content)
     tag.meta(name: 'viewport', content: content)
   end
 
+  def n_a_if_blank(value, n_a = "Not Available")
+    value.blank? ? n_a : value.to_s
+  end
 end

app/helpers/settings/api_services_helper.rb

@@ -0,0 +1,15 @@
+module Settings
+  module APIServicesHelper
+    def official?(model)
+      openai?(model) && anthropic?(model)
+    end
+
+    def openai?(api_service)
+      api_service.url == APIService::URL_OPEN_AI
+    end
+
+    def anthropic?(api_service)
+      api_service.url == APIService::URL_ANTHROPIC
+    end
+  end
+end

app/helpers/settings/language_models_helper.rb

@@ -0,0 +1,7 @@
+module Settings
+  module LanguageModelsHelper
+    def display_boolean(value)
+      ActiveModel::Type::Boolean.new.cast(value) ? 'Yes' : 'No'
+    end
+  end
+end

app/jobs/autotitle_conversation_job.rb

@@ -7,8 +7,7 @@ class ConversationNotReady < StandardError; end
 
   def perform(conversation_id)
     conversation = Conversation.find(conversation_id)
-    Current.user = conversation.user
-    return false if Current.user.preferred_openai_key.blank? # should we use anthropic key if that's all the user has?
+    return false if conversation.assistant.api_service.effective_token.blank? # should we use anthropic key if that's all the user has?
 
     messages = conversation.messages.ordered.limit(4)
     raise ConversationNotReady  if messages.empty?

app/jobs/get_next_ai_message_job.rb

@@ -114,13 +114,13 @@ def self.broadcast_updated_message(message, locals = {})
   private
 
   def set_openai_error
-    @message.content_text = "(You need to enter a valid API key for OpenAI to use GPT-3.5 or GPT-4. Click your Profile in the bottom " +
-      "left and then Settings. You will find OpenAI Key instructions.)"
+    @message.content_text = "(You need to enter a valid API key for OpenAI to use GPT. Click your Profile in the bottom " +
+      "left and then Settings and then **API Services**. You will find OpenAI Key instructions.)"
   end
 
   def set_anthropic_error
     @message.content_text = "(You need to enter a valid API key for Anthropic to use Claude. Click your Profile in the bottom " +
-      "left and then Settings. You will find Anthropic Key instructions.)"
+      "left and then Settings and then **API Services**. You will find Anthropic Key instructions.)"
   end
 
   def set_response_error

app/models/api_service.rb

@@ -0,0 +1,44 @@
+class APIService < ApplicationRecord
+  URL_OPEN_AI = "https://api.openai.com/"
+  URL_ANTHROPIC = "https://api.anthropic.com/"
+
+  belongs_to :user
+
+  has_many :language_models, -> { not_deleted }
+
+  enum driver: %w[ openai anthropic ].index_by(&:to_sym)
+
+  validates :url, format: URI::DEFAULT_PARSER.make_regexp(%w[http https]), if: -> { url.present? }
+  validates :name, :url, presence: true
+
+  normalizes :url, with: -> url { url.strip }
+  encrypts :token
+
+  before_save :soft_delete_language_models, if: -> { deleted_at && deleted_at_changed? && deleted_at_was.nil? }
+
+  scope :ordered, -> { order(:name) }
+
+  def ai_backend
+    openai? ? AIBackend::OpenAI : AIBackend::Anthropic
+  end
+
+  def requires_token?
+    [URL_OPEN_AI, URL_ANTHROPIC].include?(url) # other services may require it but we don't always know
+  end
+
+  def effective_token
+    token.presence || default_llm_key
+  end
+
+  private
+
+  def default_llm_key
+    return nil unless Feature.default_llm_keys?
+    return Setting.default_openai_key if url == URL_OPEN_AI
+    return Setting.default_anthropic_key if url == URL_ANTHROPIC
+  end
+
+  def soft_delete_language_models
+    language_models.each { |language_model| language_model.deleted! }
+  end
+end

app/models/assistant.rb

@@ -10,6 +10,7 @@ class Assistant < ApplicationRecord
   has_many :messages, dependent: :destroy
 
   delegate :supports_images?, to: :language_model
+  delegate :api_service, to: :language_model
 
   belongs_to :language_model
 
@@ -18,6 +19,10 @@ class Assistant < ApplicationRecord
 
   scope :ordered, -> { order(:id) }
 
+  def delete!
+    update!(deleted_at: Time.now)
+  end
+
   def initials
     return nil if name.blank?
 

app/models/credential.rb

@@ -1,9 +1,10 @@
 class Credential < ApplicationRecord
   belongs_to :user
-  encrypts :external_id, :oauth_email, :oauth_token, :oauth_refresh_token, deterministic: true
 
   has_many :authentications, -> { not_deleted }
   has_many :authentications_including_deleted, class_name: "Authentication", inverse_of: :credential, dependent: :destroy
 
+  encrypts :external_id, :oauth_email, :oauth_token, :oauth_refresh_token, deterministic: true
+
   serialize :properties, coder: JsonSerializer
 end

app/models/language_model.rb

@@ -1,27 +1,45 @@
 # We don"t care about large or not
 class LanguageModel < ApplicationRecord
+  BEST_GPT = "gpt-best"
+  BEST_CLAUDE = "claude-best"
+
   BEST_MODELS = {
-    "gpt-best" => "gpt-4o-2024-05-13",
-    "claude-best" => "claude-3-5-sonnet-20240620"
+    BEST_GPT => "gpt-4o-2024-05-13",
+    BEST_CLAUDE => "claude-3-5-sonnet-20240620"
   }
 
+  belongs_to :user
+  belongs_to :api_service
+
+  has_many :assistants, -> { not_deleted }
+  has_many :assistants_including_deleted, class_name: "Assistant", dependent: :destroy
+
+  before_validation :populate_position, unless: :position
+
+  validates :api_name, :name, :position, presence: true
+
+  before_save :soft_delete_assistants, if: -> { deleted_at && deleted_at_changed? && deleted_at_was.nil? }
+
   scope :ordered, -> { order(:position) }
+  scope :for_user, ->(user) { where(user_id: user.id).not_deleted }
 
-  has_many :assistants
+  delegate :ai_backend, to: :api_service
 
-  def readonly?
-    !new_record?
+  def provider_name
+    BEST_MODELS[api_name] || api_name
   end
 
-  def provider_name
-    BEST_MODELS[name] || name
+  def created_by_current_user?
+    user == Current.user
+  end
+
+  private
+
+  def populate_position
+    self.position = (user&.language_models&.maximum(:position) || 0) + 1
   end
 
-  def ai_backend
-    if name.starts_with?("gpt-")
-      AIBackend::OpenAI
-    else
-      AIBackend::Anthropic
-    end
+  def soft_delete_assistants
+    assistants.update_all(deleted_at: Time.current)
   end
 end

app/models/person.rb

@@ -2,15 +2,15 @@ class Person < ApplicationRecord
   delegated_type :personable, types: %w[ User Tombstone ], dependent: :destroy
   has_many :clients, dependent: :destroy
 
-  encrypts :email, deterministic: true
-
   accepts_nested_attributes_for :personable
 
   validate :personable_id_unchanged, on: :update
   validates_associated :personable
   validates :email, presence: true, uniqueness: true, format: { with: URI::MailTo::EMAIL_REGEXP }
   validate :proper_personable_id, on: :update
 
+  encrypts :email, deterministic: true
+
   scope :ordered, -> { order(:created_at) }
 
   normalizes :email, with: -> email { email.downcase.strip }

app/models/run.rb

@@ -14,6 +14,6 @@ class Run < ApplicationRecord
   private
 
   def set_model
-    self.model = assistant&.language_model&.name
+    self.model = assistant&.language_model&.provider_name
   end
 end

app/models/user.rb

@@ -1,15 +1,15 @@
 class User < ApplicationRecord
   include Personable, Registerable
-  encrypts :openai_key, :anthropic_key
 
   has_secure_password validations: false
   has_person_name
 
-  validates :first_name, presence: true
-  validates :last_name, presence: true, on: :create
-
   has_many :assistants, -> { not_deleted }
   has_many :assistants_including_deleted, class_name: "Assistant", inverse_of: :user, dependent: :destroy
+  has_many :language_models, -> { not_deleted }
+  has_many :language_models_including_deleted, class_name: "LanguageModel", dependent: :destroy
+  has_many :api_services, -> { not_deleted }
+  has_many :api_services_including_deleted, class_name: "APIService", dependent: :destroy
   has_many :conversations, dependent: :destroy
   has_many :credentials, dependent: :destroy
   has_many :memories, dependent: :destroy
@@ -22,18 +22,13 @@ class User < ApplicationRecord
 
   belongs_to :last_cancelled_message, class_name: "Message", optional: true
 
+  validates :first_name, presence: true
+  validates :last_name, presence: true, on: :create
+
   accepts_nested_attributes_for :credentials
   serialize :preferences, coder: JsonSerializer
 
   def preferences
     attributes["preferences"].with_defaults(dark_mode: "system")
   end
-
-  def preferred_openai_key
-    self.openai_key.presence || (Feature.default_llm_keys? ? Setting.default_openai_key : nil)
-  end
-
-  def preferred_anthropic_key
-    self.anthropic_key.presence || (Feature.default_llm_keys? ? Setting.default_anthropic_key : nil)
-  end
 end