openclacky 1.0.4 → 1.1.0

data/lib/clacky/default_skills/channel-manager/discord_setup.rb

@@ -0,0 +1,199 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# discord_setup.rb — Discord channel setup helper.
+#
+# Discord's developer portal requires manual interaction (hCaptcha + private API), so the
+# Agent uses the browser only as a container — it navigates to the portal and the user
+# creates the App manually, then pastes back the bot token and application id. This
+# script handles everything a shell can do: emit the portal URL, validate the token
+# against /users/@me, save to the clacky server, generate the OAuth2 invite URL, and
+# poll until the bot is in at least one guild.
+#
+# Modes:
+#   --portal-url                Print the Discord developer portal URL (stdout, single line)
+#   --validate <token>          Validate bot_token via /users/@me, then POST to server
+#   --invite-url <client_id>    Print the OAuth2 invite URL (stdout, single line)
+#   --watch-guild               Long-poll /users/@me/guilds via the saved token
+#                               until at least one guild appears (or timeout)
+#   --bot-info <token>          Print {id, username} JSON for an unsaved token
+#
+# Environment:
+#   CLACKY_SERVER_HOST  default 127.0.0.1
+#   CLACKY_SERVER_PORT  default 7070
+
+require "json"
+require "net/http"
+require "net/https"
+require "uri"
+require "openssl"
+require "cgi"
+require "yaml"
+
+DISCORD_API_BASE      = "https://discord.com/api/v10"
+DISCORD_OAUTH_BASE    = "https://discord.com/oauth2/authorize"
+DISCORD_PORTAL_URL    = "https://discord.com/developers/applications"
+DEFAULT_BOT_PERMS     = "274877990912"
+DEFAULT_BOT_SCOPES    = "bot applications.commands"
+WATCH_GUILD_DEADLINE  = 10 * 60
+WATCH_GUILD_INTERVAL  = 3
+USER_AGENT            = "DiscordBot (https://github.com/clackyai/openclacky, 1.0)"
+
+CLACKY_SERVER_URL = begin
+  host = ENV.fetch("CLACKY_SERVER_HOST", "127.0.0.1")
+  port = ENV.fetch("CLACKY_SERVER_PORT", "7070")
+  "http://#{host}:#{port}"
+end
+
+def step(msg);  $stderr.puts("[discord-setup] #{msg}"); end
+def ok(msg);    $stderr.puts("[discord-setup] #{msg}"); end
+def warn!(msg); $stderr.puts("[discord-setup] #{msg}"); end
+
+def fail!(msg, json: false)
+  if json
+    $stdout.puts(JSON.generate({ error: msg }))
+  else
+    $stderr.puts("[discord-setup] #{msg}")
+  end
+  exit 1
+end
+
+def discord_get(path, bot_token:, timeout: 15)
+  uri  = URI("#{DISCORD_API_BASE}#{path}")
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.use_ssl      = true
+  http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
+  http.read_timeout = timeout
+  http.open_timeout = 10
+
+  req = Net::HTTP::Get.new(uri.request_uri)
+  req["Authorization"] = "Bot #{bot_token}"
+  req["User-Agent"]    = USER_AGENT
+  req["Accept"]        = "application/json"
+
+  res    = http.request(req)
+  body   = res.body.to_s
+  parsed = (JSON.parse(body) rescue nil)
+
+  unless res.is_a?(Net::HTTPSuccess)
+    msg = parsed.is_a?(Hash) ? (parsed["message"] || body.slice(0, 200)) : body.slice(0, 200)
+    raise "Discord HTTP #{res.code} #{path}: #{msg}"
+  end
+  parsed
+end
+
+def saved_bot_token
+  yml_path = File.expand_path("~/.clacky/channels.yml")
+  return nil unless File.exist?(yml_path)
+  data = YAML.safe_load_file(yml_path, permitted_classes: [Symbol], aliases: true) rescue nil
+  data&.dig("channels", "discord", "bot_token") || data&.dig(:channels, :discord, :bot_token)
+end
+
+def save_to_server(bot_token:)
+  uri  = URI("#{CLACKY_SERVER_URL}/api/channels/discord")
+  body = JSON.generate({ bot_token: bot_token })
+
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.read_timeout = 30
+  http.open_timeout = 5
+
+  req = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
+  req.body = body
+
+  res  = http.request(req)
+  data = JSON.parse(res.body) rescue {}
+
+  unless res.is_a?(Net::HTTPSuccess) && data["ok"]
+    fail!("Failed to save Discord config: #{data["error"] || res.body.slice(0, 200)}")
+  end
+end
+
+mode_idx = ARGV.index { |a| a.start_with?("--") }
+mode     = mode_idx ? ARGV[mode_idx] : nil
+arg      = mode_idx ? ARGV[mode_idx + 1] : nil
+
+case mode
+when "--portal-url"
+  $stdout.puts(DISCORD_PORTAL_URL)
+  exit 0
+
+when "--validate"
+  fail!("--validate requires <bot_token>") if arg.to_s.strip.empty?
+  bot_token = arg.strip
+  step("Validating bot token against Discord API...")
+  begin
+    me = discord_get("/users/@me", bot_token: bot_token)
+  rescue => e
+    fail!("Token validation failed: #{e.message}")
+  end
+
+  bot_id   = me["id"].to_s
+  username = me["username"].to_s
+  fail!("Empty bot id from /users/@me") if bot_id.empty?
+
+  ok("Authenticated as #{username} (id=#{bot_id})")
+  step("Saving credentials via clacky server...")
+  save_to_server(bot_token: bot_token)
+  ok("Discord channel configured")
+
+  $stdout.puts(JSON.generate({ bot_id: bot_id, username: username }))
+  exit 0
+
+when "--bot-info"
+  fail!("--bot-info requires <bot_token>", json: true) if arg.to_s.strip.empty?
+  begin
+    me = discord_get("/users/@me", bot_token: arg.strip)
+  rescue => e
+    fail!(e.message, json: true)
+  end
+  $stdout.puts(JSON.generate({ bot_id: me["id"], username: me["username"] }))
+  exit 0
+
+when "--invite-url"
+  fail!("--invite-url requires <client_id>") if arg.to_s.strip.empty?
+  client_id = arg.strip
+  url = "#{DISCORD_OAUTH_BASE}?client_id=#{CGI.escape(client_id)}" \
+        "&permissions=#{DEFAULT_BOT_PERMS}" \
+        "&scope=#{CGI.escape(DEFAULT_BOT_SCOPES)}"
+  $stdout.puts(url)
+  exit 0
+
+when "--watch-guild"
+  bot_token = saved_bot_token
+  fail!("No saved bot_token in ~/.clacky/channels.yml — run --validate first") if bot_token.to_s.empty?
+
+  step("Waiting for the bot to be added to a guild (timeout: #{WATCH_GUILD_DEADLINE / 60} min)...")
+  deadline = Time.now + WATCH_GUILD_DEADLINE
+
+  loop do
+    fail!("Timed out waiting for the bot to join a guild. Open the invite URL again to retry.") if Time.now > deadline
+
+    begin
+      guilds = discord_get("/users/@me/guilds", bot_token: bot_token)
+    rescue => e
+      warn!("Poll error (will retry): #{e.message}")
+      sleep WATCH_GUILD_INTERVAL
+      next
+    end
+
+    if guilds.is_a?(Array) && !guilds.empty?
+      g = guilds.first
+      ok("Bot added to guild: #{g["name"]} (id=#{g["id"]})")
+      $stdout.puts(JSON.generate({ guild_id: g["id"], guild_name: g["name"], total: guilds.length }))
+      exit 0
+    end
+
+    sleep WATCH_GUILD_INTERVAL
+  end
+
+else
+  $stderr.puts(<<~USAGE)
+    Usage:
+      ruby discord_setup.rb --portal-url
+      ruby discord_setup.rb --validate <bot_token>
+      ruby discord_setup.rb --bot-info <bot_token>
+      ruby discord_setup.rb --invite-url <client_id>
+      ruby discord_setup.rb --watch-guild
+  USAGE
+  exit 1
+end

data/lib/clacky/default_skills/channel-manager/install_feishu_skills.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'json'
+
+require_relative '../skill-add/scripts/install_from_zip'
+
+# Install Feishu-related skills from the openclacky platform.
+#
+# Calls GET /api/v1/skills/feishu — same payload shape as /api/v1/skills/builtin:
+#   { "skills": [{ "name": "lark-doc", "download_url": "https://..." }, ...] }
+#
+# Each skill is installed sequentially via ZipSkillInstaller into ~/.clacky/skills/<name>/.
+#
+# Usage:
+#   ruby install_feishu_skills.rb
+#
+# Output:
+#   Diagnostics  → STDERR
+#   Last line    → JSON: {"installed":N,"attempted":N}
+#   Exit code    → always 0
+
+class FeishuSkillsInstaller
+  PRIMARY_HOST     = ENV.fetch('CLACKY_LICENSE_SERVER', 'https://www.openclacky.com')
+  FALLBACK_HOST    = 'https://openclacky.up.railway.app'
+  API_HOSTS        = ENV['CLACKY_LICENSE_SERVER'] ? [PRIMARY_HOST] : [PRIMARY_HOST, FALLBACK_HOST]
+  API_PATH         = '/api/v1/skills/feishu'
+  API_OPEN_TIMEOUT = 5
+  API_READ_TIMEOUT = 10
+
+  def initialize
+    @target_dir = File.join(Dir.home, '.clacky', 'skills')
+    @installed  = 0
+    @attempted  = 0
+    @errors     = []
+  end
+
+  def run
+    skills = fetch_skill_list
+    if skills.nil? || skills.empty?
+      emit_summary
+      return
+    end
+
+    skills.each { |skill| install_one(skill) }
+  ensure
+    emit_summary
+  end
+
+  private def fetch_skill_list
+    API_HOSTS.each do |host|
+      begin
+        uri = URI.parse(host + API_PATH)
+        Net::HTTP.start(uri.host, uri.port,
+                        use_ssl:      uri.scheme == 'https',
+                        open_timeout: API_OPEN_TIMEOUT,
+                        read_timeout: API_READ_TIMEOUT) do |http|
+          response = http.request(Net::HTTP::Get.new(uri.request_uri))
+          if response.code.to_i == 200
+            payload = JSON.parse(response.body)
+            return Array(payload['skills'])
+          else
+            @errors << "API #{host}: HTTP #{response.code}"
+          end
+        end
+      rescue StandardError => e
+        @errors << "API #{host}: #{e.class}: #{e.message}"
+      end
+    end
+    nil
+  end
+
+  private def install_one(skill)
+    name         = skill['name'].to_s
+    download_url = skill['download_url'].to_s
+    @attempted  += 1
+
+    if name.empty? || download_url.empty?
+      @errors << "skill payload missing name or download_url: #{skill.inspect}"
+      return
+    end
+
+    result = ZipSkillInstaller.new(
+      download_url,
+      skill_name:     name,
+      target_dir:     @target_dir,
+      skip_if_exists: false
+    ).perform
+    @installed += result[:installed].size
+    @errors.concat(result[:errors]) if result[:errors].any?
+  rescue StandardError => e
+    @errors << "#{name}: #{e.class}: #{e.message}"
+  end
+
+  private def emit_summary
+    unless @errors.empty?
+      warn '[install-feishu-skills] non-fatal errors:'
+      @errors.each { |e| warn "  - #{e}" }
+    end
+    puts JSON.generate(installed: @installed, attempted: @attempted)
+  end
+end
+
+FeishuSkillsInstaller.new.run if __FILE__ == $0

data/lib/clacky/default_skills/onboard/SKILL.md

@@ -226,8 +226,8 @@ If `yes`:
 1. `ruby "SKILL_DIR/scripts/import_external_skills.rb" --source openclaw --dry-run`
 2. Parse the skill count N.
 3. Ask via `request_user_feedback`:
-   - zh: `{ "question": "检测到你安装过 OpenClaw，找到 N 个 Skills，导入到 Clacky 直接使用？", "options": ["导入", "跳过"] }`
-   - en: `{ "question": "OpenClaw detected. Found N skills. Import them into Clacky?", "options": ["Import", "Skip"] }`
+   - zh: `{ "question": "检测到你安装过 OpenClaw，找到 N 个 Skills。现在建议跳过，后续使用 /skill-add 按需安装。", "options": ["全部导入", "跳过"] }`
+   - en: `{ "question": "OpenClaw detected. Found N skills. We recommend skipping for now and installing only what you need later with /skill-add.", "options": ["Import all", "Skip"] }`
 4. If confirmed: `ruby "SKILL_DIR/scripts/import_external_skills.rb" --source openclaw --yes`
 
 ### A.11. Celebrate soul setup & offer browser

data/lib/clacky/default_skills/onboard/scripts/import_external_skills.rb

@@ -8,7 +8,7 @@ require 'pathname'
 #
 # Supported sources:
 #   - OpenClaw: ~/.openclaw/skills/, ~/.openclaw/workspace/skills/,
-#               ~/.agents/skills/, ~/.openclaw/workspace/.agents/skills/
+#               ~/.openclaw/workspace/.agents/skills/
 #
 # Each source is imported into a dedicated category subdirectory under ~/.clacky/skills/,
 # e.g. ~/.clacky/skills/openclaw-imports/<skill-name>/. This keeps imported skills
@@ -178,16 +178,14 @@ class OpenClawImporter < ExternalSkillsImporter
   # Returns all directories that may contain OpenClaw skills.
   # Each entry is a hash: { root: Pathname, layout: :flat }
   #
-  # Mirrors the four sources from hermes openclaw_to_hermes.py:
+  # Mirrors the sources from hermes openclaw_to_hermes.py:
   #   - ~/.openclaw/workspace/skills/             (workspace skills)
   #   - ~/.openclaw/skills/                        (managed/shared skills)
-  #   - ~/.agents/skills/                          (personal cross-project skills)
   #   - ~/.openclaw/workspace/.agents/skills/      (project-level shared skills)
   private def source_dirs
     [
       @openclaw_dir.join('workspace', 'skills'),
       @openclaw_dir.join('skills'),
-      Pathname.new(Dir.home).join('.agents', 'skills'),
       @openclaw_dir.join('workspace', '.agents', 'skills')
     ].select(&:exist?)
   end

data/lib/clacky/default_skills/onboard/scripts/install_builtin_skills.rb

@@ -1,29 +1,10 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# Install builtin skills into ~/.clacky/skills/.
-#
-# Fetches the server-curated builtin list from GET /api/v1/skills/builtin on
-# the openclacky platform (public, no auth), then downloads and installs each
-# skill's zip package in parallel (5 workers, 30s total timeout).
-#
-# The "builtin" whitelist is enforced server-side — this script takes no
-# filter flags. Admin toggles the `builtin` flag per skill on the platform.
-#
-# Called by onboard skill: `ruby install_builtin_skills.rb`
-#
-# Output:
-#   - Diagnostics → STDERR
-#   - Last line of STDOUT → JSON: {"installed":N,"attempted":N,"skipped_existing":N}
-#   - Exit code: always 0
-
 require 'uri'
 require 'net/http'
 require 'json'
-require 'timeout'
 
-# Reuse the downloader/extractor/installer from the skill-add skill.
-# Physical relocation to lib/clacky/ is deferred until a third caller appears.
 require_relative '../../skill-add/scripts/install_from_zip'
 
 class BuiltinSkillsInstaller
@@ -33,18 +14,13 @@ class BuiltinSkillsInstaller
   API_PATH         = '/api/v1/skills/builtin'
   API_OPEN_TIMEOUT = 5
   API_READ_TIMEOUT = 10
-  CONCURRENCY      = 5
 
   def initialize
-    @target_dir        = File.join(Dir.home, '.clacky', 'skills')
-    @per_skill_timeout = 10
-    @total_timeout     = 30
-
-    @installed         = 0
-    @skipped_existing  = 0
-    @attempted         = 0
-    @errors            = []
-    @mutex             = Mutex.new
+    @target_dir       = File.join(Dir.home, '.clacky', 'skills')
+    @installed        = 0
+    @skipped_existing = 0
+    @attempted        = 0
+    @errors           = []
   end
 
   def run
@@ -54,14 +30,11 @@ class BuiltinSkillsInstaller
       return
     end
 
-    install_concurrently(skills)
+    skills.each { |skill| install_one(skill) }
   ensure
     emit_summary
   end
 
-  # --- Internals -------------------------------------------------------------
-
-  # Returns an array of skill hashes, or nil on total failure.
   private def fetch_skill_list
     API_HOSTS.each do |host|
       begin
@@ -85,79 +58,29 @@ class BuiltinSkillsInstaller
     nil
   end
 
-  # Install skills in parallel, bounded by CONCURRENCY and @total_timeout.
-  # Workers pull from a shared queue and self-check the deadline, so the
-  # global timeout is enforced without killing threads mid-download (which
-  # would leak temp dirs). Whatever finishes before the deadline stays
-  # installed; the rest is recovered on the next onboard run via skip_if_exists.
-  private def install_concurrently(skills)
-    queue = Queue.new
-    skills.each { |s| queue << s }
-
-    deadline    = Time.now + @total_timeout
-    worker_pool = [CONCURRENCY, skills.size].min
-
-    workers = Array.new(worker_pool) do
-      Thread.new do
-        loop do
-          break if Time.now >= deadline
-          skill = queue.pop(true) rescue nil    # non-blocking pop
-          break if skill.nil?
-          install_one(skill)
-        end
-      end
-    end
-
-    workers.each(&:join)
-
-    # If the deadline cut us off with items still in the queue, record it.
-    remaining = queue.size
-    if remaining.positive?
-      @mutex.synchronize do
-        @errors << "overall timeout after #{@total_timeout}s " \
-                   "(installed=#{@installed}, attempted=#{@attempted}, remaining=#{remaining})"
-      end
-    end
-  end
-
-  # Install one skill entry (hash from the API payload).
-  # Bounded by @per_skill_timeout; any failure is swallowed into @errors.
-  # Thread-safe: all shared state writes go through @mutex.
   private def install_one(skill)
     name         = skill['name'].to_s
     download_url = skill['download_url'].to_s
-
-    @mutex.synchronize { @attempted += 1 }
+    @attempted  += 1
 
     if name.empty? || download_url.empty?
-      @mutex.synchronize do
-        @errors << "skill payload missing name or download_url: #{skill.inspect}"
-      end
+      @errors << "skill payload missing name or download_url: #{skill.inspect}"
       return
     end
 
-    Timeout.timeout(@per_skill_timeout) do
-      installer = ZipSkillInstaller.new(
-        download_url,
-        skill_name:     name,
-        target_dir:     @target_dir,
-        skip_if_exists: true
-      )
-      result = installer.perform
-      @mutex.synchronize do
-        @installed        += result[:installed].size
-        @skipped_existing += result[:skipped].size
-        @errors.concat(result[:errors]) if result[:errors].any?
-      end
-    end
-  rescue Timeout::Error
-    @mutex.synchronize { @errors << "#{name}: install timeout after #{@per_skill_timeout}s" }
+    result = ZipSkillInstaller.new(
+      download_url,
+      skill_name:     name,
+      target_dir:     @target_dir,
+      skip_if_exists: true
+    ).perform
+    @installed        += result[:installed].size
+    @skipped_existing += result[:skipped].size
+    @errors.concat(result[:errors]) if result[:errors].any?
   rescue StandardError => e
-    @mutex.synchronize { @errors << "#{name}: #{e.class}: #{e.message}" }
+    @errors << "#{name}: #{e.class}: #{e.message}"
   end
 
-  # Diagnostics to stderr; single-line JSON summary to stdout.
-  # The caller (onboard) should parse the LAST stdout line.
   private def emit_summary
     unless @errors.empty?
       warn '[install_builtin_skills] non-fatal errors:'
@@ -171,5 +94,4 @@ class BuiltinSkillsInstaller
   end
 end
 
-# ── Entry point ───────────────────────────────────────────────────────────────
 BuiltinSkillsInstaller.new.run if __FILE__ == $0

data/lib/clacky/default_skills/product-help/SKILL.md

@@ -91,9 +91,11 @@ web_fetch(url: "<URL>", max_length: 5000)
 - If still no answer, tell the user: "请访问 https://www.openclacky.com/docs 查看完整文档"
 - Keep answers concise — extract what's relevant, don't paste the whole page
 
-## Restarting the server
+## Server restart, upgrade, and downgrade
 
-If the user asks to restart the clacky/openclacky server (e.g. "重启", "restart", "请重启openclacky"):
+### Normal restart
+
+If the user asks to restart the server normally (e.g. "重启", "restart", "请重启openclacky") — without mentioning failure or errors:
 
 **Do NOT fetch any docs.** Just return this answer directly:
 
@@ -103,3 +105,9 @@ If the user asks to restart the clacky/openclacky server (e.g. "重启", "restar
 > ```
 > This sends USR1 to the Master process, which spawns a new Worker and gracefully stops the old one.
 > The `$CLACKY_MASTER_PID` environment variable is already set in the current session.
+
+### Restart failure, upgrade failure, or downgrade
+
+If the user mentions restart failure, upgrade failure, or how to downgrade (e.g. "重启失败", "升级失败", "降级", "restart failed", "upgrade failed", "downgrade", "如何降级"):
+
+→ Fetch the FAQ page: `https://www.openclacky.com/docs/faq` — it has a dedicated Troubleshooting section covering all three scenarios.

data/lib/clacky/message_history.rb

@@ -193,7 +193,7 @@ module Clacky
     #   thinking inline (e.g. MiniMax: <think>...</think> in content), so
     #   this bypass lets us recover on the retry without a server restart.
     def to_api(force_reasoning_content_pad: false)
-      msgs = @messages.map { |m| strip_internal_fields(m) }
+      msgs = @messages.map { |m| strip_for_api(m) }
       ensure_reasoning_content_consistency(msgs, force: force_reasoning_content_pad)
     end
 
@@ -248,6 +248,31 @@ module Clacky
       @messages.pop
     end
 
+    private def strip_for_api(message)
+      msg = strip_internal_fields(message)
+      content = msg[:content]
+      return msg unless content.is_a?(Array)
+
+      cleaned = content.filter_map do |block|
+        next block unless block.is_a?(Hash)
+
+        if block[:type] == "image_url" &&
+            block.dig(:image_url, :url) == "[image stripped]"
+          next nil
+        end
+
+        block.key?(:image_path) ? block.reject { |k, _| k == :image_path } : block
+      end
+
+      return msg if cleaned == content
+
+      if cleaned.empty?
+        msg.merge(content: "[images were shown to you in a previous turn]")
+      else
+        msg.merge(content: cleaned)
+      end
+    end
+
     private def strip_internal_fields(message)
       message.reject { |k, _| INTERNAL_FIELDS.include?(k) }
     end

data/lib/clacky/providers.rb

@@ -29,7 +29,7 @@ module Clacky
         "name" => "OpenClacky",
         "base_url" => "https://api.openclacky.com",
         "api" => "bedrock",
-        "default_model" => "abs-claude-sonnet-4-5",
+        "default_model" => "abs-claude-sonnet-4-6",
         "models" => [
           "abs-claude-opus-4-7",
           "abs-claude-opus-4-6",
@@ -80,7 +80,32 @@ module Clacky
         "base_url" => "https://openrouter.ai/api/v1",
         "api" => "openai-responses",
         "default_model" => "anthropic/claude-sonnet-4-6",
-        "models" => [],  # Dynamic - fetched from API
+        # Curated default lineup. OpenRouter's full catalogue is enormous
+        # (hundreds of models) and the live /models endpoint isn't always
+        # reachable from every region — shipping a small list of the
+        # mainstream Claude + GPT entries gives users a working dropdown
+        # out of the box. Users can still type any other OpenRouter model
+        # ID manually; this list only seeds the picker.
+        "models" => [
+          "anthropic/claude-sonnet-4-6",
+          "anthropic/claude-opus-4-7",
+          "anthropic/claude-opus-4-6",
+          "anthropic/claude-haiku-4-5",
+          "openai/gpt-5.5",
+          "openai/gpt-5.4",
+          "openai/gpt-5.4-mini"
+        ],
+        # Per-primary lite pairing — Claude family pairs with Haiku, GPT
+        # family pairs with the mini variant. Mirrors the openclacky and
+        # openai presets above so subagents on OpenRouter get a sensible
+        # cheap/fast sidekick automatically.
+        "lite_models" => {
+          "anthropic/claude-sonnet-4-6" => "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",
+          "openai/gpt-5.4"              => "openai/gpt-5.4-mini"
+        },
         # Per-model API type overrides. Matched by Regexp against the model name.
         # Why this exists: OpenRouter proxies Claude via both its OpenAI-compatible
         # /chat/completions endpoint AND a native Anthropic /v1/messages endpoint.
@@ -243,8 +268,8 @@ module Clacky
         "name" => "MiMo (Xiaomi)",
         "base_url" => "https://api.xiaomimimo.com/v1",
         "api" => "openai-completions",
-        "default_model" => "mimo-v2-pro",
-        "models" => ["mimo-v2-pro", "mimo-v2-omni"],
+        "default_model" => "mimo-v2.5-pro",
+        "models" => ["mimo-v2.5-pro", "mimo-v2-pro", "mimo-v2-omni"],
         # MiMo-V2-Pro is text-only; MiMo-V2-Omni supports vision (omni = multimodal).
         "capabilities" => { "vision" => false }.freeze,
         "model_capabilities" => {