openclacky 1.5.20 → 1.5.21

data/lib/clacky/agent_config.rb

@@ -158,19 +158,21 @@ module Clacky
     DEFAULT_COMPRESSION_THRESHOLD = 150_000
     DEFAULT_MESSAGE_COUNT_THRESHOLD = 200
 
-    attr_accessor :input_behavior, :permission_mode, :max_tokens, :verbose,
+    attr_accessor :ask_user_timeout_seconds, :input_behavior, :permission_mode, :max_tokens, :verbose,
                   :enable_compression, :enable_idle_compression, :enable_prompt_caching,
                   :compression_threshold, :message_count_threshold,
                   :models, :current_model_index, :current_model_id,
                   :memory_update_enabled, :skill_evolution,
                   :max_running_agents, :max_idle_agents,
-                  :default_working_dir,
+                  :default_working_dir, :pid_dir,
                   :proxy_url,
                   :clacky_license_server
 
     def initialize(options = {})
       @permission_mode = validate_permission_mode(options[:permission_mode])
       @input_behavior = %w[queue steer interrupt].include?(options[:input_behavior].to_s) ? options[:input_behavior].to_s : "queue"
+      timeout = options.fetch(:ask_user_timeout_seconds, 20)
+      @ask_user_timeout_seconds = timeout.is_a?(Integer) && timeout >= 0 ? timeout : 20
       @max_tokens = options[:max_tokens] || 16384
       @verbose = options[:verbose] || false
       @enable_compression = options[:enable_compression].nil? ? true : options[:enable_compression]
@@ -220,6 +222,7 @@ module Clacky
       @max_idle_agents = options[:max_idle_agents] || 10
 
       @default_working_dir = options[:default_working_dir] || ENV["CLACKY_WORKSPACE_DIR"]
+      @pid_dir = options[:pid_dir]
 
       # HTTP proxy policy. The user's shell ENV (HTTP_PROXY etc.) is always
       # ignored — set proxy_url here to route Clacky's outbound HTTP through
@@ -455,9 +458,9 @@ module Clacky
     CONFIG_SETTINGS_KEYS = %w[
       enable_compression enable_idle_compression enable_prompt_caching
       compression_threshold message_count_threshold
-      memory_update_enabled input_behavior
+      memory_update_enabled input_behavior ask_user_timeout_seconds
       skill_evolution max_running_agents max_idle_agents
-      default_working_dir
+      default_working_dir pid_dir
       proxy_url clacky_license_server
     ].freeze
 
@@ -470,6 +473,7 @@ module Clacky
       end
       settings = {
         "input_behavior" => @input_behavior,
+        "ask_user_timeout_seconds" => @ask_user_timeout_seconds,
         "enable_compression" => @enable_compression,
         "enable_idle_compression" => @enable_idle_compression,
         "enable_prompt_caching" => @enable_prompt_caching,
@@ -480,6 +484,7 @@ module Clacky
         "max_running_agents" => @max_running_agents,
         "max_idle_agents" => @max_idle_agents,
         "default_working_dir" => @default_working_dir,
+        "pid_dir" => @pid_dir,
         "proxy_url" => @proxy_url,
         "clacky_license_server" => @clacky_license_server
       }
@@ -715,6 +720,20 @@ module Clacky
       @models.find { |m| m["type"] == type }
     end
 
+    # Everything Client.new needs from the current card; also the staleness key for a live Client.
+    def client_options
+      entry = current_model
+      {
+        api_key: api_key,
+        base_url: base_url,
+        model: model_name,
+        anthropic_format: anthropic_format?,
+        api_format: api_format,
+        provider_id: provider_id_for(entry),
+        capabilities: entry && entry["capabilities"]
+      }
+    end
+
     # Resolve the provider id for a model entry. An explicit `provider_id`
     # naming a known preset wins over base_url/api_key heuristics — that lets
     # a custom base_url inherit a preset's lineup (media sidecars, OCR models,
@@ -731,6 +750,65 @@ module Clacky
       )
     end
 
+    # Find the API key to use for DeepSeek web search / page fetch.
+    # Resolution order:
+    #   1. Explicit key stored in ~/.clacky/search.yml, when DeepSeek is selected
+    #   2. Key from the model in use, when its provider declares deepseek_web_tools
+    #   3. Key from any other configured model declaring the same capability
+    #   4. nil if none is configured
+    def deepseek_web_key
+      if Clacky::SearchConfig.deepseek_web?
+        explicit = Clacky::SearchConfig.key.to_s.strip
+        return explicit unless explicit.empty?
+      end
+
+      entry = web_tool_candidates.find do |m|
+        next false unless m.is_a?(Hash)
+        next false if m["api_key"].to_s.strip.empty?
+        Clacky::Providers.deepseek_web_tools?(provider_id_for(m))
+      end
+      entry ? entry["api_key"].to_s.strip : nil
+    end
+
+    # True when the paid DeepSeek web tools are usable: they are the selected
+    # search provider and a key could be resolved.
+    def deepseek_web_ready?
+      return false unless Clacky::SearchConfig.deepseek_web?
+
+      !deepseek_web_key.to_s.strip.empty?
+    rescue StandardError
+      false
+    end
+
+    # Endpoint base URL for DeepSeek web tools given the resolved key.
+    # If the key belongs to an OpenClacky model entry (or starts with clacky-),
+    # route to that model's base_url so the platform gateway can proxy and bill
+    # through the unified balance. Otherwise direct to DeepSeek official.
+    def deepseek_web_base_url(resolved_key = nil)
+      key = resolved_key || deepseek_web_key
+      default_url = Clacky::DeepSeekWebTools::DEFAULT_BASE_URL
+      return default_url if key.nil? || key.empty?
+
+      matching = web_tool_candidates.find { |m| m.is_a?(Hash) && m["api_key"].to_s.strip == key }
+      if matching
+        pid = provider_id_for(matching)
+        if pid == Clacky::Providers::OPENCLACKY_ID && matching["base_url"].to_s.strip != ""
+          return matching["base_url"].to_s.chomp("/")
+        end
+      elsif key.start_with?("clacky-")
+        return Clacky::Providers::PRESETS.fetch(Clacky::Providers::OPENCLACKY_ID)["base_url"].chomp("/")
+      end
+
+      default_url
+    end
+
+    # Current model first (so a session-level switch or overlay wins), then the
+    # rest of the configured models as fallback.
+    private def web_tool_candidates
+      current = current_model
+      current ? [current] + @models : @models
+    end
+
     private def derive_media_model(kind, model_override: nil)
       anchor = current_model || find_model_by_type("default")
       return nil unless anchor

data/lib/clacky/billing/platform_billing.rb

@@ -44,11 +44,15 @@ module Clacky
         "abs-claude-sonnet-4-5" => "global.anthropic.claude-sonnet-4-5",
         "abs-claude-haiku-5-5"  => "global.anthropic.claude-haiku-5-5",
         "abs-claude-haiku-4-5"  => "global.anthropic.claude-haiku-4-5",
-        # GLM / Kimi / Grok via TokHub (oc-). The gateway books these under the
+        # GLM / Kimi / Grok / GPT via TokHub (oc-). The gateway books these under the
         # alias itself, so the mapping is an identity — it exists so the billing UI
         # can resolve the alias instead of dropping the record as unknown.
         "oc-glm-5.3"            => "oc-glm-5.3",
         "oc-kimi-k3"            => "oc-kimi-k3",
+        "oc-gpt-6.1-sol"        => "oc-gpt-6.1-sol",
+        "oc-gpt-6-astra"        => "oc-gpt-6-astra",
+        "oc-gpt-6-sol"          => "oc-gpt-6-sol",
+        "oc-gpt-6-luna"         => "oc-gpt-6-luna",
         "oc-grok-4.7"           => "oc-grok-4.7",
         # gemini chat (or-)
         "or-gemini-4-argon"   => "gemini-4-argon",

data/lib/clacky/brand_config.rb

@@ -683,7 +683,7 @@ module Clacky
         already_exists = body["code"].to_s.include?("taken") ||
                          body["code"].to_s.include?("already") ||
                          result[:error].to_s.include?("HTTP 409")
-        { success: false, error: msg, already_exists: already_exists }
+        { success: false, error: msg, already_exists: already_exists, error_code: code }
       end
     rescue StandardError => e
       { success: false, error: "Network error: #{e.message}" }

data/lib/clacky/cli.rb

@@ -346,8 +346,9 @@ module Clacky
       end
 
       # Handle the `/think` slash command — pick the reasoning effort level
-      # for the current session. "off" normalizes to nil (provider default),
-      # matching the Web UI's reasoning_effort switcher semantics.
+      # for the current session. "off" is kept as an explicit choice so model
+      # adapters can resolve it per family (MiniMax Flash and GLM-5.3 turn it
+      # into their lightest effort instead of the provider's deepest default).
       private def handle_think_command(ui_controller, agent, session_manager = nil)
         choice = ui_controller.show_reasoning_effort_menu(agent.reasoning_effort)
         return if choice.nil?

data/lib/clacky/client.rb

@@ -129,7 +129,7 @@ module Clacky
         response = bedrock_connection.post(bedrock_endpoint(api_model)) { |r| r.body = body.to_json }
         parse_simple_bedrock_response(response)
       elsif anthropic_format?
-        body     = MessageFormat::Anthropic.build_request_body(messages, api_model, [], max_tokens, false)
+        body     = MessageFormat::Anthropic.build_request_body(messages, api_model, [], max_tokens, false, reasoning_effort: reasoning_effort)
         response = anthropic_connection.post(anthropic_messages_path) { |r| r.body = body.to_json }
         parse_simple_anthropic_response(response)
       elsif responses_format?
@@ -356,10 +356,10 @@ module Clacky
       end
 
       unless response.status == 200
-        recovered_body = response.body.to_s
-        recovered_body = sse_buf.to_s if recovered_body.empty?
-        recovered = Struct.new(:status, :body).new(response.status, recovered_body)
-        raise_error(recovered)
+        # Recover the streamed error body on the original response so headers
+        # remain available to error classification and routed-tier attribution.
+        response.env.body = sse_buf if response.body.to_s.empty?
+        raise_error(response)
       end
 
       result = aggregator.to_h

data/lib/clacky/deepseek_web_tools.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Clacky
+  # Client for DeepSeek hosted web tools:
+  #   POST /v1/tools/search
+  #   POST /v1/tools/fetch
+  #
+  # DeepSeek charges per successful request (CNY 5 / 1000 calls).
+  # Handles endpoint routing, auth header, request formatting, rate-limit (429)
+  # backoff, and cleans up DeepSeek-specific Markdown escapes (\# \- \_).
+  module DeepSeekWebTools
+    DEFAULT_BASE_URL = "https://api.deepseek.com"
+    SEARCH_TIMEOUT = 30
+    FETCH_TIMEOUT  = 45
+    MAX_RETRIES    = 2
+
+    # A failed call (bad key, empty balance, outage) keeps failing, and each
+    # attempt costs a timeout on the user's critical path. Once one fails, stay
+    # off DeepSeek and let the free engines serve until it expires.
+    # The window is owned by WebSearch so hosted and free providers share it.
+
+    class << self
+      # True while DeepSeek should be skipped after a recent failure.
+      def cooling_down?
+        until_at = @cooldown_until
+        return false if until_at.nil?
+
+        Time.now < until_at
+      end
+
+      def mark_unavailable!
+        @cooldown_until = Time.now + Clacky::Tools::WebSearch::PROVIDER_COOLDOWN_SECONDS
+      end
+
+      def reset_cooldown!
+        @cooldown_until = nil
+      end
+      # Perform web search via DeepSeek.
+      # @param query [String]
+      # @param count [Integer] results count (1..50)
+      # @param api_key [String]
+      # @param base_url [String]
+      # @return [Array<Hash>] [{ title:, url:, snippet: }]
+      def search(query:, count: 10, api_key:, base_url: DEFAULT_BASE_URL)
+        payload = {
+          "query" => query.to_s,
+          "count" => [[count.to_i, 1].max, 50].min
+        }
+        res = post_with_retry(
+          path: "/v1/tools/search",
+          payload: payload,
+          api_key: api_key,
+          base_url: base_url,
+          timeout: SEARCH_TIMEOUT
+        )
+        data = JSON.parse(res.body) rescue {}
+        raw_results = data["results"] || []
+
+        raw_results.filter_map do |item|
+          url = item["url"].to_s.strip
+          next if url.empty?
+
+          title = clean_text(item["title"].to_s.strip)
+          title = url if title.empty?
+
+          # Prefer summary (400-800 chars rich text), fall back to snippet
+          summary = item["summary"].to_s.strip
+          snippet = summary.empty? ? item["snippet"].to_s.strip : summary
+          snippet = clean_text(snippet)[0, 400]
+
+          {
+            title: title,
+            url: url,
+            snippet: snippet
+          }
+        end
+      end
+
+      # Fetch web page content rendered as Markdown via DeepSeek.
+      # @param url [String]
+      # @param api_key [String]
+      # @param base_url [String]
+      # @return [Hash] { title:, content: }
+      def fetch(url:, api_key:, base_url: DEFAULT_BASE_URL)
+        payload = { "url" => url.to_s }
+        res = post_with_retry(
+          path: "/v1/tools/fetch",
+          payload: payload,
+          api_key: api_key,
+          base_url: base_url,
+          timeout: FETCH_TIMEOUT
+        )
+        data = JSON.parse(res.body) rescue {}
+        content = clean_text(data["content"].to_s)
+        title = clean_text(data["title"].to_s.strip)
+
+        {
+          title: title,
+          content: content
+        }
+      end
+
+      # Strip excessive DeepSeek backslash-escapes on Markdown syntax:
+      # e.g. "\#\# title", "\- bullet", "\_italic\_", "\[link\]".
+      def clean_text(text)
+        return "" if text.nil?
+
+        text.to_s.gsub(/\\([#\-_*`\[\]()!+>|~])/, '\1')
+      end
+
+      private def post_with_retry(path:, payload:, api_key:, base_url:, timeout:)
+        raise ArgumentError, "DeepSeek API key is required" if api_key.nil? || api_key.to_s.strip.empty?
+
+        root = (base_url && !base_url.empty?) ? base_url.chomp("/") : DEFAULT_BASE_URL
+        uri = URI.parse("#{root}#{path}")
+
+        attempts = 0
+        loop do
+          attempts += 1
+          req = Net::HTTP::Post.new(uri.request_uri)
+          req["Content-Type"] = "application/json"
+          req["Authorization"] = "Bearer #{api_key}"
+          req.body = JSON.generate(payload)
+
+          response = Net::HTTP.start(
+            uri.hostname,
+            uri.port,
+            use_ssl: uri.scheme == "https",
+            read_timeout: timeout,
+            open_timeout: 10
+          ) do |http|
+            http.request(req)
+          end
+
+          case response.code.to_i
+          when 200..299
+            return response
+          when 429
+            if attempts <= MAX_RETRIES
+              sleep(1.0 * attempts)
+              next
+            end
+            raise "DeepSeek web tool rate limit exceeded (429)"
+          else
+            err_msg = response.body.to_s[0, 200]
+            raise "DeepSeek web tool #{path} returned HTTP #{response.code}: #{err_msg}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -119,6 +119,14 @@ class ExtStudioExt < Clacky::ApiExtension
         # their extension before publishing.
         json(ok: false, name_taken: true,
              error: result[:error])
+      elsif result[:error_code] == "contributor_required"
+        error!(
+          result[:error] || "publishing requires contributor status",
+          status: 403,
+          error_code: "contributor_required",
+          action_url: "#{Clacky::PlatformHttpClient.base_url}/my/extensions",
+          action_label: "open_extensions_page"
+        )
       else
         error!(result[:error] || "publish failed", status: 502)
       end

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

@@ -56,6 +56,8 @@
       "err.invalid_version": "Invalid version. Use format like 1.0.0.",
       "err.name_taken": "The name \"{{id}}\" is already taken by another user.",
       "err.id_folder_mismatch": "Extension ID mismatch: the folder is named \"{{folder}}\" but ext.yml declares id \"{{id}}\". Rename the folder or the id so they match before publishing.",
+      "err.contributor_required": "You need contributor status to publish. Open the platform, sign in, then click \"Become a contributor\" — it takes effect immediately, no review.",
+      "err.contributor_required.link": "Open My Extensions →",
       "rename.label": "Choose a new ID for your extension:",
       "rename.placeholder": "e.g. my-ext-yourname",
       "rename.hint": "Only lowercase letters, digits and hyphens. This will rename the local folder and update ext.yml.",
@@ -268,6 +270,8 @@
       "err.invalid_version": "版本号格式不对，请使用如 1.0.0 的格式。",
       "err.name_taken": "扩展名「{{id}}」已被其他用户占用。",
       "err.id_folder_mismatch": "扩展 ID 不一致：文件夹名为「{{folder}}」，但 ext.yml 声明的 id 是「{{id}}」。请先把文件夹名或 id 改成一致再发布。",
+      "err.contributor_required": "你还不是扩展贡献者，需要先开通才能发布。打开平台并登录后，点「成为扩展贡献者」即刻生效，无需审核。",
+      "err.contributor_required.link": "打开「我的扩展」→",
       "rename.label": "请为你的扩展选择一个新 ID：",
       "rename.placeholder": "例如 my-ext-yourname",
       "rename.hint": "只能使用小写字母、数字和连字符。",
@@ -663,7 +667,7 @@
 
       const status = el("p", { class: "studio-modal-status", text: t("bind.body") });
       const codeLine = el("p", { class: "studio-modal-code" });
-      const link = el("a", { class: "btn-primary", target: "_blank", rel: "noopener", text: t("bind.openLink") });
+      const link = el("a", { class: "btn-primary", target: "_blank", rel: "noopener", "data-open-external": "1", text: t("bind.openLink") });
       link.style.display = "none";
 
       const modal = openModal({
@@ -813,6 +817,18 @@
         status.className = "studio-modal-status" + (isError ? " studio-modal-status-error" : "");
       }
 
+      // Same as setProgress, but for errors the user fixes elsewhere: keeps the
+      // message neutral (a wall of red reads as a crash) and tucks the fix
+      // behind a link that opens in a new tab so the modal survives.
+      function setProgressWithLink(msg, url, linkText) {
+        setProgress("", false);
+        status.textContent = msg + " ";
+        status.appendChild(el("a", {
+          class: "studio-notice-link", href: url, target: "_blank", rel: "noopener",
+          "data-open-external": "1", text: linkText,
+        }));
+      }
+
       function syncVersionState({ normalize = false, updateFeedback = true } = {}) {
         if (normalize) {
           const raw = verInput.value;
@@ -905,6 +921,8 @@
             verInput.addEventListener("input", () => verInput.classList.remove("studio-input-error"), { once: true });
           } else if (mismatch) {
             setProgress(t("err.id_folder_mismatch", { folder: mismatch[1], id: mismatch[2] }), true);
+          } else if (e.data && e.data.error_code === "contributor_required" && e.data.action_url) {
+            setProgressWithLink(t("err.contributor_required"), e.data.action_url, t("err.contributor_required.link"));
           } else {
             setProgress(t("err.generic", { msg }), true);
           }
@@ -2365,6 +2383,8 @@
     .studio-pub-units::before { content: "·"; margin-right: 10px; }
     .studio-modal-status { margin: 0 0 8px; font-size: 13px; color: var(--color-text-secondary); line-height: 1.6; }
     .studio-modal-status-error { color: var(--color-error); }
+    .studio-notice-link { font-size: 12.5px; font-weight: 500; color: var(--color-accent-primary); text-decoration: none; white-space: nowrap; }
+    .studio-notice-link:hover { text-decoration: underline; }
     .studio-input { width: 100%; box-sizing: border-box; background: var(--color-bg-input); border: 1px solid var(--color-border-primary); border-radius: var(--radius-sm); padding: 7px 10px; color: var(--color-text-primary); font-size: 13px; font-family: monospace; }
     .studio-input:focus { border-color: var(--color-accent-primary); outline: none; }
     .studio-input-error { border-color: var(--color-error) !important; }

data/lib/clacky/extension/loader.rb

@@ -288,10 +288,12 @@ module Clacky
       end
 
 
-      # A layer's fingerprint is the sorted list of "<ext_id>|<mtime>" for
+      # A layer's fingerprint is the list of [ext_id, manifest path, mtime] for
       # every container manifest present. Cheap to compute (one stat per
       # manifest); the whole map compared as a Hash so a container appearing
-      # or disappearing also invalidates.
+      # or disappearing also invalidates. The path belongs in the key: two
+      # roots can hold the same ext_id with manifests whose mtimes collide, and
+      # reusing a result across roots would hand back stale dirs.
       private def fingerprint_layers(layers)
         layers.each_with_object({}) do |(layer, root), acc|
           next unless root && Dir.exist?(root)
@@ -302,7 +304,7 @@ module Clacky
             manifest = File.join(root, ext_id, MANIFEST)
             next unless File.file?(manifest)
 
-            entries << [ext_id, File.mtime(manifest).to_f]
+            entries << [ext_id, manifest, File.mtime(manifest).to_f]
           end
           acc[layer] = entries
         end

data/lib/clacky/locales/en.rb

@@ -15,15 +15,15 @@ module Clacky
       "llm.error.403.access_denied"     => "Access denied, please check your API key permissions",
       "llm.error.403.default"           => "Access denied",
       "llm.error.endpoint_not_found"    => "API endpoint not found, please check your service URL",
-      "llm.error.rate_limit_429"        => "Rate limit exceeded, please wait a moment",
+      "llm.error.rate_limit_429"        => "Rate limit exceeded. Please switch to another model and retry, or wait a moment",
       "llm.error.quota_exhausted"       => "API quota exhausted (key usage limit reached). Please raise the quota or upgrade your plan in the console",
       "llm.error.server_error"          => "Service temporarily unavailable (%<status>d), retrying...",
-      "llm.error.unexpected"            => "Unexpected error (%<status>d)",
+      "llm.error.unexpected"            => "Request failed (%<status>d). Please switch to another model and retry",
       "llm.error.html_response"         => "Service temporarily unavailable (received HTML error page), retrying...",
       "llm.error.bad_request"           => "Model request failed. Please switch to another model and retry",
-      "llm.error.request_timeout"       => "Request timed out after %<retries>d retries",
-      "llm.error.network_failed"        => "Network connection failed after %<retries>d retries. If the problem persists, check your account balance or API Key",
-      "llm.error.service_unavailable"   => "Service unavailable after %<retries>d retries",
+      "llm.error.request_timeout"       => "Request timed out after %<retries>d retries. Please switch to another model and retry",
+      "llm.error.network_failed"        => "Network connection failed after %<retries>d retries. If the problem persists, switch to another model and retry, or check your account balance",
+      "llm.error.service_unavailable"   => "Service unavailable after %<retries>d retries. Please switch to another model and retry",
       "platform.error.invalid_proof"        => "Invalid license key — please check and try again.",
       "platform.error.invalid_signature"    => "Invalid request signature.",
       "platform.error.nonce_replayed"       => "Duplicate request detected. Please try again.",

data/lib/clacky/locales/zh.rb

@@ -15,15 +15,15 @@ module Clacky
       "llm.error.403.access_denied"     => "访问被拒绝，请检查 API 密钥权限",
       "llm.error.403.default"           => "访问被拒绝",
       "llm.error.endpoint_not_found"    => "API 端点不存在，请检查服务地址配置",
-      "llm.error.rate_limit_429"        => "请求过于频繁，请稍后重试",
+      "llm.error.rate_limit_429"        => "请求过于频繁，请暂时切换其他模型重试或稍后重试",
       "llm.error.quota_exhausted"       => "API 配额已用尽（已达 Key 的用量上限），请前往控制台提升配额或升级套餐后继续",
       "llm.error.server_error"          => "服务暂时不可用（%<status>d），正在重试...",
-      "llm.error.unexpected"            => "请求失败（%<status>d）",
+      "llm.error.unexpected"            => "请求失败（%<status>d），请暂时切换其他模型重试",
       "llm.error.html_response"         => "服务暂时不可用（收到 HTML 错误页），正在重试...",
       "llm.error.bad_request"           => "请求模型出错，请暂时切换其他模型重试",
-      "llm.error.request_timeout"       => "请求超时（已重试 %<retries>d 次）",
-      "llm.error.network_failed"        => "网络连接失败（已重试 %<retries>d 次），若持续失败，请检查账户余额或 API Key",
-      "llm.error.service_unavailable"   => "服务暂时不可用（已重试 %<retries>d 次）",
+      "llm.error.request_timeout"       => "请求超时（已重试 %<retries>d 次），请暂时切换其他模型重试",
+      "llm.error.network_failed"        => "网络连接失败（已重试 %<retries>d 次），若持续失败，请暂时切换其他模型重试或检查账户余额",
+      "llm.error.service_unavailable"   => "服务暂时不可用（已重试 %<retries>d 次），请暂时切换其他模型重试",
       "platform.error.invalid_proof"        => "许可证密钥无效，请检查后重试。",
       "platform.error.invalid_signature"    => "请求签名无效。",
       "platform.error.nonce_replayed"       => "检测到重复请求，请重试。",

data/lib/clacky/message_format/anthropic.rb

@@ -19,6 +19,10 @@ module Clacky
     module Anthropic
       module_function
 
+      # Same "no explicit level" set the OpenAI adapter uses: the sessionbar and
+      # config paths only ever emit these values or a concrete low..max level.
+      OFF_EFFORT_VALUES = %w[off nothink disabled none].freeze
+
       # Normalise a /v1/messages usage block to the codebase's canonical
       # (OpenAI-style) prompt_tokens: total input including cache_read but
       # excluding cache_creation.
@@ -122,6 +126,22 @@ module Clacky
             end
           body[:thinking] = { type: "enabled" }
           body[:output_config] = { effort: k3_effort } if k3_effort
+        elsif model.to_s.match?(/\Aminimax-m3[.]1-flash\z/i)
+          # Flash always thinks; use its lightest supported effort for "off".
+          effort = if OFF_EFFORT_VALUES.include?(reasoning_effort.to_s)
+                     "low"
+                   else
+                     normalized_effort(reasoning_effort)
+                   end
+          body[:output_config] = { effort: effort } if effort
+        elsif model.to_s.match?(/\Aminimax-m3\z/i)
+          # M3 defaults to disabled on this transport and ignores effort.
+          effort_str = reasoning_effort.to_s
+          if OFF_EFFORT_VALUES.include?(effort_str)
+            body[:thinking] = { type: "disabled" }
+          elsif !effort_str.empty?
+            body[:thinking] = { type: "adaptive" }
+          end
         elsif (effort = normalized_effort(reasoning_effort))
           body[:thinking] = { type: "adaptive" }
           body[:output_config] = { effort: effort }

data/lib/clacky/message_format/open_ai.rb

@@ -224,17 +224,23 @@ module Clacky
 
       # 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 +
+      # MiniMax-M3 / M3.1-Flash 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)
+        if model.to_s.match?(/^mimo-v2/i) || model.to_s.match?(/^minimax-m3([.]1-flash)?$/i)
           :max_completion_tokens
         else
           :max_tokens
         end
       end
 
+      # Values the sessionbar/config use to mean "no explicit level". They are
+      # model-specific on the wire (some families map them to their lightest
+      # effort, others to thinking disabled), so every branch below handles
+      # them explicitly — the generic fallback must never forward them.
+      OFF_EFFORT_VALUES = %w[off nothink disabled none].freeze
+
       # Apply model-specific reasoning / thinking parameters to the request body.
       #
       # Different model families expose extended reasoning through different API
@@ -259,7 +265,7 @@ module Clacky
           # error (Z.ai migration guide), so "off" maps to the lightest effort
           # "low". Effort accepts low/high/max only; server default is max.
           body[:thinking] = { type: "enabled" }
-          if %w[off nothink disabled].include?(effort_str)
+          if OFF_EFFORT_VALUES.include?(effort_str)
             body[:reasoning_effort] = "low"
           elsif !effort_str.empty?
             body[:reasoning_effort] =
@@ -275,7 +281,7 @@ module Clacky
           # ({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)
+          if OFF_EFFORT_VALUES.include?(effort_str)
             body[:thinking] = { type: "disabled" }
           elsif !effort_str.empty?
             glm_effort =
@@ -293,7 +299,7 @@ module Clacky
           # 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)
+          if OFF_EFFORT_VALUES.include?(effort_str)
             body[:reasoning_effort] = "low"
           elsif !effort_str.empty?
             body[:reasoning_effort] =
@@ -309,11 +315,19 @@ module Clacky
           # 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)
+          if OFF_EFFORT_VALUES.include?(effort_str)
             body[:thinking] = { type: "disabled" }
           elsif !effort_str.empty?
             body[:thinking] = { type: "enabled" }
           end
+        elsif model.to_s.match?(/^minimax-m3[.]1-flash$/i)
+          # M3.1-Flash always thinks and rejects thinking disabled / effort none,
+          # so "off" maps to the lightest effort "low".
+          if OFF_EFFORT_VALUES.include?(effort_str)
+            body[:reasoning_effort] = "low"
+          elsif %w[low medium high xhigh max].include?(effort_str)
+            body[:reasoning_effort] = effort_str
+          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
@@ -326,20 +340,23 @@ module Clacky
           #     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)
+          if OFF_EFFORT_VALUES.include?(effort_str)
             body[:thinking] = { type: "disabled" }
           elsif !effort_str.empty?
             body[:thinking] = { type: "adaptive" }
           end
         elsif model.to_s.match?(/deepseek/i)
           # DeepSeek V4 reasoning_effort only accepts low/high/max.
-          # xhigh is not recognized — map it to max.
-          effort = case effort_str
-                   when "xhigh" then "max"
-                   else effort_str
-                   end
-          assign_effort(body, effort, responses_api)
-        elsif reasoning_effort && !effort_str.empty?
+          # xhigh is not recognized — map it to max. Off-like values are not
+          # valid either, so they keep the provider default untouched.
+          unless OFF_EFFORT_VALUES.include?(effort_str)
+            effort = case effort_str
+                     when "xhigh" then "max"
+                     else effort_str
+                     end
+            assign_effort(body, effort, responses_api)
+          end
+        elsif reasoning_effort && !effort_str.empty? && !OFF_EFFORT_VALUES.include?(effort_str)
           assign_effort(body, effort_str, responses_api)
         end
       end