openclacky 1.2.5 → 1.2.7

data/lib/clacky/providers.rb

@@ -31,6 +31,7 @@ module Clacky
         "api" => "bedrock",
         "default_model" => "abs-claude-sonnet-4-6",
         "models" => [
+          "abs-claude-opus-4-8",
           "abs-claude-opus-4-7",
           "abs-claude-opus-4-6",
           "abs-claude-sonnet-4-6",
@@ -61,6 +62,7 @@ module Clacky
         # sibling wired up (yet) on this provider; subagents using the
         # Gemini default will just reuse it for lite work until we add one.
         "lite_models" => {
+          "abs-claude-opus-4-8"   => "abs-claude-haiku-4-5",
           "abs-claude-opus-4-7"   => "abs-claude-haiku-4-5",
           "abs-claude-opus-4-6"   => "abs-claude-haiku-4-5",
           "abs-claude-sonnet-4-6" => "abs-claude-haiku-4-5",
@@ -88,6 +90,7 @@ module Clacky
         # ID manually; this list only seeds the picker.
         "models" => [
           "anthropic/claude-sonnet-4-6",
+          "anthropic/claude-opus-4-8",
           "anthropic/claude-opus-4-7",
           "anthropic/claude-opus-4-6",
           "anthropic/claude-haiku-4-5",
@@ -101,6 +104,7 @@ module Clacky
         # cheap/fast sidekick automatically.
         "lite_models" => {
           "anthropic/claude-sonnet-4-6" => "anthropic/claude-haiku-4-5",
+          "anthropic/claude-opus-4-8"   => "anthropic/claude-haiku-4-5",
           "anthropic/claude-opus-4-7"   => "anthropic/claude-haiku-4-5",
           "anthropic/claude-opus-4-6"   => "anthropic/claude-haiku-4-5",
           "openai/gpt-5.5"              => "openai/gpt-5.4-mini",
@@ -232,38 +236,11 @@ module Clacky
         "name" => "Anthropic (Claude)",
         "base_url" => "https://api.anthropic.com",
         "api" => "anthropic-messages",
-        "default_model" => "claude-sonnet-4.6",
-        "models" => ["claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-4.6", "claude-haiku-4.5"],
+        "default_model" => "claude-sonnet-4-6",
+        "models" => ["claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5"],
         "website_url" => "https://console.anthropic.com/settings/keys"
       }.freeze,
 
-      "clackyai-sea" => {
-        "name" => "ClackyAI(Sea)",
-        "base_url" => "https://api.clacky.ai",
-        "api" => "bedrock",
-        "default_model" => "abs-claude-sonnet-4-5",
-        "models" => [
-          "abs-claude-opus-4-6",
-          "abs-claude-sonnet-4-6",
-          "abs-claude-sonnet-4-5",
-          "abs-claude-haiku-4-5"
-        ],
-        # Claude family — all vision-capable.
-        "capabilities" => { "vision" => true }.freeze,
-        # Per-primary lite pairing — see openclacky preset for rationale.
-        "lite_models" => {
-          "abs-claude-opus-4-6"   => "abs-claude-haiku-4-5",
-          "abs-claude-sonnet-4-6" => "abs-claude-haiku-4-5",
-          "abs-claude-sonnet-4-5" => "abs-claude-haiku-4-5"
-        },
-        # Fallback chain: if a model is unavailable, try the next one in order.
-        # Keys are primary model names; values are the fallback model to use instead.
-        "fallback_models" => {
-          "abs-claude-sonnet-4-6" => "abs-claude-sonnet-4-5"
-        },
-        "website_url" => "https://clacky.ai"
-      }.freeze,
-
       "mimo" => {
         "name" => "MiMo (Xiaomi)",
         "base_url" => "https://api.xiaomimimo.com/v1",
@@ -572,6 +549,11 @@ module Clacky
           return "openclacky"
         end
 
+        if base_url.is_a?(String) &&
+           base_url.match?(%r{\Ahttps?://(localhost|127\.0\.0\.1|0\.0\.0\.0)(:|/|\z)}i)
+          return "openclacky"
+        end
+
         nil
       end
 

data/lib/clacky/server/channel/channel_manager.rb

@@ -234,7 +234,7 @@ module Clacky
         return if (text.nil? || text.empty?) && files.empty?
 
         # Handle built-in commands
-        if text&.start_with?("/")
+        if text&.match?(KNOWN_COMMAND) || text&.match?(/\A([\?h]|help)\z/i)
           handle_command(adapter, event, text)
           return
         end
@@ -249,7 +249,8 @@ module Clacky
           return
         end
 
-        Clacky::Logger.info("[ChannelManager] Routing to session #{session_id[0, 8]} (status=#{session[:status]})")
+        sub_count = web_ui_for_session_diag(session_id)
+        Clacky::Logger.info("[ChannelManager] Routing to session #{session_id[0, 8]} (status=#{session[:status]}, text=#{text.inspect}, channel_subs=#{sub_count})")
 
         # If session is running, interrupt it automatically (mimics CLI behavior)
         if session[:status] == :running
@@ -283,7 +284,12 @@ module Clacky
 
         @run_agent_task.call(session_id, agent) do
           begin
+            Clacky::Logger.info("[ChannelManager] agent.run START session=#{session_id[0, 8]} text=#{text.inspect}")
             agent.run(text, files: files)
+            Clacky::Logger.info("[ChannelManager] agent.run END   session=#{session_id[0, 8]} text=#{text.inspect}")
+          rescue StandardError => e
+            Clacky::Logger.error("[ChannelManager] agent.run RAISED session=#{session_id[0, 8]} #{e.class}: #{e.message}\n#{e.backtrace.first(8).join("\n")}")
+            raise
           ensure
             adapter.stop_typing_keepalive(chat_id) if adapter.respond_to?(:stop_typing_keepalive)
           end
@@ -295,11 +301,24 @@ module Clacky
         key     = channel_key(event)
 
         case text
+        when /\A([\?h]|help)\z/i
+          adapter.send_text(chat_id, COMMAND_HELP)
+
+        when "/new", "/clear"
+          session_id = auto_create_session(adapter, event)
+          adapter.send_text(chat_id, "New session `#{session_id[0, 8]}` created.") if session_id
+
+        when /\A\/model\b/i
+          handle_model_command(adapter, event, text)
+
+        when /\A\/skills\b/i
+          handle_skills_command(adapter, event)
+
         when /\A\/bind\s+(\S+)\z/i
           arg = Regexp.last_match(1)
           # Support numeric index from /list (1-based)
           session_id = if arg =~ /\A\d+\z/
-            recent = @registry.list.last(5).reverse
+            recent = @registry.list.first(5)
             idx = arg.to_i - 1
             recent[idx]&.fetch(:id, nil)
           else
@@ -351,7 +370,9 @@ module Clacky
           session_id = resolve_session(event)
           if session_id
             session = @registry.get(session_id)
-            adapter.send_text(chat_id, "Bound to session `#{session_id[0, 8]}` (status: #{session&.dig(:status) || "unknown"})")
+            model = session&.dig(:agent)&.current_model_info
+            model_name = model&.dig(:model) || "unknown"
+            adapter.send_text(chat_id, "Bound to session `#{session_id[0, 8]}` (status: #{session&.dig(:status) || "unknown"}, model: #{model_name})")
           else
             adapter.send_text(chat_id, "No session bound yet. Send any message to auto-create one.")
           end
@@ -360,16 +381,118 @@ module Clacky
           list_sessions(adapter, chat_id)
 
         else
-          adapter.send_text(chat_id,
-            "Commands:\n" \
-            "  /bind <n|session_id> - switch to a session (use /list to see numbers)\n" \
-            "  /unbind - remove binding\n" \
-            "  /stop - interrupt current task\n" \
-            "  /status - show current binding\n" \
-            "  /list - show recent sessions")
+          adapter.send_text(chat_id, "Unknown command. Type ? for help.")
         end
       end
 
+      KNOWN_COMMAND = %r{\A/(new|clear|model|skills|bind|stop|unbind|status|list)\b}i
+
+      COMMAND_HELP = <<~HELP.strip
+        Commands:
+          ? / h / help - show this help
+          /new / /clear - start a new session
+          /model - show current model & available models
+          /model <n> - switch to model n
+          /skills - list available skills
+          /<skill> <args> - invoke a skill directly
+          /bind <n|session_id> - switch to a session (use /list to see numbers)
+          /unbind - remove binding
+          /stop - interrupt current task
+          /status - show current binding
+          /list - show recent sessions
+      HELP
+
+      def handle_model_command(adapter, event, text)
+        chat_id   = event[:chat_id]
+        session_id = resolve_session(event)
+
+        unless session_id
+          adapter.send_text(chat_id, "No session bound. Send any message to auto-create one first.")
+          return
+        end
+
+        session = @registry.get(session_id)
+        agent = session&.dig(:agent)
+        unless agent
+          adapter.send_text(chat_id, "Session not ready.")
+          return
+        end
+
+        arg = text.sub(/\A\/model\s*/i, "").strip
+
+        if arg.empty?
+          # Show current model and available list
+          info = agent.current_model_info
+          current = info&.dig(:model) || "unknown"
+          sub     = info&.dig(:sub_model)
+          card    = info&.dig(:card_model)
+          header  = "Current model: #{current}"
+          header += " (#{card} · #{sub})" if card && sub && sub != current
+          header += " (#{card})" if card && !sub
+
+          models = agent.available_models
+          if models.empty?
+            adapter.send_text(chat_id, "#{header}\nNo other models available.")
+            return
+          end
+
+          lines = models.each_with_index.map do |name, i|
+            marker = name == current ? " *" : ""
+            "#{i + 1}. #{name}#{marker}"
+          end
+          adapter.send_text(chat_id, "#{header}\n\nSwitch with /model <n>:\n#{lines.join("\n")}")
+        elsif arg =~ /\A\d+\z/
+          idx = arg.to_i - 1
+          models = agent.config.models
+          if idx < 0 || idx >= models.length
+            adapter.send_text(chat_id, "Invalid model number. Use /model to see available models.")
+            return
+          end
+
+          model_id = models[idx]["id"]
+          if agent.switch_model_by_id(model_id)
+            new_info = agent.current_model_info
+            adapter.send_text(chat_id, "Switched to #{new_info&.dig(:model) || model_id}.")
+          else
+            adapter.send_text(chat_id, "Failed to switch model.")
+          end
+        else
+          adapter.send_text(chat_id, "Usage: /model to list, /model <n> to switch.")
+        end
+      end
+
+      def handle_skills_command(adapter, event)
+        chat_id    = event[:chat_id]
+        session_id = resolve_session(event)
+
+        unless session_id
+          adapter.send_text(chat_id, "No session bound. Send any message to auto-create one first.")
+          return
+        end
+
+        session = @registry.get(session_id)
+        agent = session&.dig(:agent)
+        unless agent
+          adapter.send_text(chat_id, "Session not ready.")
+          return
+        end
+
+        skills = agent.skill_loader.user_invocable_skills
+          .reject { |s| s.source == :default }
+          .first(10)
+        if skills.empty?
+          adapter.send_text(chat_id, "No skills available.")
+          return
+        end
+
+        lines = skills.each_with_index.map do |s, i|
+          desc = s.description.to_s.strip
+          desc = desc.empty? ? "(no description)" : desc.length > 50 ? "#{desc[0..49]}..." : desc
+          "#{i + 1}. #{s.name} - #{desc}"
+        end
+        adapter.send_text(chat_id, "Skills:\n#{lines.join("\n")}")
+      end
+
       def resolve_session(event)
         key = channel_key(event)
         @registry.list.each do |summary|
@@ -411,6 +534,19 @@ module Clacky
         result
       end
 
+      def web_ui_for_session_diag(session_id)
+        result = nil
+        @registry.with_session(session_id) do |s|
+          ui = s[:ui]
+          result = if ui.respond_to?(:channel_subscribed?)
+            ui.instance_variable_get(:@channel_subscribers)&.size || 0
+          else
+            -1
+          end
+        end
+        result
+      end
+
       def bind_key_to_session(key, session_id)
         @registry.list.each do |summary|
           @registry.with_session(summary[:id]) { |s| s[:channel_keys]&.delete(key) }
@@ -422,7 +558,7 @@ module Clacky
       end
 
       def list_sessions(adapter, chat_id)
-        sessions = @registry.list.last(5).reverse
+        sessions = @registry.list.first(5)
         if sessions.empty?
           adapter.send_text(chat_id, "No sessions available.")
           return

data/lib/clacky/server/channel/channel_ui_controller.rb

@@ -145,8 +145,10 @@ module Clacky
         send_text("Warning: #{message}")
       end
 
-      def show_error(message)
-        send_text("Error: #{message}")
+      def show_error(message, code: nil, top_up_url: nil)
+        text = "Error: #{message}"
+        text += "\n#{top_up_url}" if top_up_url
+        send_text(text)
       end
 
       def show_success(message)

data/lib/clacky/server/http_server.rb

@@ -436,6 +436,7 @@ module Clacky
         when ["GET",    "/api/billing/summary"]   then api_billing_summary(req, res)
         when ["GET",    "/api/billing/daily"]     then api_billing_daily(req, res)
         when ["GET",    "/api/billing/records"]   then api_billing_records(req, res)
+        when ["DELETE", "/api/billing/clear"]     then api_billing_clear(req, res)
         when ["PATCH",  "/api/sessions/:id/model"] then api_switch_session_model(req, res)
         when ["PATCH",  "/api/sessions/:id/working_dir"] then api_change_session_working_dir(req, res)
         else
@@ -480,6 +481,9 @@ module Clacky
           elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/skills$})
             session_id = path.sub("/api/sessions/", "").sub("/skills", "")
             api_session_skills(session_id, res)
+          elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/files$})
+            session_id = path.sub("/api/sessions/", "").sub("/files", "")
+            api_session_files(session_id, req, res)
           elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/export$})
             session_id = path.sub("/api/sessions/", "").sub("/export", "")
             api_export_session(session_id, res)
@@ -495,6 +499,9 @@ module Clacky
           elsif method == "PATCH" && path.match?(%r{^/api/sessions/[^/]+/reasoning_effort$})
             session_id = path.sub("/api/sessions/", "").sub("/reasoning_effort", "")
             api_switch_session_reasoning_effort(session_id, req, res)
+          elsif method == "PATCH" && path.match?(%r{^/api/sessions/[^/]+/submodel$})
+            session_id = path.sub("/api/sessions/", "").sub("/submodel", "")
+            api_switch_session_submodel(session_id, req, res)
           elsif method == "POST" && path.match?(%r{^/api/sessions/[^/]+/benchmark$})
             session_id = path.sub("/api/sessions/", "").sub("/benchmark", "")
             api_benchmark_session_models(session_id, req, res)
@@ -1113,30 +1120,32 @@ module Clacky
 
       # GET /api/billing/summary
       # Returns billing summary for a time period
-      # Query params: period (day|week|month|year|all, default: month)
+      # Query params: period (day|week|month|year|all, default: month), model (optional)
       def api_billing_summary(req, res)
         require_relative "../billing/billing_store"
 
         query  = URI.decode_www_form(req.query_string.to_s).to_h
         period = (query["period"] || "month").to_sym
+        model  = query["model"]
 
         store   = Clacky::Billing::BillingStore.new
-        summary = store.summary(period: period)
+        summary = store.summary(period: period, model: model)
 
         json_response(res, 200, summary)
       end
 
       # GET /api/billing/daily
       # Returns daily cost breakdown
-      # Query params: days (default: 30)
+      # Query params: days (default: 30), model (optional)
       def api_billing_daily(req, res)
         require_relative "../billing/billing_store"
 
         query = URI.decode_www_form(req.query_string.to_s).to_h
         days  = [(query["days"] || "30").to_i, 90].min
+        model = query["model"]
 
         store = Clacky::Billing::BillingStore.new
-        daily = store.daily_breakdown(days: days)
+        daily = store.daily_breakdown(days: days, model: model)
 
         json_response(res, 200, { days: daily })
       end
@@ -1161,6 +1170,23 @@ module Clacky
         })
       end
 
+      # DELETE /api/billing/clear
+      # Clears billing records
+      # Query params: scope (today|all, default: today)
+      def api_billing_clear(req, res)
+        require_relative "../billing/billing_store"
+
+        query = URI.decode_www_form(req.query_string.to_s).to_h
+        scope = query["scope"] || "today"
+
+        store = Clacky::Billing::BillingStore.new
+        deleted = store.clear(scope: scope.to_sym)
+
+        json_response(res, 200, { ok: true, deleted: deleted, scope: scope })
+      rescue => e
+        json_response(res, 500, { error: e.message })
+      end
+
       # GET /api/version
       # Returns current version and latest version from RubyGems (cached for 1 hour).
       def api_get_version(res)
@@ -2425,7 +2451,56 @@ module Clacky
         json_response(res, 200, { skills: skill_data })
       end
 
-      # PATCH /api/skills/:name/toggle — enable or disable a skill
+      # GET /api/sessions/:id/files?path=<relative dir>
+      # Lists one directory level inside the session's working_dir (lazy, per-layer).
+      # Path traversal outside working_dir is rejected. Noisy dirs are hidden.
+      IGNORED_FILE_ENTRIES = %w[.git .svn .hg node_modules .DS_Store .bundle vendor/bundle tmp .sass-cache].freeze
+
+      def api_session_files(session_id, req, res)
+        unless @registry.ensure(session_id)
+          return json_response(res, 404, { error: "Session not found" })
+        end
+        session = @registry.get(session_id)
+        agent   = session && session[:agent]
+        return json_response(res, 404, { error: "Session not found" }) unless agent
+
+        root = File.expand_path(agent.working_dir.to_s)
+        return json_response(res, 404, { error: "Working directory not found" }) unless Dir.exist?(root)
+
+        rel = URI.decode_www_form(req.query_string.to_s).to_h["path"].to_s
+        rel = rel.sub(%r{\A/+}, "").strip
+        target = File.expand_path(File.join(root, rel))
+
+        # Reject traversal outside the working directory.
+        unless target == root || target.start_with?("#{root}/")
+          return json_response(res, 403, { error: "Path outside working directory" })
+        end
+        return json_response(res, 404, { error: "Directory not found" }) unless Dir.exist?(target)
+
+        entries = Dir.children(target).reject { |name| IGNORED_FILE_ENTRIES.include?(name) }
+
+        items = entries.filter_map do |name|
+          full = File.join(target, name)
+          is_dir = File.directory?(full)
+          # Skip symlinks pointing outside the root, and anything unreadable.
+          next unless File.exist?(full)
+          {
+            name:  name,
+            path:  rel.empty? ? name : "#{rel}/#{name}",
+            type:  is_dir ? "dir" : "file",
+            size:  is_dir ? nil : (File.size(full) rescue nil)
+          }
+        rescue StandardError
+          nil
+        end
+
+        # Directories first, then files; both case-insensitive alphabetical.
+        items.sort_by! { |it| [it[:type] == "dir" ? 0 : 1, it[:name].downcase] }
+
+        json_response(res, 200, { root: root, path: rel, entries: items })
+      rescue StandardError => e
+        json_response(res, 500, { error: e.message })
+      end
       # Body: { enabled: true/false }
       def api_toggle_skill(name, req, res)
         body    = parse_json_body(req)
@@ -3581,6 +3656,47 @@ module Clacky
         json_response(res, 500, { error: e.message })
       end
 
+      # PATCH /api/sessions/:id/submodel
+      # Body: { "model_name": "dsk-deepseek-v4-pro" | null }
+      #
+      # Pin this session to a sub-model under its current card without
+      # touching credentials or the global @models. Pass null/empty to clear
+      # and fall back to the card default. The name must appear in the
+      # provider preset's "models" list — anything else is rejected.
+      def api_switch_session_submodel(session_id, req, res)
+        body = parse_json_body(req)
+        raw = body["model_name"]
+        model_name = raw.is_a?(String) ? raw.strip : nil
+
+        return json_response(res, 404, { error: "Session not found" }) unless @registry.ensure(session_id)
+
+        agent = nil
+        @registry.with_session(session_id) { |s| agent = s[:agent] }
+        return json_response(res, 404, { error: "Session not found" }) unless agent
+
+        if model_name && !model_name.empty?
+          info = agent.current_model_info
+          provider_id = info && Clacky::Providers.find_by_base_url(info[:base_url])
+          allowed = provider_id ? Clacky::Providers.models(provider_id) : []
+          if allowed.empty?
+            return json_response(res, 400, { error: "Current model has no provider preset; sub-model switching unavailable" })
+          end
+          unless allowed.include?(model_name)
+            return json_response(res, 400, { error: "Sub-model '#{model_name}' not listed under provider '#{provider_id}'" })
+          end
+        else
+          model_name = nil
+        end
+
+        agent.set_session_sub_model(model_name)
+        @session_manager.save(agent.to_session_data)
+        broadcast_session_update(session_id)
+
+        json_response(res, 200, { ok: true, sub_model: agent.current_model_info[:sub_model] })
+      rescue => e
+        json_response(res, 500, { error: e.message })
+      end
+
       # POST /api/sessions/:id/benchmark
       #
       # Speed-test every configured model in one shot so the user can pick the
@@ -3686,11 +3802,9 @@ module Clacky
 
         # Expand ~ to home directory
         expanded_dir = File.expand_path(new_dir)
-        
-        # Validate directory exists
-        unless Dir.exist?(expanded_dir)
-          return json_response(res, 400, { error: "Directory does not exist: #{expanded_dir}" })
-        end
+
+        # Auto-create the directory if it doesn't exist yet.
+        FileUtils.mkdir_p(expanded_dir)
 
         agent = nil
         @registry.with_session(session_id) { |s| agent = s[:agent] }
@@ -4169,12 +4283,18 @@ module Clacky
           broadcast(session_id, { type: "interrupted", session_id: session_id })
           @session_manager.save(agent.to_session_data(status: :interrupted))
         rescue => e
-          @registry.update(session_id, status: :error, error: e.message)
-          broadcast_session_update(session_id)
           # Route error through web_ui so channel subscribers (飞书/企微) receive it too.
           web_ui = nil
           @registry.with_session(session_id) { |s| web_ui = s[:ui] }
-          web_ui&.show_error(e.message)
+          code = e.is_a?(Clacky::InsufficientCreditError) ? e.error_code : nil
+          top_up_url = nil
+          if e.is_a?(Clacky::InsufficientCreditError) && e.provider_id
+            preset = Clacky::Providers::PRESETS[e.provider_id]
+            top_up_url = preset && preset["website_url"]
+          end
+          @registry.update(session_id, status: :error, error: e.message, error_code: code, top_up_url: top_up_url)
+          broadcast_session_update(session_id)
+          web_ui&.show_error(e.message, code: code, top_up_url: top_up_url)
           @session_manager.save(agent.to_session_data(status: :error, error_message: e.message))
         end
         @registry.with_session(session_id) { |s| s[:thread] = thread }

data/lib/clacky/server/session_registry.rb

@@ -40,6 +40,8 @@ module Clacky
           id:                   session_id,
           status:               :idle,
           error:                nil,
+          error_code:           nil,
+          top_up_url:           nil,
           updated_at:           Time.now,
           agent:                nil,
           ui:                   nil,
@@ -166,11 +168,15 @@ module Clacky
             live_name  = s[:agent]&.name
             live_name  = nil if live_name&.empty?
           live_cost_source = s[:agent]&.cost_source
-          { status: s[:status], error: s[:error], model: model_info&.dig(:model), model_id: model_info&.dig(:id), name: live_name,
+          { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url],
+            model: model_info&.dig(:model), model_id: model_info&.dig(:id), name: live_name,
             total_tasks: s[:agent]&.total_tasks, total_cost: s[:agent]&.total_cost,
             cost_source: live_cost_source,
             reasoning_effort: s[:agent]&.reasoning_effort,
-            latest_latency: s[:agent]&.latest_latency }
+            latest_latency: s[:agent]&.latest_latency,
+            card_model: model_info&.dig(:card_model),
+            sub_model: model_info&.dig(:sub_model),
+            sub_model_options: sub_model_options_for(model_info) }
           end
         end
 
@@ -239,11 +245,15 @@ module Clacky
           model_info = s[:agent]&.current_model_info
           live_name  = s[:agent]&.name
           live_name  = nil if live_name&.empty?
-          { status: s[:status], error: s[:error], model: model_info&.dig(:model), model_id: model_info&.dig(:id),
+          { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url],
+            model: model_info&.dig(:model), model_id: model_info&.dig(:id),
             name: live_name, total_tasks: s[:agent]&.total_tasks,
             total_cost: s[:agent]&.total_cost, cost_source: s[:agent]&.cost_source,
             reasoning_effort: s[:agent]&.reasoning_effort,
-            latest_latency: s[:agent]&.latest_latency }
+            latest_latency: s[:agent]&.latest_latency,
+            card_model: model_info&.dig(:card_model),
+            sub_model: model_info&.dig(:sub_model),
+            sub_model_options: sub_model_options_for(model_info) }
         end
 
         build_enriched_row(disk, live)
@@ -259,8 +269,13 @@ module Clacky
           name:          ls&.dig(:name) || s[:name] || "",
           status:        ls ? ls[:status].to_s : "idle",
           error:         ls ? ls[:error] : nil,
+          error_code:    ls&.dig(:error_code),
+          top_up_url:    ls&.dig(:top_up_url),
           model:         ls&.dig(:model),
           model_id:      ls&.dig(:model_id),
+          card_model:    ls&.dig(:card_model),
+          sub_model:     ls&.dig(:sub_model),
+          sub_model_options: ls&.dig(:sub_model_options) || [],
           source:        s_source(s),
           agent_profile: (s[:agent_profile] || "general").to_s,
           working_dir:   s[:working_dir],
@@ -280,6 +295,17 @@ module Clacky
       end
 
 
+      # Look up the provider preset for the session's current card and
+      # return the sub-model list. Empty when the card's base_url isn't
+      # in any preset (e.g. self-hosted custom endpoints) — the WebUI
+      # treats that as "no sub-model switcher available".
+      private def sub_model_options_for(model_info)
+        return [] unless model_info && model_info[:base_url]
+        provider_id = Clacky::Providers.find_by_base_url(model_info[:base_url])
+        return [] unless provider_id
+        Clacky::Providers.models(provider_id)
+      end
+
       # Normalize source field from a disk session hash.
       # "system" is a legacy value renamed to "setup" — treat them as equivalent.
       def s_source(s)

data/lib/clacky/server/web_ui_controller.rb

@@ -210,9 +210,12 @@ module Clacky
         forward_to_subscribers { |sub| sub.show_warning(message) }
       end
 
-      def show_error(message)
-        emit("error", message: message)
-        forward_to_subscribers { |sub| sub.show_error(message) }
+      def show_error(message, code: nil, top_up_url: nil)
+        payload = { message: message }
+        payload[:code] = code if code
+        payload[:top_up_url] = top_up_url if top_up_url
+        emit("error", **payload)
+        forward_to_subscribers { |sub| sub.show_error(message, code: code, top_up_url: top_up_url) }
       end
 
       def show_success(message)