layered-assistant-rails 0.1.0

data/app/models/layered/assistant/conversation.rb

@@ -0,0 +1,39 @@
+module Layered
+  module Assistant
+    class Conversation < ApplicationRecord
+      # UID
+      has_secure_token :uid
+
+      # Associations
+      belongs_to :assistant, counter_cache: true
+      belongs_to :owner, polymorphic: true, optional: true
+      belongs_to :subject, polymorphic: true, optional: true
+      has_many :messages, dependent: :destroy
+
+      # Validations
+      validates :name, presence: true
+
+      # Scopes
+      scope :by_name, -> { order(name: :asc, created_at: :desc) }
+      scope :by_created_at, -> { order(created_at: :desc) }
+
+      # Name
+      def update_token_totals!
+        input = messages.sum(:input_tokens)
+        output = messages.sum(:output_tokens)
+        update!(input_tokens: input, output_tokens: output, token_estimate: input + output)
+      end
+
+      def self.default_name
+        "New conversation"
+      end
+
+      def update_name_from_content!(content)
+        return unless name == self.class.default_name
+        return if content.blank?
+
+        update!(name: content.truncate(60))
+      end
+    end
+  end
+end

data/app/models/layered/assistant/message.rb

@@ -0,0 +1,56 @@
+module Layered
+  module Assistant
+    class Message < ApplicationRecord
+      # Includes
+      include ActionView::RecordIdentifier
+
+      # UID
+      has_secure_token :uid
+
+      # Enums
+      enum :role, {
+        system: "system",
+        assistant: "assistant",
+        user: "user"
+      }
+
+      # Validations
+      validates :content, presence: true, unless: :assistant?
+
+      # Associations
+      belongs_to :conversation, counter_cache: true
+      belongs_to :model, optional: true, counter_cache: true
+
+      # Scopes
+      scope :by_created_at, -> { order(created_at: :asc) }
+
+      # Broadcasting
+      def broadcast_created
+        broadcast_append_to conversation,
+          targets: ".#{dom_id(conversation)}_messages",
+          partial: "layered/assistant/messages/message",
+          locals: { message: self }
+      end
+
+      def broadcast_updated
+        broadcast_replace_to conversation,
+          targets: ".#{dom_id(self)}",
+          partial: "layered/assistant/messages/message",
+          locals: { message: self }
+      end
+
+      def broadcast_chunk(text)
+        broadcast_action_to conversation,
+          action: :append_chunk,
+          targets: ".#{dom_id(self)}_body",
+          content: helpers.content_tag(:span, text, class: "l-ui-token-fade")
+      end
+
+      private
+
+      def helpers
+        ApplicationController.helpers
+      end
+    end
+  end
+end

data/app/models/layered/assistant/model.rb

@@ -0,0 +1,21 @@
+module Layered
+  module Assistant
+    class Model < ApplicationRecord
+      # Positioning
+      positioned on: :provider
+
+      # Associations
+      belongs_to :provider, counter_cache: true
+      has_many :messages, dependent: :restrict_with_error
+      has_many :assistants, foreign_key: :default_model_id, dependent: :restrict_with_error, inverse_of: :default_model
+
+      # Validations
+      validates :name, :identifier, presence: true
+
+      # Scopes
+      scope :enabled, -> { where(enabled: true) }
+      scope :available, -> { enabled.eager_load(:provider).merge(Provider.enabled).merge(Provider.sorted).sorted }
+      scope :sorted, -> { order(position: :asc, name: :asc) }
+    end
+  end
+end

data/app/models/layered/assistant/provider.rb

@@ -0,0 +1,49 @@
+module Layered
+  module Assistant
+    class Provider < ApplicationRecord
+      # Virtual attributes
+      attr_accessor :create_models
+
+      # Positioning
+      positioned
+
+      # Associations
+      has_many :models, dependent: :destroy
+      belongs_to :owner, polymorphic: true, optional: true
+
+      # Enums
+      enum :protocol, {
+        anthropic: "Anthropic",
+        openai: "OpenAI"
+      }
+
+      # Encryption
+      unless ENV["LAYERED_ASSISTANT_DANGEROUSLY_SKIP_DB_ENCRYPTION"] == "yes"
+        encrypts :secret
+      end
+
+      # Validations
+      validates :name, :protocol, presence: true
+      validates :url, format: { with: /\Ahttps?:\/\//i, message: "must start with http:// or https://" }, allow_blank: true
+
+      TEMPLATES = {
+        "Cloud" => [
+          { key: "anthropic", name: "Anthropic", description: "Claude family of models. Requires an API key.", protocol: "anthropic", url: "https://api.anthropic.com/v1", keys_url: "https://console.anthropic.com/settings/keys" },
+          { key: "openai", name: "OpenAI", description: "GPT family of models. Requires an API key.", protocol: "openai", url: "https://api.openai.com/v1", keys_url: "https://platform.openai.com/api-keys" },
+          { key: "gemini", name: "Gemini", description: "Google Gemini family of models. Requires an API key.", protocol: "openai", url: "https://generativelanguage.googleapis.com/v1beta/openai/", keys_url: "https://aistudio.google.com/api-keys" },
+          { key: "mistral", name: "Mistral", description: "Mistral's own frontier models. Requires an API key.", protocol: "openai", url: "https://api.mistral.ai/v1", keys_url: "https://admin.mistral.ai/organization/api-keys" },
+          { key: "groq", name: "Groq", description: "Low-latency inference for popular open-weight models. Requires an API key.", protocol: "openai", url: "https://api.groq.com/openai/v1", keys_url: "https://console.groq.com/keys" },
+          { key: "openrouter", name: "OpenRouter", description: "Access hundreds of models through a single API. Requires an API key.", protocol: "openai", url: "https://openrouter.ai/api/v1/", keys_url: "https://openrouter.ai/settings/keys" }
+        ],
+        "Local" => [
+          { key: "ollama", name: "Ollama", description: "Run open-weight models locally via the Ollama CLI. No API key required.", protocol: "openai", url: "http://localhost:11434/v1" },
+          { key: "lm_studio", name: "LM Studio", description: "Run open-weight models locally via the LM Studio desktop app. No API key required.", protocol: "openai", url: "http://localhost:1234/v1" }
+        ]
+      }.freeze
+
+      # Scopes
+      scope :enabled, -> { where(enabled: true) }
+      scope :sorted, -> { order(position: :asc, name: :asc) }
+    end
+  end
+end

data/app/services/layered/assistant/chunk_service.rb

@@ -0,0 +1,80 @@
+module Layered
+  module Assistant
+    class ChunkService
+      def initialize(message, provider:)
+        @message = message
+        @provider = provider
+        @input_tokens = 0
+        @output_tokens = 0
+      end
+
+      def call(chunk)
+        Rails.logger.debug { "[ChunkService] #{chunk.inspect}" }
+        text = extract_text(chunk)
+        extract_usage(chunk)
+
+        if text
+          @message.update(content: (@message.content || "") + text)
+          @message.broadcast_chunk(text)
+        end
+
+        if chunk_finished?(chunk) || usage_chunk?(chunk)
+          save_token_usage
+          @message.broadcast_updated
+        end
+      end
+
+      private
+
+      def extract_text(chunk)
+        text = if @provider.protocol == "openai"
+          chunk.dig("choices", 0, "delta", "content")
+        else
+          chunk.dig("delta", "text") if chunk["type"] == "content_block_delta"
+        end
+        text unless text.nil? || text.empty?
+      end
+
+      def chunk_finished?(chunk)
+        if @provider.protocol == "openai"
+          chunk.dig("choices", 0, "finish_reason").present?
+        else
+          chunk["type"] == "message_stop"
+        end
+      end
+
+      def usage_chunk?(chunk)
+        @provider.protocol == "openai" && chunk["usage"].present? && chunk.dig("choices")&.empty?
+      end
+
+      def extract_usage(chunk)
+        if @provider.protocol == "openai"
+          if (usage = chunk["usage"])
+            @input_tokens = usage["prompt_tokens"].to_i
+            @output_tokens = usage["completion_tokens"].to_i
+          end
+        else
+          if chunk["type"] == "message_start" && (usage = chunk.dig("message", "usage"))
+            @input_tokens = usage["input_tokens"].to_i
+          end
+          if chunk["type"] == "message_delta" && (usage = chunk["usage"])
+            @output_tokens = usage["output_tokens"].to_i
+          end
+        end
+      end
+
+      def save_token_usage
+        if @input_tokens == 0 && @output_tokens == 0
+          estimated = TokenEstimator.estimate(@message.content)
+          return unless estimated
+
+          @message.update!(output_tokens: estimated, tokens_estimated: true)
+        else
+          @message.update!(input_tokens: @input_tokens, output_tokens: @output_tokens)
+        end
+
+        @message.conversation.update_token_totals!
+      end
+    end
+  end
+end

data/app/services/layered/assistant/client_service.rb

@@ -0,0 +1,18 @@
+module Layered
+  module Assistant
+    class ClientService
+      def call(message:, stream_proc:)
+        provider = message.model.provider
+        client = Clients::Base.for(provider)
+        system_prompt = message.conversation.assistant.system_prompt
+
+        client.chat(
+          messages: message.conversation.messages,
+          model: message.model.identifier,
+          stream_proc: stream_proc,
+          system_prompt: system_prompt
+        )
+      end
+    end
+  end
+end

data/app/services/layered/assistant/clients/anthropic.rb

@@ -0,0 +1,24 @@
+module Layered
+  module Assistant
+    module Clients
+      class Anthropic < Base
+        def chat(messages:, model:, stream_proc:, system_prompt: nil)
+          formatted = MessagesService.new.format(messages, provider: @provider, system_prompt: system_prompt)
+
+          parameters = {
+            model: model,
+            messages: formatted[:messages],
+            max_tokens: 4096,
+            stream: stream_proc
+          }
+          parameters[:system] = formatted[:system] if formatted[:system].present?
+
+          ::Anthropic::Client.new(
+            access_token: @api_key,
+            log_errors: ENV.fetch("LAYERED_ASSISTANT_LOG_ERRORS", "no") == "yes"
+          ).messages(parameters: parameters)
+        end
+      end
+    end
+  end
+end

data/app/services/layered/assistant/clients/base.rb

@@ -0,0 +1,29 @@
+module Layered
+  module Assistant
+    module Clients
+      class Base
+        def initialize(provider)
+          @provider = provider
+          @api_key = provider.secret
+
+          raise StandardError, "API key is not set for provider #{provider.name}" if @api_key.blank?
+        end
+
+        def chat(messages:, model:, stream_proc:, system_prompt: nil)
+          raise NotImplementedError
+        end
+
+        def self.for(provider)
+          case provider.protocol
+          when "anthropic"
+            Clients::Anthropic.new(provider)
+          when "openai"
+            Clients::OpenAI.new(provider)
+          else
+            raise StandardError, "Unsupported provider protocol: #{provider.protocol}"
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/layered/assistant/clients/openai.rb

@@ -0,0 +1,33 @@
+module Layered
+  module Assistant
+    module Clients
+      class OpenAI < Base
+        def chat(messages:, model:, stream_proc:, system_prompt: nil)
+          formatted = MessagesService.new.format(messages, provider: @provider, system_prompt: system_prompt)
+
+          client_options = {
+            access_token: @api_key,
+            log_errors: ENV.fetch("LAYERED_ASSISTANT_LOG_ERRORS", "no") == "yes"
+          }
+          if @provider.url.present?
+            client_options[:uri_base] = @provider.url.sub(/\/\z/, "")
+            client_options[:api_version] = ""  # Gemini and other OpenAI-compatible APIs use their own path
+          end
+
+          ::OpenAI::Client.new(**client_options) do |f|
+            if ENV.fetch("LAYERED_ASSISTANT_LOG_ERRORS", "no") == "yes"
+              f.response :logger, Logger.new($stdout), bodies: true
+            end
+          end.chat(
+            parameters: {
+              model: model,
+              messages: formatted[:messages],
+              stream: stream_proc,
+              stream_options: { include_usage: true }
+            }
+          )
+        end
+      end
+    end
+  end
+end

data/app/services/layered/assistant/messages_service.rb

@@ -0,0 +1,58 @@
+module Layered
+  module Assistant
+    class MessagesService
+      def format(messages, provider: nil, system_prompt: nil)
+        protocol = provider&.protocol
+
+        if protocol == "openai"
+          format_openai(messages, system_prompt: system_prompt)
+        else
+          format_anthropic(messages, system_prompt: system_prompt)
+        end
+      end
+
+      private
+
+      def format_anthropic(messages, system_prompt: nil)
+        system_messages = []
+        system_messages << system_prompt if system_prompt.present?
+        regular_messages = []
+
+        messages.by_created_at.each do |message|
+          case message.role
+          when "system"
+            system_messages << message.content
+          when "user"
+            regular_messages << { role: "user", content: [{ type: "text", text: message.content }] }
+          when "assistant"
+            next if message.content.blank?
+            regular_messages << { role: "assistant", content: [{ type: "text", text: message.content }] }
+          end
+        end
+
+        result = { messages: regular_messages }
+        result[:system] = system_messages.join("\n\n") if system_messages.any?
+        result
+      end
+
+      def format_openai(messages, system_prompt: nil)
+        formatted = []
+        formatted << { role: "system", content: system_prompt } if system_prompt.present?
+
+        messages.by_created_at.each do |message|
+          case message.role
+          when "system"
+            formatted << { role: "system", content: message.content }
+          when "user"
+            formatted << { role: "user", content: message.content }
+          when "assistant"
+            next if message.content.blank?
+            formatted << { role: "assistant", content: message.content }
+          end
+        end
+
+        { messages: formatted }
+      end
+    end
+  end
+end

data/app/services/layered/assistant/models/create_service.rb

@@ -0,0 +1,50 @@
+require "net/http"
+require "json"
+
+module Layered
+  module Assistant
+    module Models
+      class CreateService
+        MODELS_URL = "https://raw.githubusercontent.com/layered-ai-public/layered-assistant-rails/main/data/models.json".freeze
+
+        def initialize(provider)
+          @provider = provider
+        end
+
+        def call
+          models_data = fetch_models
+          return if models_data.nil?
+
+          entries = models_data[@provider.name]
+          if entries.nil?
+            Rails.logger.info "[layered-ui-assistant] No models found for provider #{@provider.name.inspect} in remote catalogue"
+            return
+          end
+
+          entries.each do |entry|
+            @provider.models.find_or_create_by!(identifier: entry["identifier"]) do |model|
+              model.name = entry["name"]
+            end
+          end
+        end
+
+        private
+
+        def fetch_models
+          uri = URI(MODELS_URL)
+          response = Net::HTTP.get_response(uri)
+
+          unless response.is_a?(Net::HTTPSuccess)
+            Rails.logger.info "[layered-ui-assistant] Could not fetch model catalogue (HTTP #{response.code}) - skipping model sync"
+            return nil
+          end
+
+          JSON.parse(response.body)
+        rescue SocketError, Errno::ECONNREFUSED, Errno::ETIMEDOUT, Net::OpenTimeout, Net::ReadTimeout => e
+          Rails.logger.info "[layered-ui-assistant] Could not reach GitHub to fetch model catalogue (#{e.class}) - skipping model sync"
+          nil
+        end
+      end
+    end
+  end
+end

data/app/services/layered/assistant/token_estimator.rb

@@ -0,0 +1,11 @@
+module Layered
+  module Assistant
+    class TokenEstimator
+      def self.estimate(text)
+        return nil if text.blank?
+
+        OpenAI.rough_token_count(text)
+      end
+    end
+  end
+end

data/app/views/layered/assistant/assistants/_form.html.erb

@@ -0,0 +1,42 @@
+<%= form_with(model: assistant, url: url, html: { class: "l-ui-form l-ui-utility--mt-2xl" }) do |f| %>
+  <%= render "layered_ui/shared/form_errors", item: assistant %>
+
+  <div class="l-ui-form__group">
+    <%= render "layered_ui/shared/label", form: f, field: :name, required: true %>
+    <%= f.text_field :name, class: "l-ui-form__field" %>
+    <%= render "layered_ui/shared/field_error", object: assistant, field: :name %>
+  </div>
+
+  <div class="l-ui-form__group">
+    <%= render "layered_ui/shared/label", form: f, field: :description, required: false %>
+    <%= f.text_area :description, class: "l-ui-form__field", rows: 3 %>
+    <%= render "layered_ui/shared/field_error", object: assistant, field: :description %>
+  </div>
+
+  <div class="l-ui-form__group">
+    <%= render "layered_ui/shared/label", form: f, field: :system_prompt, name: "System prompt", required: false %>
+    <%= f.text_area :system_prompt, class: "l-ui-form__field", rows: 5 %>
+    <%= render "layered_ui/shared/field_error", object: assistant, field: :system_prompt %>
+  </div>
+
+  <div class="l-ui-form__group">
+    <%= render "layered_ui/shared/label", form: f, field: :default_model_id, name: "Default model", required: false %>
+    <%= f.select :default_model_id, @models.map { |m| ["#{m.provider.name} - #{m.name}", m.id] }, { include_blank: "None" }, class: "l-ui-select" %>
+    <%= render "layered_ui/shared/field_error", object: assistant, field: :default_model_id %>
+  </div>
+
+  <label class="l-ui-switch l-ui-utility--mt-xl">
+    <%= f.check_box :public, class: "l-ui-switch__input", role: "switch" %>
+    <span class="l-ui-switch__track"></span>
+    Public
+  </label>
+
+  <div class="l-ui-container--spread l-ui-utility--mt-2xl">
+    <% if assistant.persisted? %>
+      <%= link_to "Delete", layered_assistant.assistant_path(assistant), class: "l-ui-button--outline-danger", data: { turbo_method: :delete, turbo_confirm: "Are you sure?" } %>
+    <% else %>
+      <span></span>
+    <% end %>
+    <%= f.submit assistant.new_record? ? "Create" : "Update", class: "l-ui-button--primary" %>
+  </div>
+<% end %>

data/app/views/layered/assistant/assistants/edit.html.erb

@@ -0,0 +1,6 @@
+<div class="l-ui-container--spread">
+  <h1>Edit assistant</h1>
+  <%= link_to "Back", layered_assistant.assistants_path, class: "l-ui-button--outline" %>
+</div>
+
+<%= render "form", assistant: @assistant, url: layered_assistant.assistant_path(@assistant) %>

data/app/views/layered/assistant/assistants/index.html.erb

@@ -0,0 +1,45 @@
+<div class="l-ui-container--spread">
+  <h1>Assistants</h1>
+  <%= link_to "New", layered_assistant.new_assistant_path, class: "l-ui-button--primary" %>
+</div>
+
+<div class="l-ui-container--table l-ui-utility--mt-lg">
+  <table class="l-ui-table">
+    <caption class="l-ui-sr-only">Assistants</caption>
+    <thead class="l-ui-table__header">
+      <tr>
+        <th scope="col" class="l-ui-table__header-cell">Name</th>
+        <th scope="col" class="l-ui-table__header-cell">Description</th>
+        <th scope="col" class="l-ui-table__header-cell">Default model</th>
+        <th scope="col" class="l-ui-table__header-cell">Conversations</th>
+        <th scope="col" class="l-ui-table__header-cell--action">Actions</th>
+      </tr>
+    </thead>
+
+    <tbody class="l-ui-table__body">
+      <% @assistants.each do |assistant| %>
+        <tr>
+          <th scope="row" class="l-ui-table__cell--primary">
+            <%= link_to assistant.name, layered_assistant.assistant_conversations_path(assistant) %>
+          </th>
+          <td class="l-ui-table__cell">
+            <%= truncate(assistant.description, length: 60) %>
+          </td>
+          <td class="l-ui-table__cell">
+            <%= assistant.default_model&.name %>
+          </td>
+          <td class="l-ui-table__cell">
+            <%= link_to assistant.conversations_count, layered_assistant.assistant_conversations_path(assistant) %>
+          </td>
+          <td class="l-ui-table__cell--action">
+            <%= link_to "Edit", layered_assistant.edit_assistant_path(assistant) %>
+          </td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+
+  <div class="l-ui-utility--mt-lg">
+    <%= l_ui_pagy(@pagy) %>
+  </div>
+</div>

data/app/views/layered/assistant/assistants/new.html.erb

@@ -0,0 +1,6 @@
+<div class="l-ui-container--spread">
+  <h1>New assistant</h1>
+  <%= link_to "Back", layered_assistant.assistants_path, class: "l-ui-button--outline" %>
+</div>
+
+<%= render "form", assistant: @assistant, url: layered_assistant.assistants_path %>

data/app/views/layered/assistant/conversations/_form.html.erb

@@ -0,0 +1,29 @@
+<%= form_with(model: conversation, url: url, html: { class: "l-ui-form l-ui-utility--mt-2xl" }) do |f| %>
+  <%= render "layered_ui/shared/form_errors", item: conversation %>
+
+  <% if conversation.new_record? %>
+    <div class="l-ui-form__group">
+      <%= render "layered_ui/shared/label", form: f, field: :assistant_id, name: "Assistant", required: true %>
+      <%= f.select :assistant_id, @assistants.map { |a| [a.name, a.id] }, { include_blank: "Select an assistant:" }, class: "l-ui-select" %>
+      <%= render "layered_ui/shared/field_error", object: conversation, field: :assistant %>
+    </div>
+  <% end %>
+
+  <div class="l-ui-form__group">
+    <%= render "layered_ui/shared/label", form: f, field: :name, required: false %>
+    <%= f.text_field :name, class: "l-ui-form__field" %>
+    <% if conversation.new_record? %>
+      <p class="l-ui-form__hint">Auto-set from first message if left blank</p>
+    <% end %>
+    <%= render "layered_ui/shared/field_error", object: conversation, field: :name %>
+  </div>
+
+  <div class="l-ui-container--spread l-ui-utility--mt-2xl">
+    <% if conversation.persisted? %>
+      <%= link_to "Delete", layered_assistant.conversation_path(conversation), class: "l-ui-button--outline-danger", data: { turbo_method: :delete, turbo_confirm: "Are you sure?" } %>
+    <% else %>
+      <span></span>
+    <% end %>
+    <%= f.submit conversation.new_record? ? "Create" : "Update", class: "l-ui-button--primary" %>
+  </div>
+<% end %>

data/app/views/layered/assistant/conversations/edit.html.erb

@@ -0,0 +1,6 @@
+<div class="l-ui-container--spread">
+  <h1>Edit Conversation</h1>
+  <%= link_to "Back", layered_assistant.conversations_path, class: "l-ui-button--outline" %>
+</div>
+
+<%= render "form", conversation: @conversation, url: layered_assistant.conversation_path(@conversation) %>