labimotion 2.4.0.rc10 → 2.4.0.rc11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6355c96e00c582cf1b874e6e4300bbb26a150f276e3afcde63e364e50a7b4f31
-  data.tar.gz: 69b3c2d5fa16f295ee2dbdf4b240b0948e1e1f05a3a3edb8c4c4881fecda1137
+  metadata.gz: cc8a97c07b6329e1a6be6097c923d710101dfe03494e98463ab2795cea02a590
+  data.tar.gz: 7d5535979919fe5709feed7a00860ba6ac24c6c69999e3b1e9f0c03819b3268e
 SHA512:
-  metadata.gz: a916242cee0543be6fa0fa04333eaa9dfede1d486f311e0229b97f13120e18b80e58bdbfac234b0429a09e2ba915bafe461be229a52cc64bde1ecd8fd403a597
-  data.tar.gz: f79f17d2d887a637566ba9bd81123cb1474c75dcb6519813b2dcb770888e1c49c7b55342899f2455423e2a46da3d6056d27229048b431b2fa9c78595c9acfd41
+  metadata.gz: 79b2acc5223830bb6c4444342173b80af2ad4611f095e07cfcc89861473cf5f2e2854b0ed67e098b8c9bd94fe9285178f06fb20c7ae84729d5938d567a490531
+  data.tar.gz: b657890bf6c80d13283ba1936678c2c364308e80ba0cf01b51f36d129012873c47b2a9393724d2154307ba1ee267708a00992a49038428c3abe8160ef607eeb2

data/lib/labimotion/apis/generic_dataset_api.rb

@@ -85,6 +85,21 @@ module Labimotion
           use :create_ai_dataset_klass_params
         end
         post do
+          # Settle the cheap objections BEFORE spending a provider call on this:
+          # a taken name is knowable now, and finding out after generation means
+          # 15-90s and a token spend for an answer a lookup could have given.
+          validation = Labimotion::AiKlassValidator.error_for(kind: 'dataset', params: params)
+          next { status: 'error', message: validation } if validation
+
+          # Generation is a long provider call, so it is handed to the host's worker
+          # and the request answers at once; the result arrives as a notification
+          # linking back into the designer. A host with no such worker gets the
+          # old inline behaviour rather than an error.
+          if Labimotion::AiKlassQueue.queue(kind: 'dataset', params: params, user: current_user)
+            next { status: 'queued',
+                   message: 'Generating the template in the background. You will be notified when it is ready.' }
+          end
+
           msg = create_ai_dataset_klass(params, current_user)
           klass = Labimotion::DatasetKlassEntity.represent(Labimotion::DatasetKlass.all)
           { status: msg[:status], message: msg[:message], klass: klass }

data/lib/labimotion/apis/generic_element_api.rb

@@ -219,6 +219,21 @@ module Labimotion
         end
         post do
           authenticate_admin!('elements')
+          # Settle the cheap objections BEFORE spending a provider call on this:
+          # a taken name is knowable now, and finding out after generation means
+          # 15-90s and a token spend for an answer a lookup could have given.
+          validation = Labimotion::AiKlassValidator.error_for(kind: 'element', params: params)
+          next { status: 'error', message: validation } if validation
+
+          # Generation is a long provider call, so it is handed to the host's worker
+          # and the request answers at once; the result arrives as a notification
+          # linking back into the designer. A host with no such worker gets the
+          # old inline behaviour rather than an error.
+          if Labimotion::AiKlassQueue.queue(kind: 'element', params: params, user: current_user)
+            next { status: 'queued',
+                   message: 'Generating the template in the background. You will be notified when it is ready.' }
+          end
+
           msg = create_ai_element_klass(params, current_user)
           { status: msg[:status], message: msg[:message],
             klass: Labimotion::ElementKlassEntity.represent(Labimotion::ElementKlass.where(is_active: true)) }

data/lib/labimotion/apis/labimotion_ai_api.rb

@@ -17,6 +17,7 @@ module Labimotion
     # :models) lists none. A representative subset of the chat-capable KI-Toolbox
     # models (ki-toolbox.scc.kit.edu); the full list lives in the yml.
     DEFAULT_MODELS = %w[
+      models/DeepSeek-R1-Distill-Qwen-1.5B-Q4_K_M.gguf
       kit.mistral-small-4-119b-a8b
       azure.gpt-4.1-mini
       azure.gpt-4.1
@@ -99,18 +100,23 @@ module Labimotion
             (ids << ENV['KI_TOOLBOX_MODEL'].to_s).compact_blank.uniq
           end
 
-          # A well-formed https URL with a host. The deep SSRF check (host resolves
-          # to a public address) runs server-side in the gem at request time; this
-          # is only a fast format check for immediate UI feedback.
-          def https_endpoint?(url)
+          # A well-formed URL with a host, https only. In non-production envs
+          # (dev/test against local providers) http is also accepted. The deep
+          # SSRF check (host resolves to a public address) runs server-side in
+          # the gem at request time; this is only a fast format check for
+          # immediate UI feedback.
+          def valid_ai_endpoint?(url)
             uri = URI.parse(url.to_s.strip)
-            uri.is_a?(URI::HTTPS) && uri.host.present?
+            return false unless uri.host.present?
+
+            Rails.env.production? ? uri.is_a?(URI::HTTPS) : uri.is_a?(URI::HTTP)
           rescue URI::InvalidURIError
             false
           end
 
           # A personal provider endpoint is only usable with a personal key, and
-          # must be a valid https URL. Raises a 422 otherwise; no-op when unset.
+          # must be a valid https URL (http allowed outside production). Raises
+          # a 422 otherwise; no-op when unset.
           def validate_ai_endpoint!(base_url_arg, will_have_key)
             return if base_url_arg.blank?
 
@@ -120,9 +126,10 @@ module Labimotion
                 422
               )
             end
-            return if https_endpoint?(base_url_arg)
+            return if valid_ai_endpoint?(base_url_arg)
 
-            error!({ status: false, error: 'The AI provider endpoint must be a valid https:// URL.' }, 422)
+            scheme_msg = Rails.env.production? ? 'https://' : 'http:// or https://'
+            error!({ status: false, error: "The AI provider endpoint must be a valid #{scheme_msg} URL." }, 422)
           end
         end
 
@@ -136,7 +143,7 @@ module Labimotion
             base_url: settings.base_url,
             api_path: settings.api_path,
             available_models: labimotion_ai_models,
-            default_model: (configured && configured[:model]).presence,
+            default_model: (configured && configured[:model]).presence || DEFAULT_MODELS.first,
             default_base_url: (configured && configured[:base_url]).presence,
             server_api_key_set: (configured && configured[:api_key]).present?
           }

data/lib/labimotion/apis/segment_api.rb

@@ -69,6 +69,22 @@ module Labimotion
           @klass = fetch_klass('ElementKlass', params[:element_klass])
         end
         post do
+          # Settle the cheap objections BEFORE spending a provider call on this:
+          # a taken name is knowable now, and finding out after generation means
+          # 15-90s and a token spend for an answer a lookup could have given.
+          validation = Labimotion::AiKlassValidator.error_for(kind: 'segment', params: params, element_klass: @klass)
+          next { status: 'error', message: validation } if validation
+
+          # Generation is a long provider call, so it is handed to the host's worker
+          # and the request answers at once; the result arrives as a notification
+          # linking back into the designer. A host with no such worker gets the
+          # old inline behaviour rather than an error.
+          if Labimotion::AiKlassQueue.queue(kind: 'segment', params: params, user: current_user,
+                                            element_klass_id: @klass&.id)
+            next { status: 'queued',
+                   message: 'Generating the template in the background. You will be notified when it is ready.' }
+          end
+
           msg = create_ai_segment_klass(current_user, params)
           { status: msg[:status], message: msg[:message],
             klass: Labimotion::SegmentKlassEntity.represent(Labimotion::SegmentKlass.all) }

data/lib/labimotion/helpers/dataset_helpers.rb

@@ -113,9 +113,24 @@ module Labimotion
         'created_by' => current_user.id
       }
 
-      ds = Labimotion::DatasetKlass.create!(attributes)
+      # Same as the non-AI create beside it: the owner row shares the create's
+      # transaction, because a klass committed without one is owner-less and
+      # falls OPEN to the legacy designer-wide gate — every designer of the
+      # family could then edit, release and delete it, while its creator holds
+      # no special standing at all. seed_owner! rescues only RecordNotUnique and
+      # RecordInvalid, so any other failure has to take the klass down with it;
+      # this helper turns every StandardError into { status: 'error' }, and
+      # without the transaction the caller would be told the create failed while
+      # an unowned template silently persisted.
+      ds = Labimotion::DatasetKlass.transaction do
+        Labimotion::DatasetKlass.create!(attributes).tap do |klz|
+          Labimotion::KlassShare.seed_owner!(klz, current_user.id)
+        end
+      end
       ds.create_klasses_revision(current_user)
-      { status: 'success',
+      # `record` is the row itself. The background job that calls this needs the
+      # template, not a sentence about it, to link the notification back to it.
+      { status: 'success', record: ds,
         message: "The AI dataset template [#{label}] has been created as inactive. Review and activate it in the designer." }
     rescue StandardError => e
       Labimotion.log_exception(e, current_user)

data/lib/labimotion/helpers/element_helpers.rb

@@ -106,13 +106,28 @@ module Labimotion
         'created_by' => current_user.id
       }
 
-      new_klass = Labimotion::ElementKlass.create!(attributes)
+      # Same as the non-AI create beside it: the owner row shares the create's
+      # transaction, because a klass committed without one is owner-less and
+      # falls OPEN to the legacy designer-wide gate — every designer of the
+      # family could then edit, release and delete it, while its creator holds
+      # no special standing at all. seed_owner! rescues only RecordNotUnique and
+      # RecordInvalid, so any other failure has to take the klass down with it;
+      # this helper turns every StandardError into { status: 'error' }, and
+      # without the transaction the caller would be told the create failed while
+      # an unowned template silently persisted.
+      new_klass = Labimotion::ElementKlass.transaction do
+        Labimotion::ElementKlass.create!(attributes).tap do |klz|
+          Labimotion::KlassShare.seed_owner!(klz, current_user.id)
+        end
+      end
       new_klass.reload
       new_klass.create_klasses_revision(current_user)
       klass_names_file = Labimotion::KLASSES_JSON # Rails.root.join('app/packs/klasses.json')
       klasses = Labimotion::ElementKlass.where(is_active: true)&.pluck(:name) || []
       File.write(klass_names_file, klasses)
-      { status: 'success',
+      # `record` is the row itself. The background job that calls this needs the
+      # template, not a sentence about it, to link the notification back to it.
+      { status: 'success', record: new_klass,
         message: "The AI element template [#{label}] has been created as inactive. Review and activate it in the designer." }
     rescue StandardError => e
       Labimotion.log_exception(e, current_user)

data/lib/labimotion/helpers/segment_helpers.rb

@@ -106,10 +106,25 @@ module Labimotion
       # params[:metadata] via declared. Absent -> leave the column default.
       attributes['metadata'] = params[:metadata] if params[:metadata].present?
 
-      klass = Labimotion::SegmentKlass.create!(attributes)
+      # Same as the non-AI create beside it: the owner row shares the create's
+      # transaction, because a klass committed without one is owner-less and
+      # falls OPEN to the legacy designer-wide gate — every designer of the
+      # family could then edit, release and delete it, while its creator holds
+      # no special standing at all. seed_owner! rescues only RecordNotUnique and
+      # RecordInvalid, so any other failure has to take the klass down with it;
+      # this helper turns every StandardError into { status: 'error' }, and
+      # without the transaction the caller would be told the create failed while
+      # an unowned template silently persisted.
+      klass = Labimotion::SegmentKlass.transaction do
+        Labimotion::SegmentKlass.create!(attributes).tap do |klz|
+          Labimotion::KlassShare.seed_owner!(klz, current_user.id)
+        end
+      end
       klass.reload
       klass.create_klasses_revision(current_user)
-      { status: 'success',
+      # `record` is the row itself. The background job that calls this needs the
+      # template, not a sentence about it, to link the notification back to it.
+      { status: 'success', record: klass,
         message: "The AI segment template [#{params[:label]}] has been created as inactive. Review and activate it in the designer." }
     rescue StandardError => e
       Labimotion.log_exception(e, current_user)

data/lib/labimotion/libs/ai_egress_guard.rb

@@ -26,10 +26,13 @@ module Labimotion
       '255.255.255.255/32', '::/128', '::1/128', 'fc00::/7', 'fe80::/10', 'ff00::/8'
     ].map { |cidr| IPAddr.new(cidr) }.freeze
 
-    # Raise BlockedError unless url is a public https endpoint. Returns url.
+    # Raise BlockedError unless url is a public https endpoint (http is also
+    # accepted outside production, e.g. against a local dev provider). Returns url.
     def self.validate!(url)
       uri = parse(url)
-      raise BlockedError, 'AI provider URL must use https' unless uri.scheme == 'https'
+      allowed_schemes = Rails.env.production? ? %w[https] : %w[https http]
+      raise BlockedError, "AI provider URL must use #{allowed_schemes.join(' or ')}" unless
+        allowed_schemes.include?(uri.scheme)
 
       host = uri.host.to_s
       raise BlockedError, 'AI provider URL has no host' if host.empty?
@@ -37,7 +40,7 @@ module Labimotion
       addresses = resolve(host)
       raise BlockedError, "AI provider host could not be resolved: #{host}" if addresses.empty?
 
-      blocked = addresses.find { |ip| !public_ip?(ip) }
+      blocked = addresses.find { |ip| !allowed_ip?(ip) }
       raise BlockedError, "AI provider host resolves to a non-public address (#{blocked})" if blocked
 
       url
@@ -80,5 +83,17 @@ module Labimotion
     rescue StandardError
       false
     end
+
+    # Outside production, a private-network address (e.g. a self-hosted model
+    # on another machine on the LAN) is allowed; loopback/link-local/other
+    # EXTRA_BLOCKED ranges (cloud metadata etc.) stay blocked regardless of env.
+    def self.allowed_ip?(ip)
+      return public_ip?(ip) if Rails.env.production?
+      return false if ip.loopback? || ip.link_local?
+
+      EXTRA_BLOCKED.none? { |net| net.include?(ip) }
+    rescue StandardError
+      false
+    end
   end
 end

data/lib/labimotion/libs/ai_klass_queue.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Labimotion
+  # Hands AI template generation to the host's background worker.
+  #
+  # Generating a template is one long provider call — 18s for a small segment,
+  # past 90s for a large one — and running it inside the request held the dialog
+  # open for all of it, losing the work if the tab was closed or reloaded. The
+  # endpoints enqueue instead and answer at once; the result comes back as a
+  # notification carrying a link into the designer.
+  #
+  # The job itself belongs to the host: ActiveJob, the queue and the Message
+  # machinery are all its, and a gem that shipped its own would be defining
+  # infrastructure it does not own. So the host class is reached by its bare
+  # name and only if it exists — the same NameError-guarded pattern used for
+  # Matrice and Message elsewhere in this gem. A host without it gets the old
+  # inline behaviour rather than an error, which is what `queue` returning false
+  # tells the caller.
+  module AiKlassQueue
+    JOB = 'AiTemplateJob'
+
+    # @return [Boolean] true when the work was handed off
+    def self.queue(kind:, params:, user:, element_klass_id: nil)
+      job = job_class
+      return false if job.nil?
+
+      # Grape params are a Hashie::Mash; the queue serialises what it is given,
+      # and a Mash carries method_missing behaviour a worker process should not
+      # be asked to rebuild. A plain hash is the whole contract.
+      args = [kind.to_s, plain(params), user.id, element_klass_id]
+      inline? ? run_now(job, args, user) : job.perform_later(*args)
+      true
+    rescue StandardError => e
+      # An enqueue that fails must not fail the request: the caller falls back
+      # to generating inline, which is slower but still correct.
+      Labimotion.log_exception(e, user)
+      false
+    end
+
+    # Queued in every environment, development included: one code path, and the
+    # request returns straight away wherever it runs. Development therefore
+    # needs a worker like anywhere else — without one the job sits in the table
+    # and the notification never arrives.
+    #
+    # LABIMOTION_AI_INLINE=true runs it in the request instead, for a machine
+    # with no worker to spare. Off unless asked for, because a create that
+    # blocks for the length of a provider call is not the behaviour anyone
+    # should get by accident.
+    def self.inline?
+      ENV['LABIMOTION_AI_INLINE'] == 'true'
+    rescue StandardError
+      false
+    end
+
+    # Deliberately swallows: the job reports its own failure as a notification,
+    # exactly as it would on a worker, and letting it raise here would send the
+    # caller down the inline-generation fallback — spending a second provider
+    # call on work that has already been done and paid for.
+    def self.run_now(job, args, user)
+      job.perform_now(*args)
+    rescue StandardError => e
+      Labimotion.log_exception(e, user)
+      nil
+    end
+
+    def self.job_class
+      Object.const_get(JOB)
+    rescue NameError
+      nil
+    end
+
+    # Only what the helpers read, and stringified: file payloads included, since
+    # the reference files are part of the request the worker has to replay.
+    #
+    # A JSON round trip rather than as_json, because that is precisely what the
+    # queue will do to these arguments anyway — so anything that would not
+    # survive being written to the jobs table fails here, in the request, rather
+    # than in a worker nobody is watching.
+    def self.plain(params)
+      return {} if params.nil?
+
+      source = params.respond_to?(:to_unsafe_h) ? params.to_unsafe_h : params
+      JSON.parse(JSON.generate(source))
+    end
+  end
+end

data/lib/labimotion/libs/ai_klass_validator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # The checks that must happen BEFORE a template is generated.
+  #
+  # Generation moved to a background job, and the cheap objections — this name
+  # is taken, this ontology term already has a template — used to live inside
+  # the create helpers, which now run inside that job. So the user spent a
+  # provider call and 15-90s of waiting only to be told the label was already in
+  # use, which was knowable before a single token was spent. Worse, the answer
+  # arrived as a notification long after the dialog that could have fixed it had
+  # closed.
+  #
+  # These are only the objections that can be settled by a lookup. Anything the
+  # model decides at create! stays there: this is a courtesy gate, not a second
+  # source of truth, and the create still validates for real.
+  module AiKlassValidator
+    # @return [String, nil] the objection, or nil when there is none
+    def self.error_for(kind:, params:, element_klass: nil)
+      files = file_error(params)
+      return files if files
+
+      case kind.to_s
+      when 'element' then element_error(params)
+      when 'segment' then segment_error(params, element_klass)
+      when 'dataset' then dataset_error(params)
+      end
+    end
+
+    def self.file_error(params)
+      count = Array(params[:files]).size
+      return nil if count <= Labimotion::AiTemplate::MAX_FILES
+
+      "Too many files (max #{Labimotion::AiTemplate::MAX_FILES})."
+    end
+
+    # Mirrors ElementKlass's `validates :name, uniqueness:` — scoped to rows that
+    # are not soft-deleted, so a deleted template does not block the name it no
+    # longer holds.
+    def self.element_error(params)
+      name = params[:name].to_s.strip
+      return 'A name is required.' if name.blank?
+      return 'A label is required.' if params[:label].to_s.strip.blank?
+
+      return unless Labimotion::ElementKlass.where(deleted_at: nil).exists?(name: name)
+
+      "An element named [#{name}] already exists."
+    end
+
+    # Mirrors SegmentKlass's `validates :label, uniqueness: { scope: :element_klass_id }`.
+    # The label only has to be unique WITHIN its parent element, which is why the
+    # parent has to be known before this can be answered at all.
+    def self.segment_error(params, element_klass)
+      label = params[:label].to_s.strip
+      return 'A label is required.' if label.blank?
+      return 'A parent element is required.' if element_klass.nil?
+
+      taken = Labimotion::SegmentKlass.where(deleted_at: nil)
+                                      .exists?(label: label, element_klass_id: element_klass.id)
+      return unless taken
+
+      "A segment template labelled [#{label}] already exists for this element."
+    end
+
+    def self.dataset_error(params)
+      term = params[:ols_term_id].to_s.split('|').first.to_s.strip
+      return 'An ontology term (CHMO) is required.' if term.blank?
+
+      return unless Labimotion::DatasetKlass.where(deleted_at: nil).exists?(ols_term_id: term)
+
+      "A dataset template already exists for #{term}. Edit it in the designer instead."
+    end
+  end
+end

data/lib/labimotion/libs/ai_template.rb

@@ -108,6 +108,9 @@ module Labimotion
     # A plan longer than this is not a structural edit any more.
     MAX_PLAN_OPERATIONS = 25
 
+    # How much of a provider's error message is shown to the user.
+    MAX_PROVIDER_ERROR_CHARS = 300
+
     # Generate a metadata template for a generic dataset, element or segment.
     #
     # The JSON template schema (layers / fields / select_options) is IDENTICAL
@@ -292,7 +295,7 @@ module Labimotion
       end
 
       response = post_messages
-      raise "AI request failed (HTTP #{response.code})" unless response.code == 200
+      request_failed!('generate', response) unless response.code == 200
 
       body = JSON.parse(response.body)
       guard_finish_reason!(body)
@@ -312,7 +315,7 @@ module Labimotion
       raise 'An instruction is required' if instruction.to_s.strip.blank?
 
       response = post_chat(refine_messages(current, instruction))
-      raise "AI request failed (HTTP #{response.code})" unless response.code == 200
+      request_failed!('refine', response) unless response.code == 200
 
       body = JSON.parse(response.body)
       guard_finish_reason!(body)
@@ -345,7 +348,7 @@ module Labimotion
       raise 'An instruction is required' if instruction.to_s.strip.blank?
 
       response = post_chat(plan_messages(index, instruction), PLAN_MAX_TOKENS)
-      raise "AI request failed (HTTP #{response.code})" unless response.code == 200
+      request_failed!('plan', response) unless response.code == 200
 
       body = JSON.parse(response.body)
       raise 'AI request was declined by the content filter' if finish_reason(body) == 'content_filter'
@@ -372,7 +375,7 @@ module Labimotion
       raise 'This element template has no fields to fill' if schema.empty?
 
       response = post_chat(fill_messages(schema, context_text))
-      raise "AI request failed (HTTP #{response.code})" unless response.code == 200
+      request_failed!('fill', response) unless response.code == 200
 
       body = JSON.parse(response.body)
       guard_finish_reason!(body)
@@ -424,16 +427,55 @@ module Labimotion
       Array(body['choices']).first&.dig('finish_reason').to_s
     end
 
+    # A non-200 carries the provider's own reason, and that reason is the only
+    # thing separating a 400 for "no such model" from a 400 for "context length
+    # exceeded" or "max_tokens above this model's limit". Raising the bare status
+    # code — as this used to — leaves whoever hit it on another instance with
+    # nothing to go on but the number.
+    # The whole body still reaches log/labimotion.log; only what the user is
+    # shown is capped, because a misconfigured endpoint can answer with an entire
+    # HTML error page.
+    def request_failed!(context, response)
+      log_ai_response("#{context} failed (HTTP #{response.code})", response.body)
+      detail = provider_error(response).to_s.strip[0, MAX_PROVIDER_ERROR_CHARS]
+      message = "AI request failed (HTTP #{response.code})"
+      message += " — #{detail}" if detail.present?
+      raise message
+    end
+
+    # OpenAI-compatible gateways answer {"error": {"message": ..}}; this one
+    # (Open WebUI in front of vLLM) answers {"detail": ..}. Take either, and the
+    # raw body when it is neither.
+    def provider_error(response)
+      body = JSON.parse(response.body.to_s)
+      return '' unless body.is_a?(Hash)
+
+      err = body['error']
+      message = err.is_a?(Hash) ? err['message'] : err
+      message.presence || body['detail'].presence || body['message'].presence || ''
+    rescue JSON::ParserError
+      response.body.to_s.strip
+    end
+
     # Best-effort: record the raw model output (truncated) to log/labimotion.log so a
     # response that can't be turned into a template can be diagnosed. Never raises.
     def log_ai_response(context, raw)
       return if raw.to_s.strip.empty?
 
-      Labimotion.logger.warn("AiTemplate #{context}; raw (truncated): #{raw.to_s[0, 2000]}")
+      Labimotion.logger.warn("AiTemplate #{context}; raw (truncated): #{loggable(raw)}")
     rescue StandardError
       nil
     end
 
+    # An HTTParty body arrives as ASCII-8BIT, and a template full of °C and µm
+    # carries the high bytes to prove it. Interpolating that into a UTF-8 log
+    # line makes the write fail — silently, and precisely on the responses this
+    # exists to diagnose. Scrubbed to the encoding the log is actually in, and
+    # cut afterwards so the slice cannot split a character in half.
+    def loggable(raw)
+      raw.to_s.dup.force_encoding('UTF-8').scrub('')[0, 2000]
+    end
+
     # Map a non-200 status from the ping into a message that points at the setting
     # most likely at fault. Network/SSRF failures raise before this (from post_chat).
     def ping_error(code)

data/lib/labimotion/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '2.4.0.rc10'
+  VERSION = '2.4.0.rc11'
 end

data/lib/labimotion.rb

@@ -88,6 +88,8 @@ module Labimotion
 
   ######## Libs
   autoload :AiTemplate, 'labimotion/libs/ai_template'
+  autoload :AiKlassQueue, 'labimotion/libs/ai_klass_queue'
+  autoload :AiKlassValidator, 'labimotion/libs/ai_klass_validator'
   autoload :AiEgressGuard, 'labimotion/libs/ai_egress_guard'
   autoload :AiModels, 'labimotion/libs/ai_models'
   autoload :UserAiSettings, 'labimotion/libs/user_ai_settings'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.4.0.rc10
+  version: 2.4.0.rc11
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-17 00:00:00.000000000 Z
+date: 2026-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: caxlsx
@@ -145,6 +145,8 @@ files:
 - lib/labimotion/helpers/segment_helpers.rb
 - lib/labimotion/helpers/vocabulary_helpers.rb
 - lib/labimotion/libs/ai_egress_guard.rb
+- lib/labimotion/libs/ai_klass_queue.rb
+- lib/labimotion/libs/ai_klass_validator.rb
 - lib/labimotion/libs/ai_models.rb
 - lib/labimotion/libs/ai_template.rb
 - lib/labimotion/libs/attachment_handler.rb