llm_meta_client 1.3.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fcc6377f3293f8ecd13b81cd79ea63891c18f55dfa05ee225a151f7e1fa5b84
-  data.tar.gz: 35c4cba209aed5989b43606715205a7e2b85c669fa7dd71d65a33f4dd47a293a
+  metadata.gz: 392fd4f6a93475e739beef49bf50b8158fced469993b78875a22845777bcf96b
+  data.tar.gz: '090a33919e5ac2916b1d5af16b11e9e831f954c00dc1a61f1459db931f3f02f8'
 SHA512:
-  metadata.gz: c959d77e7d3b8c9f5070bf2f63a74e83ba1082391694788e094c09629e76883dcf0142336af7742dd08fa46c0d36ec20ad31ad85b558ea4199cb8b7e3c4345fc
-  data.tar.gz: 651d88ddb211fd11234daf2ecee22e368d8886d27e43b94c1786d4d3980cedfb078a562ee0cd0ad06a48140c7fb07cae779326237e604b21a819d4ceb663d815
+  metadata.gz: 8e9546f73d0e30b8ebc5074fdbb5a244f0e657d82094e7ba64383d9aad07c69cfc2570cb6c0c7ec316f4314ab0c693a7260cf25e79301e2d1a633d93e47a97fb
+  data.tar.gz: 2f84dd1aa7c422081d30a7c02b963eeae90c4e3b43e0b957f575e8cd348a773189f1137bb979f6922420404f7e7d3acbf70abe5403eabaa736e4a3cd14feb5be

data/CHANGELOG.md

@@ -5,6 +5,44 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.0] - 2026-06-04
+
+### Added
+
+- Thinking-mode SSE event: `message_stream_controller` handles `event: thinking` for reasoning models and renders a fixed-height collapsible reasoning panel with pulsing dots while the model is mid-thought.
+- Image input — `ServerQuery#stream` and `#run` now accept an `images:` array; scaffold templates add Enter-to-send, image preview, drag-and-drop, and a URL-based chat identity so reload preserves the active conversation.
+- Image-generation plumbing: scaffold supports Gemini image-gen responses (data-URI rendering, save-as-PNG) and a cancel button that aborts an in-flight stream.
+- Asset actions: scaffold ships `asset_actions_controller` so assistant responses get Download / Copy buttons on JSON, CSV, and image blocks.
+- Grid-view model picker — quick-picks row + searchable "Other models" tile grid with a Settings count badge; favorites can be reordered.
+- Default-LLM persistence, batch chat actions (multi-select destroy/export), refreshable "New Chat" button, and a redesigned chat input.
+
+### Changed
+
+- `message_stream_controller` UI polish: fixed-height reasoning area, pulsing dots, smoother streaming bubble layout.
+- Scaffold model-selection labels renamed for consistency with the hub UI.
+- `strip_title_markdown` helper normalizes generated chat titles for sidebar display.
+
+### Tested
+
+- `ServerQuery` HTTP client — sync, SSE, and error-mapping branches.
+- `ServerResource` REST helpers + Ollama-fallback branches.
+- `Helpers#split_attached_image_html` regex.
+
+### Notes
+
+- Compatible with `llm_meta_server` ≥ the matching server-side thinking-event and image-input plumbing.
+
+## [1.4.0] - 2026-05-11
+
+### Added
+
+- Phase indicator in the streaming bubble. `message_stream_controller` now handles `event: phase` from the server and updates the role label (e.g. "🤔 Thinking…") so the user sees progress during turn 1 tool selection and turn 2 reasoning. The label auto-flips back to "🤖 streaming…" on the first content delta.
+- Streaming endpoint emits SSE keepalive comment lines during long synchronous waits (works alongside the server-side heartbeat thread on `llm_meta_server`). EventSource ignores these by design; they keep the connection warm through buffering proxies.
+
+### Notes
+
+- Requires `llm_meta_server` with the matching `on_phase_change` plumbing in `LlmRbFacade.stream!` and the heartbeat thread in `Api::ChatStreamsController`.
+
 ## [1.3.0] - 2026-05-10
 
 ### Added

data/lib/generators/llm_meta_client/scaffold/scaffold_generator.rb

@@ -29,28 +29,31 @@ module LlmMetaClient
         template "app/views/chats/edit.html.erb"
         template "app/views/chats/create.turbo_stream.erb"
         template "app/views/chats/update.turbo_stream.erb"
+        template "app/views/chats/destroy.turbo_stream.erb"
         template "app/views/chats/_message.html.erb"
         template "app/views/chats/_streaming_message.html.erb"
         template "app/views/chats/_tool_call_message.html.erb"
         template "app/views/chats/_chat_sidebar.html.erb"
         template "app/views/chats/_messages_list.html.erb"
-        template "app/views/shared/_family_field.html.erb"
-        template "app/views/shared/_api_key_field.html.erb"
-        template "app/views/shared/_model_field.html.erb"
+        template "app/views/shared/_quick_picks.html.erb"
+        template "app/views/shared/_model_grid.html.erb"
         template "app/views/shared/_tool_selector_field.html.erb"
         template "app/views/shared/_generation_settings_field.html.erb"
         template "app/views/layouts/application.html.erb"
         template "app/views/layouts/_header.html.erb"
+        template "app/views/layouts/_new_chat_button.html.erb"
         template "app/views/layouts/_sidebar.html.erb"
       end
 
       def create_javascript
-        template "app/javascript/controllers/llm_selector_controller.js"
+        template "app/javascript/controllers/model_picker_controller.js"
+        template "app/javascript/controllers/llm_toggle_controller.js"
         template "app/javascript/controllers/chats_form_controller.js"
         template "app/javascript/controllers/chat_title_edit_controller.js"
         template "app/javascript/controllers/tool_selector_controller.js"
         template "app/javascript/controllers/generation_settings_controller.js"
         template "app/javascript/controllers/message_stream_controller.js"
+        template "app/javascript/controllers/asset_actions_controller.js"
         copy_file "app/javascript/popover.js"
       end
 
@@ -68,19 +71,21 @@ module LlmMetaClient
         route <<-RUBY
           root "chats#new"
 
-          resources :chats, only: [ :new, :create, :edit, :update, :show ] do
+          resources :chats, only: [ :new, :create, :show, :destroy ] do
             collection do
               delete :clear
               post :start_new
-              get :download_all_csv
+              delete :batch_destroy
+              post :download_selected_csv
             end
             member do
               patch :update_title
               get :download_csv
+              post :add_prompt
             end
             resource :stream, only: [ :show ], controller: "chat_streams"
           end
-          resources :prompts, only: [ :show ]
+          resources :prompts, only: [ :show, :destroy ]
 
           namespace :api do
             resources :mcp_servers, only: [ :index ], param: :uuid do

data/lib/generators/llm_meta_client/scaffold/templates/app/controllers/api/mcp_servers_controller.rb

@@ -5,13 +5,13 @@ class Api::McpServersController < ApplicationController
   before_action :authenticate_user!
 
   def index
-    jwt_token = current_user.id_token
+    jwt_token = current_user.jwt_token
     mcp_servers = LlmMetaClient::ServerResource.fetch_mcp_servers(jwt_token)
     render json: { mcp_servers: mcp_servers }
   end
 
   def tools
-    jwt_token = current_user.id_token
+    jwt_token = current_user.jwt_token
     tools = LlmMetaClient::ServerResource.fetch_mcp_tools(jwt_token, params[:uuid])
     render json: { tools: tools }
   end

data/lib/generators/llm_meta_client/scaffold/templates/app/controllers/chat_streams_controller.rb

@@ -9,17 +9,28 @@ class ChatStreamsController < ApplicationController
     response.headers["Cache-Control"] = "no-cache"
     response.headers["X-Accel-Buffering"] = "no"
 
+    # Initialize early so the disconnect rescue can persist whatever was
+    # forwarded before the user clicked Cancel.
+    partial = +""
+    chat = nil
+    prompt_execution = nil
+    jwt_token = nil
+
     chat = find_chat
     prompt_execution = PromptNavigator::PromptExecution.find_by!(execution_id: params[:execution_id])
     unless chat.messages.exists?(prompt_navigator_prompt_execution_id: prompt_execution.id)
       raise ActiveRecord::RecordNotFound
     end
 
-    jwt_token = current_user.id_token if user_signed_in?
+    jwt_token = current_user.jwt_token if user_signed_in?
     generation_settings = parse_generation_settings(params[:generation_settings_json])
     tool_ids = Array(params[:tool_ids]).reject(&:blank?)
 
     assembled = chat.stream_assistant_response(prompt_execution, jwt_token, tool_ids: tool_ids, generation_settings: generation_settings) do |event|
+      # Accumulate before forwarding so a write failure (ClientDisconnected)
+      # doesn't drop the delta we just received.
+      partial << event[:data]["delta"].to_s if event[:event] == "message"
+
       if event[:event] == "tool_calls"
         tool_calls = event[:data]["tool_calls"] || []
         forward(event: "tool_calls", data: {
@@ -54,7 +65,8 @@ class ChatStreamsController < ApplicationController
 
     forward(event: "done", data: {})
   rescue ActionController::Live::ClientDisconnected
-    Rails.logger.info "[ChatStream] client disconnected"
+    Rails.logger.info "[ChatStream] client disconnected (partial=#{partial.length} chars)"
+    persist_partial(chat, prompt_execution, partial, jwt_token)
   rescue ActiveRecord::RecordNotFound
     forward(event: "error", data: { code: "not_found", message: "Chat or prompt execution not found" }) rescue nil
   rescue StandardError => e
@@ -66,6 +78,16 @@ class ChatStreamsController < ApplicationController
 
   private
 
+  # Best-effort save of the partial content the user already saw when they
+  # cancelled mid-stream. Skips if there's nothing to save or required
+  # context wasn't established before the disconnect.
+  def persist_partial(chat, prompt_execution, partial, jwt_token)
+    return unless chat && prompt_execution && partial.present?
+    chat.finalize_streamed_response(prompt_execution, partial, jwt_token)
+  rescue StandardError => e
+    Rails.logger.warn "[ChatStream] persist_partial failed: #{e.class}: #{e.message}"
+  end
+
   def find_chat
     scope = user_signed_in? ? current_user.chats : Chat.where(user_id: nil)
     scope.find_by!(uuid: params[:chat_id])

data/lib/generators/llm_meta_client/scaffold/templates/app/controllers/chats_controller.rb

@@ -4,21 +4,21 @@ class ChatsController < ApplicationController
   include PromptNavigator::HistoryManageable
   # Allow access without login
   skip_before_action :authenticate_user!, raise: false
-  before_action :authenticate_user!, only: [ :update_title, :download_csv, :download_all_csv ]
+  before_action :authenticate_user!, only: [ :update_title, :download_csv, :download_selected_csv, :batch_destroy ]
 
   def show
     # Initialize chat context
     initialize_chat current_user&.chats
 
     @chat = current_user&.chats.includes(:messages).find_by!(uuid: params[:id])
-    session[:chat_id] = @chat.id
+    set_active_chat_uuid(@chat&.uuid)
     @messages = @chat.ordered_messages
 
     # Initialize history
     initialize_history @chat.ordered_by_descending_prompt_executions
 
     # Get LLM options available for users
-    jwt_token = current_user.id_token if user_signed_in?
+    jwt_token = current_user.jwt_token if user_signed_in?
     @llm_families = LlmMetaClient::ServerResource.available_llm_families(jwt_token)
 
     # Set active UUID for history sidebar highlighting
@@ -32,19 +32,15 @@ class ChatsController < ApplicationController
   end
 
   def new
+    # Pure new-chat form. No chat row is created until the user actually
+    # submits, and nothing is read from session — so opening "/" in a second
+    # tab can never surface a previously-active chat from another tab.
     initialize_chat current_user&.chats
-    # Find current conversation or create it on create method if not found
-    @chat = Chat.find_or_switch_for_session(
-      session,
-      current_user
-    )
-    add_chat @chat
-    @messages = @chat&.ordered_messages || []
-    # initialize history for the chat
-    initialize_history @chat&.ordered_by_descending_prompt_executions
+    @chat = nil
+    @messages = []
+    initialize_history []
 
-    # Get LLM options available for users
-    jwt_token = current_user.id_token if user_signed_in?
+    jwt_token = current_user.jwt_token if user_signed_in?
     @llm_families = LlmMetaClient::ServerResource.available_llm_families(jwt_token)
   rescue StandardError => e
     Rails.logger.error "Error in ChatsController#new: #{e.class} - #{e.message}\n#{e.backtrace&.join("\n")}"
@@ -53,17 +49,17 @@ class ChatsController < ApplicationController
   end
 
   def create
-    jwt_token = current_user.id_token if user_signed_in?
+    jwt_token = current_user.jwt_token if user_signed_in?
 
     # Initialize chat sidebar
     initialize_chat current_user&.chats
 
-    # Find or create chat
-    @chat = Chat.find_or_switch_for_session(
-      session,
-      current_user
-    )
+    # Always create a new chat — URL/form is the source of truth for chat
+    # identity, not session[:chat_id]. This makes the entry point tab-safe:
+    # cross-tab navigation can no longer rewrite the "current chat" under us.
+    @chat = Chat.create!(user: current_user)
     add_chat @chat
+    set_active_chat_uuid(@chat&.uuid)
     @messages = @chat&.ordered_messages || []
 
     # initialize history for the chat
@@ -87,7 +83,9 @@ class ChatsController < ApplicationController
       @prompt_execution, @user_message = @chat.add_user_message(params[:message],
                                                                 params[:api_key_uuid],
                                                                 params[:model],
-                                                                params[:branch_from_uuid])
+                                                                params[:branch_from_uuid],
+                                                                llm_platform: params[:family],
+                                                                image: uploaded_image_payload)
       # Push to history for rendering
       push_to_history @prompt_execution
       # Set active message UUID for highlighting in UI
@@ -107,6 +105,33 @@ class ChatsController < ApplicationController
     end
   end
 
+  def destroy
+    scope = user_signed_in? ? current_user.chats : Chat.where(user_id: nil)
+    chat = scope.find_by(uuid: params[:id])
+    # "Currently viewing this chat" is now identified by the URL the user
+    # came from (referrer), since chat identity is URL-local, not session.
+    was_viewed = chat && request.referer.to_s.include?("/chats/#{chat.uuid}")
+    chat&.destroy
+
+    initialize_chat(user_signed_in? ? current_user.chats : nil)
+
+    if was_viewed
+      redirect_to root_path
+    else
+      respond_to do |format|
+        format.turbo_stream
+        format.html { redirect_to root_path }
+      end
+    end
+  end
+
+  def batch_destroy
+    scope = user_signed_in? ? current_user.chats : Chat.where(user_id: nil)
+    uuids = Array(params[:uuids]).reject(&:blank?)
+    scope.where(uuid: uuids).destroy_all
+    redirect_to root_path
+  end
+
   def update_title
     chat = current_user.chats.find_by!(uuid: params[:id])
     title = params[:title].to_s.strip
@@ -126,102 +151,93 @@ class ChatsController < ApplicationController
   end
 
   def start_new
-    session.delete(:chat_id)
     redirect_to root_path
   end
 
-  def edit
-    # Initialize chat context
-    initialize_chat current_user&.chats
-
-    # Get LLM options available for users
-    jwt_token = current_user.id_token if user_signed_in?
-    @llm_families = LlmMetaClient::ServerResource.available_llm_families(jwt_token)
+  # Add a prompt to a specific chat identified by URL uuid. This is the
+  # tab-safe entry point: chat identity comes from the URL, not session, so
+  # navigation in another tab can never re-target the prompt.
+  def add_prompt
+    jwt_token = current_user.jwt_token if user_signed_in?
 
-    @chat = Chat.find_or_switch_for_session(
-      session,
-      current_user
-    )
-    @messages = @chat&.ordered_messages || []
-    # initialize history for the chat
-    initialize_history @chat&.ordered_by_descending_prompt_executions
-    # Set active message UUID for highlighting in UI
-    set_active_message_uuid(params.dig(:chat, :branch_from_uuid))
-  rescue StandardError => e
-    Rails.logger.error "Error in ChatsController#edit: #{e.class} - #{e.message}\n#{e.backtrace&.join("\n")}"
-    @llm_families = []
-    flash.now[:alert] = "Chat service is currently unavailable. Please try again later."
-  end
+    scope = user_signed_in? ? current_user.chats : Chat.where(user_id: nil)
+    @chat = scope.find_by!(uuid: params[:id])
 
-  def update
-    jwt_token = current_user.id_token if user_signed_in?
-
-    # Use the chat identified by the URL, not the session
-    @chat = current_user.chats.find(params[:id])
-    session[:chat_id] = @chat.id
+    initialize_chat current_user&.chats
+    add_chat @chat
+    set_active_chat_uuid(@chat&.uuid)
     @messages = @chat&.ordered_messages || []
-    # initialize history for the chat
     initialize_history @chat&.ordered_by_descending_prompt_executions
 
     if params[:message].present?
-      # Validate generation settings before proceeding (raises if invalid).
-      # The streaming controller re-parses them from the URL.
       begin
         generation_settings_param
       rescue InvalidGenerationSettingsError => e
         @error_message = e.message
         respond_to do |format|
-          format.turbo_stream
-          format.html { redirect_to chat_path(@chat), alert: e.message }
+          format.turbo_stream { render :create }
+          format.html { redirect_to chat_path(@chat.uuid), alert: e.message }
         end
         return
       end
 
-      # Add user message (will be rendered via turbo stream)
       @prompt_execution, @user_message = @chat.add_user_message(params[:message],
-                                                               params[:api_key_uuid],
-                                                               params[:model],
-                                                               params[:branch_from_uuid])
-      # Push to history for rendering
+                                                                params[:api_key_uuid],
+                                                                params[:model],
+                                                                params[:branch_from_uuid],
+                                                                llm_platform: params[:family],
+                                                                image: uploaded_image_payload)
       push_to_history @prompt_execution
-      # Set active message UUID for highlighting in UI
       set_active_message_uuid(@prompt_execution&.execution_id || params.dig(:chat, :branch_from_uuid))
 
-      # The assistant response is streamed by ChatStreamsController (SSE).
-      # See create action for details.
       @generation_settings_json = params[:generation_settings_json]
       @tool_ids = Array(params[:tool_ids]).reject(&:blank?)
     end
 
-    # Return turbo stream to render both messages
+    @llm_families = LlmMetaClient::ServerResource.available_llm_families(jwt_token) rescue []
+
     respond_to do |format|
-      format.turbo_stream
-      format.html { redirect_to new_chat_path }
+      format.turbo_stream { render :create }
+      format.html { redirect_to chat_path(@chat.uuid) }
     end
+  rescue ActiveRecord::RecordNotFound
+    redirect_to root_path, alert: "Chat not found."
   end
 
   private
 
-  ALLOWED_GENERATION_KEYS = %w[temperature top_k top_p max_tokens repeat_penalty].freeze
+  MAX_IMAGE_BYTES = 8 * 1024 * 1024 # 8 MB
 
   class InvalidGenerationSettingsError < StandardError; end
 
+  # Read params[:image] (multipart upload) and return a transport-ready hash
+  # `{mime:, data_b64:}` or nil if absent / invalid. Validation is lenient:
+  # caller's add_user_message just embeds the data URI; the server enforces
+  # vision-model compatibility.
+  def uploaded_image_payload
+    upload = params[:image]
+    return nil if upload.blank? || !upload.respond_to?(:read)
+    bytes = upload.read
+    return nil if bytes.blank? || bytes.bytesize > MAX_IMAGE_BYTES
+    mime = upload.content_type.to_s
+    mime = "application/octet-stream" if mime.empty?
+    { mime: mime, data_b64: Base64.strict_encode64(bytes) }
+  rescue StandardError => e
+    Rails.logger.warn "Image upload read failed: #{e.class}: #{e.message}"
+    nil
+  end
+
+  # Pass-through generation settings: accept any JSON object. Values can be
+  # numbers, booleans, strings, or nested hashes (e.g. Ollama's `options`).
+  # The provider gem / upstream API decides which keys it understands;
+  # unknown keys are typically ignored by the provider.
   def generation_settings_param
     return {} if params[:generation_settings_json].blank?
 
     parsed = JSON.parse(params[:generation_settings_json])
     raise InvalidGenerationSettingsError, "Generation settings must be a JSON object" unless parsed.is_a?(Hash)
 
-    settings = parsed.slice(*ALLOWED_GENERATION_KEYS)
-    invalid_keys = parsed.keys - ALLOWED_GENERATION_KEYS
-    raise InvalidGenerationSettingsError, "Unknown keys: #{invalid_keys.join(', ')}" if invalid_keys.any?
-
-    non_numeric = settings.reject { |_k, v| v.is_a?(Numeric) }
-    if non_numeric.any?
-      raise InvalidGenerationSettingsError, "Values must be numeric: #{non_numeric.keys.join(', ')}"
-    end
-
-    settings.symbolize_keys
+    parsed.deep_symbolize_keys
   rescue JSON::ParserError => e
     raise InvalidGenerationSettingsError, "Invalid JSON: #{e.message}"
   end

data/lib/generators/llm_meta_client/scaffold/templates/app/controllers/prompts_controller.rb

@@ -16,7 +16,7 @@ class PromptsController < ApplicationController
     initialize_history @chat.ordered_by_descending_prompt_executions
 
     # Get LLM options available for users
-    jwt_token = current_user.id_token if user_signed_in?
+    jwt_token = current_user.jwt_token if user_signed_in?
     @llm_families = LlmMetaClient::ServerResource.available_llm_families(jwt_token)
 
     # Set the target message ID for scrolling
@@ -33,4 +33,31 @@ class PromptsController < ApplicationController
     Rails.logger.error "Error in PromptsController#show_by_uuid: #{e.class} - #{e.message}\n#{e.backtrace&.join("\n")}"
     redirect_to root_path, alert: "Message not found."
   end
+
+  # Leaf-only delete. Re-checks leaf status server-side (a branch could have
+  # been added after the page rendered) so the tree can never be corrupted.
+  def destroy
+    pe = PromptNavigator::PromptExecution.find_by!(execution_id: params[:id])
+    scope = user_signed_in? ? current_user.chats : Chat.where(user_id: nil)
+    chat = Message.where(prompt_navigator_prompt_execution_id: pe.id).first&.chat
+
+    unless chat && scope.exists?(id: chat.id)
+      redirect_to(root_path, alert: "Prompt not found.")
+      return
+    end
+
+    if PromptNavigator::PromptExecution.where(previous_id: pe.id).exists?
+      redirect_to(prompt_path(pe.execution_id), alert: "Cannot delete: this prompt has follow-up branches.")
+      return
+    end
+
+    ActiveRecord::Base.transaction do
+      Message.where(prompt_navigator_prompt_execution_id: pe.id).delete_all
+      pe.delete
+    end
+
+    redirect_to chat_path(chat.uuid), notice: "Prompt deleted."
+  rescue ActiveRecord::RecordNotFound
+    redirect_to root_path, alert: "Prompt not found."
+  end
 end

data/lib/generators/llm_meta_client/scaffold/templates/app/javascript/controllers/asset_actions_controller.js

@@ -0,0 +1,98 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Connects to data-controller="asset-actions"
+//
+// Powers the Download / Copy buttons rendered next to assistant-generated
+// assets (images and copyable code blocks — JSON, CSV). Markup is emitted
+// by ApplicationHelper::AssistantResponseRenderer.
+//
+// Values:
+//   kindValue       — "image" or "text"; chooses copy/download strategy
+//   hrefValue       — for kind=image, the image src (data URL or http)
+//   filenameValue   — suggested download filename
+//   mimeValue       — for kind=text, the MIME type of the generated Blob
+export default class extends Controller {
+  static values = {
+    kind: { type: String, default: "text" },
+    href: { type: String, default: "" },
+    filename: { type: String, default: "download" },
+    mime: { type: String, default: "text/plain" },
+  }
+
+  async download(event) {
+    const btn = event.currentTarget
+    try {
+      if (this.kindValue === "image") {
+        this.#triggerDownload(this.hrefValue, this.filenameValue)
+      } else {
+        const text = this.#extractText()
+        const blob = new Blob([text], { type: this.mimeValue })
+        const url = URL.createObjectURL(blob)
+        this.#triggerDownload(url, this.filenameValue)
+        // Yield a tick before revoking so the browser has time to start
+        // the download — Blob URLs revoked too eagerly cancel the file.
+        setTimeout(() => URL.revokeObjectURL(url), 1000)
+      }
+      this.#flashOk(btn)
+    } catch (e) {
+      console.error("[asset-actions] download failed", e)
+      this.#flashFail(btn)
+    }
+  }
+
+  async copyText(event) {
+    const btn = event.currentTarget
+    try {
+      await navigator.clipboard.writeText(this.#extractText())
+      this.#flashOk(btn)
+    } catch (e) {
+      console.error("[asset-actions] copyText failed", e)
+      this.#flashFail(btn)
+    }
+  }
+
+  async copyImage(event) {
+    const btn = event.currentTarget
+    try {
+      const resp = await fetch(this.hrefValue)
+      const blob = await resp.blob()
+      if (typeof ClipboardItem === "undefined") {
+        throw new Error("ClipboardItem unsupported in this browser")
+      }
+      await navigator.clipboard.write([
+        new ClipboardItem({ [blob.type]: blob }),
+      ])
+      this.#flashOk(btn)
+    } catch (e) {
+      console.error("[asset-actions] copyImage failed", e)
+      this.#flashFail(btn)
+    }
+  }
+
+  #triggerDownload(href, filename) {
+    const a = document.createElement("a")
+    a.href = href
+    a.download = filename
+    document.body.appendChild(a)
+    a.click()
+    a.remove()
+  }
+
+  #extractText() {
+    const code = this.element.querySelector("code")
+    return (code ? code.textContent : this.element.textContent) || ""
+  }
+
+  // Brief icon flip so the user sees the click registered. 1.2s is long
+  // enough to read, short enough to not collide with a second click.
+  #flashOk(btn)  { this.#flashIcon(btn, "bi-check-lg") }
+  #flashFail(btn) { this.#flashIcon(btn, "bi-exclamation-circle") }
+
+  #flashIcon(btn, replacementClass) {
+    const icon = btn?.querySelector("i")
+    if (!icon) return
+    const original = icon.className
+    icon.className = `bi ${replacementClass}`
+    setTimeout(() => { icon.className = original }, 1200)
+  }
+}