layered-assistant-rails 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9419d936b5247ec519e481b02b7ead93a0e85bd6720a7b4298d145810c1405be
-  data.tar.gz: 5f9058cdae99fa50b3bf704853b74205f9a544e8c8430611ceb6ba1a509356bf
+  metadata.gz: '0849058555cc1dd6e7a2dffb73b3919086413374156a1c3300999eaa543c8a4b'
+  data.tar.gz: fa46c8ac4e95587216f467be30eb25d8c01c427d642b589b63a0ab849984e4fb
 SHA512:
-  metadata.gz: d5111d8c91517082ac5ab5eea935df4fbf73f0952c7455fcf6ac98f1fadab19f842aa0bf2483c60cdf1d8aaf2cfdb2cb812f488e7352195586038337f3e2314a
-  data.tar.gz: 3776256743b2734f9ae369508770e8cdc327e17299de34d01af376ba594485b4e55d2b160ce4b4820968c657fedcca2ede227067810a7dcb6f134e29dc5dd7ca
+  metadata.gz: 6b4ae1f8d54d5a753b9560fd532cb04e80cbe1959a728deaa9dfaaa82f83d5a7a65edef6a341a61879f73d1c22d76785692ef430242c7e8f995abc19754bac83
+  data.tar.gz: d43a15e7ed0b30c8a85dc578a4887b46b537d37e2d881f83fc2135539e60a8b4751dc3bc06fba37ed75e3ee0281b2fa52e089594abf91d31017a94156b065c0a

data/.claude/skills/layered-assistant-rails/SKILL.md

@@ -59,26 +59,18 @@ Until configured, every request returns 403. Public routes under `/layered/assis
 
 ## Scoping (multi-tenant ownership)
 
-Engine models with a polymorphic `owner` association (assistants, personas, providers, models, skills, conversations) can be scoped per request. The block receives the model class and returns an `ActiveRecord::Relation`:
+Assistants, personas, providers, skills and conversations include `Ownable`, giving them a polymorphic `owner` and an `owned_by` scope. Controllers stamp the owner on create and filter by it on read, defaulting to the signed-in user - no configuration required.
 
-```ruby
-Layered::Assistant.scope do |model_class|
-  model_class.where(owner: current_user)
-end
-```
-
-Scope only conversations, leave the rest unscoped:
+To move the boundary elsewhere, e.g. to an organisation:
 
 ```ruby
-Layered::Assistant.scope do |model_class|
-  if model_class == Layered::Assistant::Conversation
-    model_class.where(owner: current_user)
-  else
-    model_class.all
-  end
+Layered::Assistant.owner do
+  current_user.organisation
 end
 ```
 
+A nil owner means reads return no records and creates raise `Layered::Assistant::MissingOwnerError`, rather than persisting a record that every scoped read would hide.
+
 Ownership is enforced **at the controller layer via `scoped()`**, not via model validations. Out-of-scope IDs return 404.
 
 ## Optional settings
@@ -87,6 +79,7 @@ Ownership is enforced **at the controller layer via `scoped()`**, not via model
 Layered::Assistant.log_errors = true             # log API errors to stdout
 Layered::Assistant.api_request_timeout = 210     # total streaming API timeout (seconds)
 Layered::Assistant.skip_db_encryption = true     # dev/test only - skip encryption on Provider#secret
+Layered::Assistant.max_tool_cycles = 10          # rounds of tool calls one prompt may trigger
 ```
 
 `Provider#secret` is encrypted with Rails encrypted attributes, so the host app must have `bin/rails db:encryption:init` keys configured (or set `skip_db_encryption = true` for dev/test).
@@ -152,10 +145,47 @@ All under `Layered::Assistant::*`, tables prefixed `layered_assistant_`. Inherit
 | `Assistant` | A configured assistant: model + persona + skills |
 | `AssistantSkill` | Join between assistant and skill |
 | `Conversation` | A chat session with an assistant, owned polymorphically |
-| `Message` | A single message in a conversation; supports streaming |
+| `Message` | A single message in a conversation; supports streaming. A `tool` role message records what a tool returned |
 
 Enums are stored as **strings**, not integers.
 
+## Tools
+
+Tools let an assistant call into the host app before it answers. Define them in `app/tools` as subclasses of `Layered::Assistant::Tool` and list the classes in the initialiser:
+
+```ruby
+# app/tools/weather_tool.rb
+class WeatherTool < Layered::Assistant::Tool
+  description "Get the current weather for a city."
+
+  argument :city, :string, required: true, description: "The city to look up."
+  argument :units, :string, description: "celsius or fahrenheit", enum: %w[celsius fahrenheit]
+
+  def call(city:, units: "celsius")
+    { city: city, temperature: Weather.for(city).temperature(units) }
+  end
+end
+
+# config/initializers/layered_assistant.rb
+Layered::Assistant.tools do
+  [ WeatherTool ]
+end
+```
+
+The block is called per request, not read at boot, so tool classes reload in development.
+
+Class-level DSL: `description`, `argument(name, type, required:, description:, enum:, items:)`, `tool_name` (defaults to the class name minus its `Tool` suffix, namespaces hyphenated), `self.public =`. Argument types: `:string`, `:integer`, `:number`, `:boolean`, `:array` (with `items:`), `:object`. Subclassing a tool inherits `description`, the `public` flag and the parent's arguments (a child may redeclare one by name); `tool_name` is derived per class rather than inherited.
+
+Inside `#call`: `message`, `conversation`, `owner`. Return a string or anything responding to `#to_json`. Raising is safe - the error is handed back to the model as the tool's result rather than failing the response.
+
+**Public assistants:** a conversation with a public assistant has no owner. Tools are private by default and are withheld from those conversations; declare `self.public = true` to opt a safe tool in. Otherwise scope a tool's reads and writes to `owner`.
+
+**Assigning tools:** registering a tool makes it available to pick, not to call. Each assistant is given its own set (`assistant.tool_names`, a combobox on its edit screen); an assistant with none calls nothing.
+
+**Calling context:** inside `#call`, `owner` is the record the conversation is scoped to (scope reads to it), `user` is the person doing the talking - the same record until an owner block scopes ownership elsewhere - plus `conversation` and `message`.
+
+**The loop:** a response that asks for tools is not the end of the turn. `ToolRunnerService` runs the tools, records a `tool` role message per result, then queues a fresh assistant message so the model can answer with what came back. `max_tool_cycles` (default 10) bounds it. Results render as a collapsible `l-ui-surface` panel naming the tool, with input and output.
+
 ## Routes
 
 Mounted at `/layered/assistant` by default. Top-level resources: `personas`, `skills`, `assistants` (with nested `conversations`), `providers` (with nested `models`), `conversations` (with nested `messages` and a `stop` member route).
@@ -199,7 +229,7 @@ The engine renders inside `layered-ui-rails` layouts and uses only `l-ui-` class
 - **Provider creation fails with encryption error** - run `bin/rails db:encryption:init` and add the keys to credentials, or set `Layered::Assistant.skip_db_encryption = true` for dev/test.
 - **Panel body never loads** - `turbo-rails` must be installed and `layered-ui-rails` must be mounted in the layout. Check `import "@hotwired/turbo-rails"` is present.
 - **`layered_assistant` JS controllers missing** - ensure `import "layered_assistant"` is in `app/javascript/application.js` (added by the install generator, after the `layered_ui` import).
-- **Cross-tenant records visible** - configure `Layered::Assistant.scope` to filter by `owner`.
+- **No records visible, or `MissingOwnerError` on create** - `current_owner` is nil. Check the authorize block only admits signed-in users, and that any `Layered::Assistant.owner` block returns a record.
 
 ## Further reference
 

data/NOTICE

@@ -5,3 +5,23 @@ Copyright 2026 LAYERED AI LIMITED (UK company number: 17056830).
 This product includes software developed by LAYERED AI LIMITED and contributors.
 
 Licensed under the Apache License, Version 2.0.
+
+------------------------------------------------------------------------
+Third-party software
+------------------------------------------------------------------------
+
+This product bundles the following third-party JavaScript libraries
+under app/javascript/layered_assistant/vendor/. Their full license
+texts are included alongside the source files.
+
+  marked (https://github.com/markedjs/marked)
+    Copyright (c) 2018+ MarkedJS
+    Copyright (c) 2011-2018 Christopher Jeffrey
+    Licensed under the MIT License.
+    See: app/javascript/layered_assistant/vendor/marked.LICENSE
+
+  DOMPurify (https://github.com/cure53/DOMPurify)
+    Copyright Dr.-Ing. Mario Heiderich, Cure53
+    Dual-licensed under the Apache License 2.0 or the
+    Mozilla Public License 2.0; used here under Apache-2.0.
+    See: app/javascript/layered_assistant/vendor/dompurify.LICENSE

data/README.md

@@ -120,31 +120,45 @@ The `l_assistant_accessible?` helper evaluates the authorize block without side
 
 ## Record scoping
 
-By default, all records are visible to any authorised user. If your application is multi-tenant or you need to restrict which records a user can see, configure a `scope` block in the initialiser.
+Engine records are owned. Assistants, conversations, personas, providers and skills are stamped with an owner on create and filtered by it on read, so users only see their own records. The owner defaults to the signed-in user, so multi-tenant apps need no configuration.
 
-The block receives the model class, runs in controller context, and must return an `ActiveRecord::Relation`. All engine models with a polymorphic `owner` association are passed through the scope block.
+### Changing the ownership boundary
 
-### Scope all owned resources to the current user
+To scope records to something other than the signed-in user - their organisation, say - configure an `owner` block in the initialiser:
 
 ```ruby
-Layered::Assistant.scope do |model_class|
-  model_class.where(owner: current_user)
+Layered::Assistant.owner do
+  current_user.organisation
 end
 ```
 
-### Scope conversations only
+The block runs in controller context. Whatever it returns is used as the owner for both reads and creates.
+
+### When there is no owner
+
+Reads return no records, and create actions raise `Layered::Assistant::MissingOwnerError` rather than persisting a record that every scoped read would then hide. Make sure your authorize block only admits authenticated users.
+
+If you configure an owner block, it must return a record for every request your authorize block admits - not just for signed-in users. `current_user.organisation` returns nil for someone who has not created an organisation yet, and that user will hit `MissingOwnerError` on their first create. Either give the block a fallback, or have your authorize block send those users somewhere to set one up first.
+
+Ownership is enforced at the controller layer, not by model validations. Out-of-scope IDs return 404.
+
+### The conversation user
+
+Ownership answers "which records may this request see". It does not answer
+"who is doing the talking" - and once an owner block scopes records to an
+organisation, the owner cannot: every member of that organisation shares it.
+
+So a conversation separately records the signed-in user who started it:
 
 ```ruby
-Layered::Assistant.scope do |model_class|
-  if model_class == Layered::Assistant::Conversation
-    model_class.where(owner: current_user)
-  else
-    model_class.all
-  end
-end
+conversation.owner # => #<Organisation id: 3>   the boundary records are scoped to
+conversation.user  # => #<User id: 91>          the person who asked
 ```
 
-When no scope block is configured, queries are unscoped. Record-level access control is the host application's responsibility; the scope block is the integration point for it.
+The two are the same record until you configure an owner block. `user` is
+always whoever was signed in and is never redirected by a block, and it is nil
+for an anonymous visitor on a public assistant. Tools read both - see
+[Tools](#tools).
 
 ## Panel helpers
 
@@ -173,6 +187,140 @@ Both helpers accept keyword arguments that are forwarded as HTML attributes to t
 | `layered_assistant_panel_header` | Empty Turbo Frame (`assistant_panel_header`) populated by the engine's panel views |
 | `layered_assistant_panel_body` | Turbo Frame (`assistant_panel`) that loads the conversation list from the engine's panel routes |
 
+## Tools
+
+An assistant can call into the host application to fetch or change something
+before it answers. Define a tool as a class in `app/tools`:
+
+```ruby
+# app/tools/weather_tool.rb
+class WeatherTool < Layered::Assistant::Tool
+  description "Get the current weather for a city."
+
+  argument :city, :string, required: true, description: "The city to look up."
+  argument :units, :string, description: "celsius or fahrenheit", enum: %w[celsius fahrenheit]
+
+  def call(city:, units: "celsius")
+    forecast = Weather.for(city)
+
+    { city: city, temperature: forecast.temperature(units), summary: forecast.summary }
+  end
+end
+```
+
+Then list the tool classes in your initialiser:
+
+```ruby
+Layered::Assistant.tools do
+  [ WeatherTool ]
+end
+```
+
+The block is called per request rather than read once at boot, so tool classes
+reload in development like any other application class.
+
+### Giving tools to an assistant
+
+Registering a tool makes it available to pick, not available to call. Each
+assistant is given its own set on its edit screen, and an assistant with no
+tools calls nothing - so adding a tool to the application does not hand it to
+every assistant at once. Two assistants can share a registered tool and still
+be given different sets:
+
+| Assistant | Tools |
+|---|---|
+| Sales assistant | `weather` |
+| Support assistant | `weather`, `order-lookup` |
+
+The set is held by tool name rather than a foreign key, because tools are
+classes rather than records. A name whose class is no longer registered is
+ignored, so removing a tool from the initialiser does not break the assistants
+that listed it.
+
+Outside the UI, assign the set with `tool_names`:
+
+```ruby
+assistant.update!(tool_names: [ "weather", "order-lookup" ])
+```
+
+### Defining a tool
+
+| Method | Description |
+|---|---|
+| `description` | What the tool does, in the model's words. This is the only thing the model has to go on, so be specific |
+| `argument` | An argument the model may supply: `argument :name, :type, required:, description:, enum:, items:` |
+| `tool_name` | The name the model calls the tool by. Defaults to the class name without its `Tool` suffix, namespaces hyphenated: `Weather::ForecastTool` becomes `weather-forecast` |
+| `self.public =` | Whether the tool may be offered to a public assistant. `false` by default - see below |
+
+Argument types are `:string`, `:integer`, `:number`, `:boolean`, `:array` and
+`:object`. An `:array` takes `items:` to name its element type.
+
+Subclass a tool to share logic and the declarations come with it: the child
+inherits its parent's `description`, `public` flag and arguments, adds any
+arguments of its own, and may redeclare one by name to narrow it. The name is
+the exception - the child derives its own from its class name, since two tools
+answering to one name would collide in the registry.
+
+`#call` receives the arguments as keywords and may return a string or anything
+that responds to `#to_json`. Raising is safe: the error is reported back to the
+model as the tool's result, so it can correct itself or explain, rather than
+the response failing.
+
+Inside `#call`, four methods give the calling context:
+
+| Method | Description |
+|---|---|
+| `owner` | The record the conversation is scoped to. Scope the tool's reads and writes to this - it is the caller's boundary |
+| `user` | The person doing the talking. The same record as `owner` until an owner block scopes ownership elsewhere, at which point `owner` is (say) the organisation and `user` is the member of it who asked |
+| `conversation` | The conversation the call came from |
+| `message` | The assistant message that asked for the call |
+
+Registering a tool does not scope it. `owner` is handed to you, but nothing
+enforces that you use it - a tool that queries across every tenant will do
+exactly that. Scoping is the tool's own job:
+
+```ruby
+def call(reference:)
+  owner.orders.find_by(reference: reference)
+end
+```
+
+### Tools and public assistants
+
+A conversation with a public assistant has no owner - it belongs to an
+anonymous visitor, so there is no boundary to scope a tool's reads to. Tools
+are private by default and withheld from those conversations even when the
+assistant has been given them. A tool that is safe to expose opts in, using
+the same word an assistant does:
+
+```ruby
+class CurrentTimeTool < Layered::Assistant::Tool
+  description "Get the current date and time on the server."
+  self.public = true
+
+  def call
+    { time: Time.current.iso8601 }
+  end
+end
+```
+
+This is written as an attribute rather than a `public true` DSL because
+`public` is Ruby's own method-visibility keyword. A class method of that name
+would shadow it, and a tool whose body used a bare `public` to reopen
+visibility would silently mark itself callable by anonymous visitors - too
+sharp an edge for a flag that governs exposure.
+
+### The tool call loop
+
+A response that asks for tools is not the end of the turn. The engine runs the
+tools, records a message per result, then queues a fresh assistant message so
+the model can answer with what came back - which may ask for tools again. The
+composer stays disabled until a response completes without asking for
+anything, and `max_tool_cycles` (default 10) bounds the loop.
+
+Results are shown in the conversation as a collapsible panel naming the tool,
+with its input and output.
+
 ## Configuration
 
 Optional settings can be added to your initialiser (`config/initializers/layered_assistant.rb`):
@@ -188,6 +336,10 @@ Layered::Assistant.api_request_timeout = 210
 # Disable Active Record Encryption on Provider#secret.
 # Only use this in development/test environments without encryption keys configured.
 Layered::Assistant.skip_db_encryption = true
+
+# How many rounds of tool calls one prompt may trigger before the engine gives
+# up and says so (default: 10).
+Layered::Assistant.max_tool_cycles = 10
 ```
 
 Note: `skip_db_encryption` is read at class load time, so it must be set before `Layered::Assistant::Provider` is first loaded. A standard Rails initialiser satisfies this requirement.

data/app/controllers/layered/assistant/application_controller.rb

@@ -10,6 +10,51 @@ module Layered
 
       private
 
+      # The record ownership is stamped with on create and filtered by on
+      # reads. Configure an owner block in the initialiser to scope records
+      # to something other than the signed-in user (e.g. their organisation).
+      def current_owner
+        block = Layered::Assistant.owner_block
+
+        block ? instance_exec(&block) : l_ui_current_user
+      end
+
+      # The person a new conversation records as the one talking. Unlike the
+      # owner this is never redirected by a block: it is always whoever is
+      # signed in, and nil for an anonymous visitor on a public assistant.
+      def current_conversation_user
+        l_ui_current_user
+      end
+
+      # Owner stamping on create goes through this bang variant: persisting
+      # a record with a nil owner would leave it invisible to every scoped
+      # read, so a missing owner fails loudly instead.
+      def current_owner!
+        current_owner || raise(MissingOwnerError, "current_owner is nil - the authorize block admitted a request without a signed-in user, or the owner block returned nil")
+      end
+
+      def scoped(model_class)
+        model_class.owned_by(current_owner)
+      end
+
+      # Models carry no owner of their own - they belong to the owner of
+      # their provider - so the set a request may choose from is filtered
+      # through the provider rather than through `scoped`.
+      def scoped_models
+        Model.available.merge(scoped(Provider))
+      end
+
+      # The composer posts the model to answer with, so the id has to be
+      # resolved through `scoped_models` before it reaches a message -
+      # otherwise a request could name another owner's model and have the
+      # response generated through their provider, on their API key. An
+      # out-of-scope id 404s, as it does everywhere else.
+      def scoped_model_id(model_id)
+        return nil if model_id.blank?
+
+        scoped_models.find(model_id).id
+      end
+
       def layered_assistant_authorize!
         block = Layered::Assistant.authorize_block
 
@@ -20,18 +65,6 @@ module Layered
 
         instance_exec(&block)
       end
-
-      def scoped(model_class)
-        block = Layered::Assistant.scope_block
-        return model_class.all unless block
-
-        result = instance_exec(model_class, &block)
-        unless result.is_a?(ActiveRecord::Relation)
-          raise ArgumentError,
-            "Layered::Assistant.scope must return an ActiveRecord::Relation, got #{result.class}"
-        end
-        result
-      end
     end
   end
 end

data/app/controllers/layered/assistant/assistants_controller.rb

@@ -1,83 +1,64 @@
 module Layered
   module Assistant
-    class AssistantsController < ApplicationController
-      before_action :set_assistant, only: [:edit, :update, :destroy]
-      before_action :set_models, only: [:new, :create, :edit, :update]
-      before_action :set_personas, only: [:new, :create, :edit, :update]
-      before_action :set_skills, only: [:new, :create, :edit, :update]
+    # Assistants point at a model, a persona, a set of skills and a set of
+    # tools. All but the tools are owner-scoped records, and the resource
+    # class cannot scope them itself - a field's `collection:` is resolved
+    # without a controller - so the options are filled in here, and the ids
+    # that come back are resolved through `scoped` before they reach the
+    # record.
+    #
+    # `@fields` is set by the gem's own `load_layered_resource`, declared
+    # when `Layered::Resource::Controller` is included by ResourcesController,
+    # so it has always run by the time this subclass's callback does.
+    class AssistantsController < ResourcesController
+      before_action :scope_choice_fields, only: [ :new, :create, :edit, :update ]
 
-      def index
-        @page_title = "Assistants"
-        @pagy, @assistants = pagy(scoped(Assistant).includes(:persona).by_name)
-      end
-
-      def new
-        @page_title = "New assistant"
-        @assistant = Assistant.new
-      end
+      private
 
-      def create
-        @assistant = Assistant.new(assistant_params.except(:persona_id, :skill_ids))
-        @assistant.owner = l_ui_current_user
-        @assistant.persona = scoped(Persona).find(assistant_params[:persona_id]) if assistant_params[:persona_id].present?
+      def scope_choice_fields
+        models = scoped_models.map { |model| [ "#{model.provider.name} - #{model.name}", model.id ] }
+        personas = scoped(Persona).by_name.map { |persona| [ persona.name, persona.id ] }
+        skills = scoped(Skill).by_name.map { |skill| [ skill.name, skill.id ] }
+        # Tools are classes the host application registered, not records, so
+        # there is nothing to scope - the registry is the whole list.
+        tools = ToolRegistry.all.map { |tool| [ tool.tool_name, tool.tool_name ] }
 
-        if @assistant.save
-          assign_skills
-          redirect_to layered_assistant.assistants_path, notice: "Assistant was successfully created."
-        else
-          render :new, status: :unprocessable_entity
+        @fields = @fields.map do |field|
+          case field[:attribute]
+          when :default_model_id then field.merge(collection: models)
+          when :persona_id then field.merge(collection: personas)
+          when :skill_ids then field.merge(collection: skills)
+          when :tool_names then field.merge(collection: tools)
+          else field
+          end
         end
       end
 
-      def edit
-        @page_title = "Edit assistant"
-      end
+      # An out-of-scope model or persona 404s rather than being silently
+      # dropped, matching how a record itself is looked up. Skills and tools
+      # are filtered instead: the picker posts a list, and one stale entry
+      # should not fail the whole save.
+      def layered_resource_params
+        attributes = super
 
-      def update
-        if assistant_params.key?(:persona_id)
-          @assistant.persona = assistant_params[:persona_id].present? ? scoped(Persona).find(assistant_params[:persona_id]) : nil
+        if attributes[:default_model_id].present?
+          attributes[:default_model_id] = scoped_models.find(attributes[:default_model_id]).id
         end
 
-        if @assistant.update(assistant_params.except(:persona_id, :skill_ids))
-          assign_skills
-          redirect_to layered_assistant.assistants_path, notice: "Assistant was successfully updated."
-        else
-          render :edit, status: :unprocessable_entity
+        if attributes[:persona_id].present?
+          attributes[:persona_id] = scoped(Persona).find(attributes[:persona_id]).id
         end
-      end
-
-      def destroy
-        @assistant.destroy
-        redirect_to layered_assistant.assistants_path, notice: "Assistant was successfully deleted."
-      end
-
-      private
 
-      def set_assistant
-        @assistant = scoped(Assistant).find(params[:id])
-      end
-
-      def set_models
-        @models = Model.available
-      end
-
-      def set_personas
-        @personas = scoped(Persona).by_name
-      end
-
-      def set_skills
-        @skills = scoped(Skill).by_name
-      end
+        if attributes.key?(:skill_ids)
+          attributes[:skill_ids] = scoped(Skill).where(id: Array(attributes[:skill_ids]).compact_blank).ids
+        end
 
-      def assign_skills
-        if assistant_params.key?(:skill_ids)
-          skill_ids = Array(assistant_params[:skill_ids]).compact_blank
-          @assistant.skills = scoped(Skill).where(id: skill_ids)
+        if attributes.key?(:tool_names)
+          registered = ToolRegistry.all.map(&:tool_name)
+          attributes[:tool_names] = Array(attributes[:tool_names]).compact_blank & registered
         end
-      end
 
-      def assistant_params
-        params.require(:assistant).permit(:name, :description, :instructions, :default_model_id, :persona_id, :public, skill_ids: [])
+        attributes
       end
     end
   end

data/app/controllers/layered/assistant/conversations_controller.rb

@@ -3,39 +3,40 @@ module Layered
     class ConversationsController < ApplicationController
       include StoppableResponse
 
-      before_action :set_conversation, only: [:show, :edit, :update, :destroy, :stop]
-      before_action :set_assistants, only: [:new, :create]
+      before_action :set_conversation, only: [ :show, :edit, :update, :destroy, :stop ]
+      before_action :set_assistants, only: [ :new, :create ]
 
       def index
         if params[:assistant_id]
           @assistant = scoped(Assistant).find(params[:assistant_id])
           @page_title = "Conversations - #{@assistant.name}"
-          @pagy, @conversations = pagy(@assistant.conversations.merge(scoped(Conversation)).includes(:owner).by_created_at)
+          @pagy, @conversations = pagy(@assistant.conversations.merge(scoped(Conversation)).includes(:owner, :user).by_created_at)
         else
           @page_title = "Conversations"
-          @pagy, @conversations = pagy(scoped(Conversation).includes(:assistant, :owner).by_created_at)
+          @pagy, @conversations = pagy(scoped(Conversation).includes(:assistant, :owner, :user).by_created_at)
         end
       end
 
       def show
         @page_title = @conversation.name
         @messages = @conversation.messages.includes(:model).by_created_at
-        @models = Model.available
+        @models = scoped_models
         @selected_model_id = @messages.last&.model_id || @conversation.assistant.default_model_id || @models.first&.id
       end
 
       def new
         @page_title = "New conversation"
-        @conversation = Conversation.new(params.permit(conversation: [:assistant_id])[:conversation])
+        @conversation = Conversation.new(params.permit(conversation: [ :assistant_id ])[:conversation])
       end
 
       def create
         @conversation = Conversation.new(conversation_params)
-        @conversation.owner = l_ui_current_user
+        @conversation.owner = current_owner!
+        @conversation.user = current_conversation_user
         @conversation.assistant = scoped(Assistant).find(conversation_params[:assistant_id]) if conversation_params[:assistant_id].present?
         @conversation.name = Conversation.default_name if @conversation.name.blank?
         if @conversation.save
-          redirect_to layered_assistant.conversation_path(@conversation), notice: "Conversation was successfully created."
+          redirect_to layered_assistant.conversation_path(@conversation)
         else
           render :new, status: :unprocessable_entity
         end

data/app/controllers/layered/assistant/messages_controller.rb

@@ -4,7 +4,7 @@ module Layered
       include MessageCreation
 
       before_action :set_conversation
-      before_action :set_message, only: [:destroy]
+      before_action :set_message, only: [ :destroy ]
 
       def index
         @page_title = "Messages"
@@ -12,10 +12,12 @@ module Layered
       end
 
       def create
+        model_id = scoped_model_id(message_params[:model_id])
+
         result = create_messages_for(
           conversation: @conversation,
           content: message_params[:content],
-          model_id: message_params[:model_id]
+          model_id: model_id
         )
         @message = result[:message]
 
@@ -24,8 +26,8 @@ module Layered
         end
 
         @assistant_message = result[:assistant_message]
-        @models = Model.available
-        @selected_model_id = message_params[:model_id]
+        @models = scoped_models
+        @selected_model_id = model_id
         @error = result[:error]
 
         respond_to do |format|