openclacky 1.5.2 → 1.5.4

data/lib/clacky/brand_config.rb

@@ -383,16 +383,16 @@ module Clacky
 
     # Returns true when a public distribution refresh is due.
     #
-    # Refresh is needed only when the install has a package_name configured
-    # but is not yet activated — activated licenses already get fresh
-    # distribution data via #heartbeat! (once per 24h).
+    # Refresh is needed for unactivated branded installs and for private
+    # platform sources that have not supplied their deployment brand yet.
+    # Activated licenses already get fresh distribution data via #heartbeat!.
     #
     # Rate limit: once every HEARTBEAT_INTERVAL (24h), measured from the last
     # SUCCESSFUL refresh. A failed refresh does not advance the clock so we'll
     # keep trying on subsequent startups / status polls.
     def distribution_refresh_due?
-      return false unless branded?
       return false if activated?
+      return false unless branded? || private_platform_source?
       return true  if @distribution_last_refreshed_at.nil?
 
       elapsed = Time.now.utc - @distribution_last_refreshed_at
@@ -400,7 +400,8 @@ module Clacky
     end
 
     # Refresh public brand assets (logo, theme, homepage_url, support_*) for
-    # installs that have `package_name` configured but no activated license yet.
+    # unactivated installs. Package installs use an exact package lookup;
+    # private platform sources without a local brand use the source default.
     #
     # Motivation: `install.sh --brand-name=X --command=X` only writes
     # product_name + package_name to brand.yml. The rest of the distribution
@@ -409,32 +410,47 @@ module Clacky
     # anonymous public lookup endpoint.
     #
     # Behaviour:
-    #   * No-op (returns { success: false, message: "..." }) when not branded,
-    #     already activated, or package_name is blank.
+    #   * No-op when already activated, or when neither a package_name nor a
+    #     private platform source is available.
     #   * On success: apply_distribution + save + stamp
     #     @distribution_last_refreshed_at.
+    #   * When a block is provided, discard the response unless it still
+    #     confirms that the platform source is current.
     #   * On failure: log and return without touching the timestamp (so we
     #     retry on next trigger).
     #
     # Returns { success: Boolean, message: String }.
     def refresh_distribution!
-      unless branded?
+      source_brand_lookup = private_platform_source? &&
+                            (@package_name.nil? || @package_name.strip.empty?)
+      unless branded? || source_brand_lookup
         return { success: false, message: "Not branded" }
       end
       if activated?
         return { success: false, message: "License activated — use heartbeat! instead" }
       end
-      if @package_name.nil? || @package_name.strip.empty?
+      if !source_brand_lookup && (@package_name.nil? || @package_name.strip.empty?)
         return { success: false, message: "package_name not configured" }
       end
 
-      encoded_pkg = URI.encode_www_form_component(@package_name.strip)
-      path        = "/api/v1/distributions/lookup?package_name=#{encoded_pkg}"
+      if source_brand_lookup
+        path = "/api/v1/distributions/lookup"
+      else
+        encoded_pkg = URI.encode_www_form_component(@package_name.strip)
+        path = "/api/v1/distributions/lookup?package_name=#{encoded_pkg}"
+      end
 
-      Clacky::Logger.info("[Brand] refresh_distribution! fetching — package_name=#{@package_name}")
+      Clacky::Logger.info(
+        "[Brand] refresh_distribution! fetching — package_name=#{@package_name || "source-default"}"
+      )
       response = platform_client.get(path)
 
       if response[:success] && response[:data].is_a?(Hash) && response[:data]["distribution"].is_a?(Hash)
+        if block_given? && !yield
+          Clacky::Logger.info("[Brand] refresh_distribution! discarded — platform source changed")
+          return { success: false, message: "Platform source changed during refresh" }
+        end
+
         apply_distribution(response[:data]["distribution"])
         @distribution_last_refreshed_at = Time.now.utc
         save
@@ -1762,6 +1778,10 @@ module Clacky
       @homepage_url    = dist["homepage_url"]     if dist.key?("homepage_url")
     end
 
+    private def private_platform_source?
+      !ENV["CLACKY_LICENSE_SERVER"].to_s.strip.empty?
+    end
+
     # Download a remote URL to a local file path.
     #
     # Deprecated: this method now delegates to

data/lib/clacky/client.rb

@@ -337,6 +337,13 @@ module Clacky
     # ── OpenAI request / response ─────────────────────────────────────────────
 
     def send_openai_request(messages, model, tools, max_tokens, caching_enabled, reasoning_effort: nil, on_chunk: nil, capability_model: nil)
+      # Override max_tokens when the model declares a higher output ceiling
+      # in Providers::MODEL_MAX_OUTPUT. Without this, strong models (GLM-5.2,
+      # Kimi-K3, MiMo-V2.5) are throttled to the 16K global default.
+      model_for_limit = capability_model || model
+      model_limit = Providers.max_output_for(model_for_limit)
+      max_tokens = model_limit if model_limit
+
       # Apply cache_control markers to messages when caching is enabled.
       # OpenRouter proxies Claude with the same cache_control field convention as Anthropic direct.
       messages = apply_message_caching(messages) if caching_enabled

data/lib/clacky/default_extensions/ext-studio/agents/ext-developer/system_prompt.md

@@ -143,3 +143,18 @@ main product, and apply every rule below whenever you propose or write code:
   Ruby and carry supply-chain risk.
 - After editing `view.js`, `handler.rb`, or a `SKILL.md`, tell the user to reload the
   WebUI page — hot reload is per-request, no restart needed.
+- After you finish editing extension files, call this once at the very end to trigger
+  a reload button in the UI (if it doesn't appear, the user can manually refresh the browser):
+  ```
+  curl -s --noproxy '*' -X POST "http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/ui/show_ext_refresh" \
+    -H "Content-Type: application/json" \
+    -d "{\"session_id\": \"${CLACKY_SESSION_ID}\"}"
+  ```
+  (`--noproxy '*'` prevents shell proxy env vars from silently intercepting this loopback call.)
+- If the extension contributes a `session.aside` panel, also call this right after the above
+  to open the panel automatically:
+  ```
+  curl -s --noproxy '*' -X POST "http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/ui/open_aside" \
+    -H "Content-Type: application/json" \
+    -d "{\"session_id\": \"${CLACKY_SESSION_ID}\"}"
+  ```

data/lib/clacky/default_extensions/ext-studio/api/handler.rb

@@ -201,11 +201,7 @@ class ExtStudioExt < Clacky::ApiExtension
       error!("extension not found: #{ext_id}", status: 404) unless container
 
       readme_path = File.join(container[:dir], "README.md")
-      if readme.strip.empty?
-        File.delete(readme_path) if File.exist?(readme_path)
-      else
-        File.write(readme_path, readme, encoding: "utf-8")
-      end
+      File.write(readme_path, readme, encoding: "utf-8")
     end
 
     json(ok: true, ext_id: ext_id, saved_to: published ? "platform" : "local")
@@ -362,7 +358,7 @@ class ExtStudioExt < Clacky::ApiExtension
   post "/develop" do
     idea = presence(json_body["idea"])
     name = idea ? "扩展开发: #{idea[0, 40]}" : "扩展开发"
-    sid  = create_session(name: name, prompt: idea, profile: "ext-developer", source: :setup)
+    sid  = create_session(name: name, prompt: idea, profile: "ext-developer")
     json(ok: true, session_id: sid)
   end
 

data/lib/clacky/default_extensions/ext-studio/panels/studio/view.js

@@ -1539,7 +1539,7 @@
         let data = {};
         try { data = await res.json(); } catch (_e) {}
         if (!res.ok) throw new Error(data?.error || `Error ${res.status}`);
-        await reload(); rebuild();
+        location.reload();
       } catch (e) {
         alert(t("err.generic", { msg: e.message }));
         btn.disabled = false;
@@ -1957,7 +1957,7 @@
     .studio-form-status { font-size: 12px; color: var(--color-text-tertiary); }
     .studio-btn-sm { padding: 4px 10px; font-size: 12px; }
     .studio-readme-overlay { align-items: center; justify-content: center; }
-    .studio-readme-modal { width: min(1200px, calc(100vw - 48px)); height: calc(100vh - 80px); max-width: calc(100vw - 48px); border-radius: var(--radius-md, 8px); margin: 0; padding: 24px 28px 20px; display: flex; flex-direction: column; }
+    .studio-readme-modal { max-width: 1280px; width: 98%; height: 90vh; max-height: 960px; border-radius: var(--radius-md, 8px); margin: 0; padding: 24px 28px 20px; display: flex; flex-direction: column; }
     .studio-readme-modal .studio-modal-title { margin-bottom: 16px; flex-shrink: 0; }
     .studio-readme-split { display: flex; gap: 14px; flex: 1; min-height: 0; margin-bottom: 18px; }
     .studio-readme-pane { flex: 1; display: flex; flex-direction: column; min-width: 0; }
@@ -1965,13 +1965,20 @@
     .studio-readme-textarea { flex: 1; resize: none; font-family: monospace; font-size: 12.5px; line-height: 1.65; border-radius: var(--radius-sm); }
     .studio-readme-preview { flex: 1; overflow-y: auto; overflow-x: hidden; border: 1px solid var(--color-border-primary); border-radius: var(--radius-sm); padding: 12px 16px; background: var(--color-bg-secondary); font-size: 13px; line-height: 1.75; }
     .studio-readme-preview > *:first-child { margin-top: 0; }
-    .studio-readme-preview img { max-width: 100%; height: auto; display: block; border-radius: var(--radius-sm); }
     .studio-readme-screenshots { border-top: 1px solid var(--color-border-primary); padding-top: 14px; margin-bottom: 6px; }
     .studio-readme-screenshots-row { display: flex; align-items: center; gap: 10px; }
     .studio-readme-screenshots-hint { font-size: 11px; color: var(--color-text-muted); }
     .studio-readme-card { margin-top: 8px; }
     .studio-readme-card-preview { max-height: 200px; overflow-y: auto; font-size: 13px; }
-    .extension-readme-body img { max-width: min(800px, 100%); height: auto; }
+    .extension-readme-body img { max-width: min(800px, 100%); height: auto; display: inline; vertical-align: middle; }
+    .studio-readme-preview img { max-width: 100%; height: auto; display: inline; vertical-align: middle; }
+    .studio-readme-preview hr, .extension-readme-body hr { border: none; border-top: 1px solid var(--color-border-primary); margin: 1.25em 0; }
+    .studio-readme-preview table, .extension-readme-body table { border-collapse: collapse; width: 100%; margin: 0.75em 0; font-size: 0.8125rem; }
+    .studio-readme-preview th, .studio-readme-preview td, .extension-readme-body th, .extension-readme-body td { border: 1px solid var(--color-border-primary); padding: 0.375em 0.75em; text-align: left; }
+    .studio-readme-preview th, .extension-readme-body th { background: rgba(128,128,128,0.15); font-weight: 600; }
+    .studio-readme-preview pre, .extension-readme-body pre { background: rgba(128,128,128,0.15); border-radius: 6px; padding: 0.75em 1em; overflow-x: auto; margin: 0.625em 0; }
+    .studio-readme-preview code, .extension-readme-body code { font-family: monospace; font-size: 0.8125em; background: rgba(128,128,128,0.15); border-radius: 4px; padding: 0.15em 0.4em; }
+    .studio-readme-preview pre code, .extension-readme-body pre code { background: none; padding: 0; }
     .studio-link-btn { background: none; border: none; padding: 0; font-size: 12px; color: var(--color-accent-primary); cursor: pointer; text-decoration: underline; text-underline-offset: 2px; }
     .studio-link-btn:hover { color: var(--color-accent-hover); }
   `;

data/lib/clacky/default_extensions/ext-studio/skills/ext-develop/SKILL.md

@@ -204,6 +204,10 @@ Response helpers: `json` / `text(str)` / `send_data(bytes, content_type:, filena
 - Drive sessions from the backend: `create_session(prompt:, profile:, …)`,
   `submit_task(session_id, prompt)`, `dispatch_to_session(session_id, prompt)` (runs a
   side task on a fork and returns its reply without touching the conversation).
+- `create_session(hidden: true)` creates a session the openclacky session list hides
+  and the 200-session cleanup skips - use it for dedicated extension sessions you
+  manage yourself. Still reachable by `session_id` via `submit_task` /
+  `dispatch_to_session` / `registry.with_session`; forking resets `hidden` to false.
 - Public (no-auth) endpoints: call `public_endpoint("/path")` in the class **and** set
   `public: true` at ext.yml top level — both are required.
 
@@ -294,7 +298,7 @@ contributes:
 classes; swap the body for the real UI, POST to your own route:
 
 ```js
-Clacky.ext.ui.mount("session.aside", function (ctx) {
+Clacky.ext.ui.mount("session.aside", function (container, ctx) {
   var el = document.createElement("div");
   el.style.padding = "16px";
   var input = document.createElement("input");

data/lib/clacky/default_parsers/xlsx_parser.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""xlsx_parser.py — extract an XLSX/XLS workbook to Markdown tables.
+
+Usage:   python3 xlsx_parser.py <file_path>
+Output:  stdout — Markdown tables (UTF-8), one section per non-empty sheet
+         stderr — error messages
+         exit 0 success / 1 failure / 2 dependency missing
+
+Uses openpyxl in read_only mode: a streaming reader that keeps memory
+constant regardless of sheet size, so multi-megabyte worksheets parse in
+seconds instead of exhausting RAM/CPU like a full DOM parse would.
+"""
+# VERSION: 2
+import sys
+
+
+def build_table(rows):
+    width = max(len(r) for r in rows)
+    lines = []
+    for i, r in enumerate(rows):
+        padded = r + [""] * (width - len(r))
+        lines.append("| " + " | ".join(padded) + " |")
+        if i == 0:
+            lines.append("|" + " --- |" * width)
+    return "\n".join(lines)
+
+
+def main():
+    if len(sys.argv) < 2:
+        sys.stderr.write("Usage: xlsx_parser.py <file_path>\n")
+        sys.exit(1)
+    path = sys.argv[1]
+
+    try:
+        from openpyxl import load_workbook
+    except ImportError as e:
+        sys.stderr.write(f"openpyxl not installed: {e}\n")
+        sys.stderr.write("Install with: pip3 install --user openpyxl\n")
+        sys.exit(2)
+
+    try:
+        wb = load_workbook(path, read_only=True, data_only=True)
+    except Exception as e:
+        sys.stderr.write(f"Failed to open workbook: {e}\n")
+        sys.exit(1)
+
+    sections = []
+    for ws in wb.worksheets:
+        rows = []
+        for row in ws.iter_rows(values_only=True):
+            cells = ["" if v is None else str(v) for v in row]
+            if any(c != "" for c in cells):
+                rows.append(cells)
+        if rows:
+            sections.append(f"### {ws.title}\n\n{build_table(rows)}")
+    wb.close()
+
+    if not sections:
+        sys.stderr.write("Spreadsheet appears to be empty\n")
+        sys.exit(1)
+
+    sys.stdout.write("\n\n".join(sections))
+
+
+if __name__ == "__main__":
+    main()

data/lib/clacky/extension/api_extension.rb

@@ -263,7 +263,7 @@ module Clacky
     # submitted immediately (the session starts running); display_message
     # controls the user-facing bubble shown in place of the raw prompt.
     def create_session(name: nil, prompt: nil, working_dir: nil, profile: "general",
-                       source: :manual, display_message: nil)
+                       source: :manual, display_message: nil, hidden: false)
       error!("server not ready", status: 503) unless @http_server
 
       session_id = @http_server.send(
@@ -271,7 +271,8 @@ module Clacky
         name: name,
         working_dir: working_dir,
         profile: profile,
-        source: source
+        source: source,
+        hidden: hidden
       )
 
       submit_task(session_id, prompt, display_message: display_message) if prompt && !prompt.strip.empty?

data/lib/clacky/message_format/anthropic.rb

@@ -77,7 +77,33 @@ module Clacky
         body[:system] = system_text unless system_text.empty?
         body[:tools]  = api_tools   if api_tools&.any?
 
-        if (effort = normalized_effort(reasoning_effort))
+        # Kimi (Moonshot Coding Plan) models routed through the Anthropic
+        # /v1/messages format expect thinking:{type:"enabled"} — the native
+        # Anthropic "adaptive" type is Claude-specific and is silently ignored
+        # by the Kimi backend, so thinking never actually activates on K3.
+        #
+        # K3 additionally supports a "max" effort level (strongest reasoning)
+        # beyond the standard low/medium/high triple. The generic
+        # normalized_effort() helper drops "max" because it only whitelists
+        # the standard three levels, making K3's signature strongest-reasoning
+        # mode unreachable through this format adapter.
+        #
+        # This branch only changes K3's wire format; every other model keeps
+        # using the adaptive path below unchanged. When reasoning_effort is
+        # nil/empty we leave the body untouched (provider default), and we
+        # never emit output_config for "on" so the backend can pick its own
+        # default — both behaviours match the official kimi CLI.
+        if model.to_s.match?(/\A(kimi-)?k3/i)
+          effort_str = reasoning_effort.to_s
+          k3_effort =
+            case effort_str
+            when "max", "xhigh"              then "max"
+            when "high", "medium", "low"     then effort_str
+            else                                  nil
+            end
+          body[:thinking] = { type: "enabled" }
+          body[:output_config] = { effort: k3_effort } if k3_effort
+        elsif (effort = normalized_effort(reasoning_effort))
           body[:thinking] = { type: "adaptive" }
           body[:output_config] = { effort: effort }
         end

data/lib/clacky/message_format/open_ai.rb

@@ -47,7 +47,7 @@ module Clacky
       def build_request_body(messages, model, tools, max_tokens, caching_enabled, vision_supported: true, reasoning_effort: nil)
         api_messages = messages.map { |msg| normalize_message_content(msg, vision_supported: vision_supported) }
 
-        body = { model: model, max_tokens: max_tokens, messages: api_messages }
+        body = { model: model, token_field_for(model) => max_tokens, messages: api_messages }
 
         if tools&.any?
           if caching_enabled
@@ -59,9 +59,7 @@ module Clacky
           end
         end
 
-        if reasoning_effort && !reasoning_effort.to_s.empty?
-          body[:reasoning_effort] = reasoning_effort.to_s
-        end
+        apply_reasoning_params(body, model, reasoning_effort)
 
         body
       end
@@ -196,6 +194,96 @@ module Clacky
 
       # ── Private helpers ───────────────────────────────────────────────────────
 
+      # Returns the token-limit field name for the given model.
+      # Most OpenAI-compatible APIs use :max_tokens; MiMo-V2.5 (Xiaomi) and
+      # MiniMax-M3 use :max_completion_tokens to cap the combined thinking +
+      # answer length (M3 documents max_completion_tokens over the legacy
+      # max_tokens field).
+      private_class_method def self.token_field_for(model)
+        if model.to_s.match?(/^mimo-v2/i) || model.to_s.match?(/^minimax-m3$/i)
+          :max_completion_tokens
+        else
+          :max_tokens
+        end
+      end
+
+      # Apply model-specific reasoning / thinking parameters to the request body.
+      #
+      # Different model families expose extended reasoning through different API
+      # fields. We map the shared internal reasoning_effort value to each
+      # family's native parameters in-place.
+      #
+      # Zero side-effects: when reasoning_effort is nil/empty the body is
+      # unchanged, preserving the provider default for all models.
+      private_class_method def self.apply_reasoning_params(body, model, reasoning_effort)
+        effort_str = reasoning_effort.to_s
+
+        if model.to_s.match?(/^glm-[45]/i)
+          # GLM (Zhipu / Z.ai) supports a native top-level "thinking" field
+          # ({type: "enabled"|"disabled"}) plus a restricted reasoning_effort
+          # that only accepts "max" or "high". Other effort levels collapse
+          # to "high". Send both fields so GLM activates thinking correctly.
+          if %w[off nothink disabled].include?(effort_str)
+            body[:thinking] = { type: "disabled" }
+          elsif !effort_str.empty?
+            glm_effort =
+              case effort_str
+              when "max", "xhigh" then "max"
+              when "high"          then "high"
+              when "medium", "low" then "high"   # GLM collapses these to "high"
+              else                      "max"
+              end
+            body[:thinking] = { type: "enabled" }
+            body[:reasoning_effort] = glm_effort
+          end
+        elsif model.to_s.match?(/^kimi-k3/i)
+          # Kimi K3 reasoning_effort only accepts low/high/max (default max).
+          # Thinking is always enabled and cannot be turned off; "off" maps
+          # to the lowest intensity "low". Unsupported effort levels (medium,
+          # xhigh) would be rejected or ignored by the server.
+          if %w[off nothink disabled].include?(effort_str)
+            body[:reasoning_effort] = "low"
+          elsif !effort_str.empty?
+            body[:reasoning_effort] =
+              case effort_str
+              when "max", "xhigh"  then "max"
+              when "high"          then "high"
+              when "medium", "low" then "low"
+              else                      "max"
+              end
+          end
+        elsif model.to_s.match?(/^mimo-v2/i)
+          # MiMo-V2.5 (Xiaomi) controls reasoning via a top-level
+          # thinking:{type:...} field rather than reasoning_effort. Map the
+          # internal reasoning_effort value to thinking on/off so MiMo does
+          # not receive an unsupported parameter.
+          if %w[off nothink disabled].include?(effort_str)
+            body[:thinking] = { type: "disabled" }
+          elsif !effort_str.empty?
+            body[:thinking] = { type: "enabled" }
+          end
+        elsif model.to_s.match?(/^minimax-m3$/i)
+          # MiniMax-M3 controls thinking via a top-level "thinking" field with
+          # { type: "adaptive" | "disabled" } — the same envelope shape MiMo
+          # uses, but with MiniMax-specific values. Adaptive thinking is the
+          # server default when the field is omitted, so we only send the
+          # field to explicitly switch modes:
+          #   - reasoning_effort "off"/"disabled"  → thinking disabled
+          #     (M3 answers directly; M2.7 keeps thinking on regardless).
+          #   - any other effort                   → adaptive thinking (M3
+          #     decides per request); we let the server pick the intensity.
+          # M2.7 cannot disable thinking and ignores this field, so sending
+          # it is harmless for the rest of the MiniMax lineup.
+          if %w[off nothink disabled].include?(effort_str)
+            body[:thinking] = { type: "disabled" }
+          elsif !effort_str.empty?
+            body[:thinking] = { type: "adaptive" }
+          end
+        elsif reasoning_effort && !effort_str.empty?
+          body[:reasoning_effort] = effort_str
+        end
+      end
+
       private_class_method def self.parse_tool_calls(raw)
         return nil if raw.nil? || raw.empty?
 

data/lib/clacky/providers.rb

@@ -29,12 +29,14 @@ module Clacky
         "name" => "OpenClacky",
         "base_url" => "https://api.openclacky.com",
         "api" => "bedrock",
-        "default_model" => "abs-claude-sonnet-4-6",
+        "default_model" => "abs-claude-sonnet-5",
         "models" => [
           "abs-claude-fable-5",
+          "abs-claude-opus-5",
           "abs-claude-opus-4-8",
           "abs-claude-opus-4-7",
           "abs-claude-opus-4-6",
+          "abs-claude-sonnet-5",
           "abs-claude-sonnet-4-6",
           "abs-claude-sonnet-4-5",
           "abs-claude-haiku-4-5",
@@ -134,9 +136,11 @@ module Clacky
         # no injection happens when the default model is already lite-class.
         "lite_models" => {
           "abs-claude-fable-5"    => "abs-claude-haiku-4-5",
+          "abs-claude-opus-5"     => "abs-claude-haiku-4-5",
           "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-5"   => "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",
           "dsk-deepseek-v4-pro"   => "dsk-deepseek-v4-flash",
@@ -145,7 +149,9 @@ module Clacky
         # 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-fable-5"    => "abs-claude-opus-4-8",
+          "abs-claude-fable-5"    => "abs-claude-opus-5",
+          "abs-claude-opus-5"     => "abs-claude-opus-4-8",
+          "abs-claude-sonnet-5"   => "abs-claude-sonnet-4-6",
           "abs-claude-sonnet-4-6" => "abs-claude-sonnet-4-5"
         },
         # Secondary gateway URL used when the primary base_url is unreachable
@@ -254,18 +260,20 @@ module Clacky
         # so capability checks (vision=false) fire correctly regardless of
         # which endpoint the user configured.
         "endpoint_variants" => [
-          { "label" => "Mainland China", "label_key" => "settings.models.baseurl.variant.mainland_cn",    "base_url" => "https://api.minimaxi.com/v1", "region" => "cn"   }.freeze,
-          { "label" => "International",  "label_key" => "settings.models.baseurl.variant.international",  "base_url" => "https://api.minimax.io/v1",   "region" => "intl" }.freeze
+          { "label" => "Mainland China", "label_key" => "settings.models.baseurl.variant.mainland_cn",   "base_url" => "https://api.minimaxi.com/v1", "region" => "cn"   }.freeze,
+          { "label" => "International",  "label_key" => "settings.models.baseurl.variant.international", "base_url" => "https://api.minimax.io/v1",   "region" => "intl" }.freeze
         ].freeze,
-        # MiniMax M2.x does not support multimodal/vision input on this endpoint.
-        # M3 (released 2026-06-01) is natively multimodal and accepts image
-        # input, so it overrides the provider-level vision=false below.
+        # MiniMax M2.5/M2.7 are text-only on this endpoint. M3 (released 2026-06-01)
+        # is natively multimodal — it accepts image input via OpenAI-style
+        # image_url content parts — so it overrides the provider-level
+        # vision=false below. M3 exposes a 1,000,000-token context window
+        # (M2.7: 204,800; M2.5: 40,960).
         "capabilities" => { "vision" => false }.freeze,
         "model_capabilities" => {
           "MiniMax-M3" => { "vision" => true }.freeze
         }.freeze,
         "default_ocr_model" => "MiniMax-M3",
-        "website_url" => "https://www.minimaxi.com/user-center/basic-information/interface-key"
+        "website_url" => "https://platform.minimax.io/"
       }.freeze,
 
       "kimi" => {
@@ -348,13 +356,30 @@ module Clacky
         "base_url" => "https://api.xiaomimimo.com/v1",
         "api" => "openai-completions",
         "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).
+        # The MiMo-V2 family (mimo-v2-pro / mimo-v2-omni) was retired on
+        # 2026-06-30 and the model ids are no longer accepted by the API. The
+        # current lineup is the V2.5 series:
+        #   - mimo-v2.5-pro: text reasoning flagship, no vision
+        #   - mimo-v2.5: native omni-modal (image/video/audio/text), vision-capable
+        # Source: https://platform.xiaomimimo.com/docs/zh-CN/model
+        "models" => ["mimo-v2.5-pro", "mimo-v2.5"],
         "capabilities" => { "vision" => false }.freeze,
         "model_capabilities" => {
-          "mimo-v2-omni" => { "vision" => true }.freeze
+          "mimo-v2.5" => { "vision" => true }.freeze
         }.freeze,
-        "default_ocr_model" => "mimo-v2-omni",
+        "default_ocr_model" => "mimo-v2.5",
+        # Xiaomi serves the same V2.5 lineup from two billing endpoints: the
+        # pay-as-you-go API (api.xiaomimimo.com) and the Token Plan subscription
+        # endpoint (token-plan-cn.xiaomimimo.com). Both accept identical model
+        # ids and share one capability profile, so a single preset with
+        # endpoint_variants recognises both. Without this, users on the Token
+        # Plan endpoint fell through to "unknown provider" and the conservative
+        # vision=true default applied to every model — sending images to the
+        # text-only mimo-v2.5-pro, which rejects image input.
+        "endpoint_variants" => [
+          { "label" => "Pay-as-you-go", "label_key" => "settings.models.baseurl.variant.mimo_payg",        "base_url" => "https://api.xiaomimimo.com/v1",          "region" => "cn" }.freeze,
+          { "label" => "Token Plan",    "label_key" => "settings.models.baseurl.variant.mimo_token_plan", "base_url" => "https://token-plan-cn.xiaomimimo.com/v1", "region" => "cn" }.freeze
+        ].freeze,
         "website_url" => "https://platform.xiaomimimo.com/"
       }.freeze,
 
@@ -362,8 +387,8 @@ module Clacky
         "name" => "GLM (Z.ai / Zhipu)",
         "base_url" => "https://open.bigmodel.cn/api/paas/v4",
         "api" => "openai-completions",
-        "default_model" => "glm-5.1",
-        "models" => ["glm-5.1", "glm-5", "glm-5-turbo", "glm-5v-turbo", "glm-4.7"],
+        "default_model" => "glm-5.2",
+        "models" => ["glm-5.2", "glm-5.1", "glm-5", "glm-5-turbo", "glm-5v-turbo", "glm-4.7"],
         # Zhipu / Z.ai expose four functionally-equivalent endpoints:
         # two regional sites (mainland open.bigmodel.cn + international api.z.ai)
         # each with a general-billing and a Coding-Plan subpath. They share the
@@ -520,6 +545,22 @@ module Clacky
 
     MEDIA_KINDS = %w[image video audio stt video_understanding].freeze
 
+    # Per-model maximum output token limits.
+    #
+    # The Agent global default (@max_tokens = 16_384) is tuned for the lowest
+    # common denominator. Strong reasoning models (GLM-5.2, Kimi-K3, MiMo-V2.5)
+    # support 64K–128K output but are artificially throttled to 16K, causing
+    # truncation on long reasoning chains and code generation.
+    #
+    # Entries are matched top-to-bottom; the first match wins. Models not
+    # listed here fall back to the global default.
+    MODEL_MAX_OUTPUT = [
+      { pattern: /glm/i,           limit: 65_536 }, # GLM-5.2: 128K output ceiling; 64K ample for reasoning+answer
+      { pattern: /kimi-k3/i,       limit: 65_536 }, # Kimi K3: max_completion_tokens=131072 (max 1M); 64K ample
+      { pattern: /mimo-v2\.5-pro/i, limit: 65_536 }, # MiMo-V2.5-Pro: max_completion_tokens=131072; 64K ample
+      { pattern: /mimo/i,           limit: 32_768 }  # MiMo-V2.5: max_completion_tokens=32768; full default ceiling
+    ].freeze
+
     class << self
       # Check if a provider preset exists
       # @param provider_id [String] The provider identifier (e.g., "anthropic", "openrouter")
@@ -559,6 +600,18 @@ module Clacky
         preset&.dig("api")
       end
 
+      # Resolve the per-model maximum output token limit.
+      # Returns nil when no MODEL_MAX_OUTPUT entry matches — callers should
+      # then fall back to the global default (@max_tokens).
+      #
+      # @param model_name [String] The model name (e.g. "glm-5.2")
+      # @return [Integer, nil] The max output limit, or nil if undeclared
+      def max_output_for(model_name)
+        return nil if model_name.nil? || model_name.to_s.empty?
+        entry = MODEL_MAX_OUTPUT.find { |e| model_name.to_s.match?(e[:pattern]) }
+        entry&.[](:limit)
+      end
+
       # Resolve the API type for a specific provider+model pair.
       #
       # Resolution order: