openclacky 1.5.3 → 1.5.5

data/lib/clacky/extension/packager.rb

@@ -18,6 +18,14 @@ module Clacky
     MANIFEST     = "ext.yml"
     MAX_ZIP_SIZE = 50 * 1024 * 1024
 
+    # Network timeouts for the download step. `read_timeout` is an *idle*
+    # timeout (resets on every chunk received), so a stalled connection with
+    # no new bytes flowing for this long is treated as dead — not a "download
+    # still going, just slow" situation, which large files on a slow link
+    # would otherwise trigger.
+    OPEN_TIMEOUT = 15   # seconds to establish the connection
+    READ_TIMEOUT = 60   # seconds of silence before giving up mid-download
+
     # Platform metadata that leaks in from the developer's OS; never ship it.
     SYSTEM_METADATA = [".DS_Store", "__MACOSX", "Thumbs.db", "desktop.ini"].freeze
 
@@ -56,12 +64,19 @@ module Clacky
       # local zip path or an http(s) URL. Validates the archive (single top
       # container with an ext.yml, no path traversal), extracts it, then runs
       # verify on the resolved installed layer.
-      def install(source, installed_dir: Clacky::ExtensionLoader::INSTALLED_DIR, force: false)
+      # on_progress is an optional callable that receives a stage hash, e.g.:
+      #   { stage: "downloading", progress: 45 }
+      #   { stage: "extracting" }
+      #   { stage: "verifying" }
+      # Caller can use this for progress reporting without coupling to internals.
+      def install(source, installed_dir: Clacky::ExtensionLoader::INSTALLED_DIR, force: false, on_progress: nil)
         Dir.mktmpdir("clacky-ext-install") do |tmp|
-          zip_path = local_zip_for(source, tmp)
+          on_progress&.call({ stage: "downloading", progress: 0 })
+          zip_path = local_zip_for(source, tmp, on_progress: on_progress)
+
+          on_progress&.call({ stage: "extracting" })
           extract_root = File.join(tmp, "unpacked")
           FileUtils.mkdir_p(extract_root)
-
           extract_zip(zip_path, extract_root)
 
           ext_id, container_src = locate_container(extract_root)
@@ -74,6 +89,7 @@ module Clacky
           FileUtils.mkdir_p(target)
           FileUtils.cp_r(Dir.glob("#{container_src}/*"), target)
 
+          on_progress&.call({ stage: "verifying" })
           Clacky::ExtensionLoader.invalidate_cache!
           units = verify_installed(ext_id, installed_dir)
 
@@ -149,11 +165,11 @@ module Clacky
         rel.split(File::SEPARATOR).any? { |seg| SYSTEM_METADATA.include?(seg) }
       end
 
-      private def local_zip_for(source, tmp)
+      private def local_zip_for(source, tmp, on_progress: nil)
         src = source.to_s
         if src.match?(%r{\Ahttps?://})
           dest = File.join(tmp, "download.zip")
-          download(src, dest)
+          download(src, dest, on_progress: on_progress)
           dest
         else
           path = File.expand_path(src)
@@ -162,19 +178,48 @@ module Clacky
         end
       end
 
-      private def download(url, dest)
-        total = 0
-        URI.open(url, "rb") do |io| # rubocop:disable Security/Open
-          File.open(dest, "wb") do |out|
-            while (chunk = io.read(64 * 1024))
-              total += chunk.bytesize
-              raise Error, "download exceeds #{MAX_ZIP_SIZE} bytes" if total > MAX_ZIP_SIZE
-              out.write(chunk)
-            end
-          end
+      # Download url → dest file.
+      # IMPORTANT: OpenURI's block form (`URI.open(url) { |io| ... }`) buffers
+      # the *entire* response into a StringIO/Tempfile via Net::HTTP's
+      # read_body before ever yielding `io` — so reading `io` in chunks after
+      # the fact reports progress only after the download has already
+      # finished. To get progress callbacks that fire while bytes are still
+      # arriving on the socket, we hook OpenURI's own `progress_proc` /
+      # `content_length_proc`, which run inside read_body as each chunk lands.
+      # Respects whatever proxy env vars the user has configured (some CDN
+      # domains are only reachable at usable speed through a proxy).
+      private def download(url, dest, on_progress: nil)
+        content_length = nil
+
+        content_length_proc = lambda do |len|
+          content_length = len if len&.positive?
+        end
+
+        progress_proc = lambda do |size|
+          raise Error, "download exceeds #{MAX_ZIP_SIZE} bytes" if size > MAX_ZIP_SIZE
+          next unless on_progress
+
+          pct = if content_length&.positive?
+                  [(size * 100 / content_length).floor, 99].min
+                else
+                  (90 - 90 * Math.exp(-size.to_f / (1024 * 1024))).floor
+                end
+          on_progress.call({ stage: "downloading", progress: pct })
+        end
+
+        URI.open(
+          url, "rb",
+          open_timeout: OPEN_TIMEOUT,
+          read_timeout: READ_TIMEOUT,
+          content_length_proc: content_length_proc,
+          progress_proc: progress_proc
+        ) do |io| # rubocop:disable Security/Open
+          File.open(dest, "wb") { |out| out.write(io.read) }
         end
       rescue OpenURI::HTTPError, SocketError => e
         raise Error, "failed to download #{url}: #{e.message}"
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        raise Error, "download timed out: #{e.message}"
       end
 
       private def extract_zip(zip_path, dest_root)

data/lib/clacky/extension/verifier.rb

@@ -22,7 +22,7 @@ module Clacky
     PANEL_KEYS   = %w[id title title_zh description description_zh view order attach entry_points].freeze
     API_KEYS     = %w[id handler].freeze
     SKILL_KEYS   = %w[id dir protected].freeze
-    AGENT_KEYS   = %w[id title title_zh description description_zh order prompt panels skills avatar].freeze
+    AGENT_KEYS   = %w[id title title_zh description description_zh order prompt panels skills avatar hidden].freeze
     CHANNEL_KEYS = %w[id platform adapter].freeze
     PATCH_KEYS   = %w[target file fingerprint on_mismatch].freeze
     HOOK_KEYS    = %w[event file].freeze

data/lib/clacky/message_format/anthropic.rb

@@ -114,7 +114,7 @@ module Clacky
       private_class_method def self.normalized_effort(effort)
         return nil if effort.nil? || effort.to_s.empty?
         s = effort.to_s
-        %w[low medium high].include?(s) ? s : nil
+        %w[low medium high xhigh max].include?(s) ? s : nil
       end
 
       # Merge consecutive tool_result user messages into a single user message.

data/lib/clacky/message_format/bedrock.rb

@@ -91,7 +91,7 @@ module Clacky
 
       private_class_method def self.additional_fields_for_effort(effort)
         return nil if effort.nil? || effort.to_s.empty?
-        return nil unless %w[low medium high].include?(effort.to_s)
+        return nil unless %w[low medium high xhigh max].include?(effort.to_s)
         {
           thinking: { type: "adaptive" },
           output_config: { effort: effort.to_s }

data/lib/clacky/message_format/open_ai.rb

@@ -195,10 +195,16 @@ 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) uses
-      # :max_completion_tokens to cap the combined thinking + answer length.
+      # 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)
-        model.to_s.match?(/^mimo-v2/i) ? :max_completion_tokens : :max_tokens
+        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.
@@ -256,6 +262,31 @@ module Clacky
           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 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
+          body[:reasoning_effort] = effort unless effort.empty?
         elsif reasoning_effort && !effort_str.empty?
           body[:reasoning_effort] = effort_str
         end

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" => {
@@ -469,6 +477,67 @@ module Clacky
         "website_url" => "https://console.volcengine.com/ark/region:cn-beijing/overview"
       }.freeze,
 
+      "ollama" => {
+        "name" => "Ollama (Cloud)",
+        # Ollama Cloud API — OpenAI-compatible endpoint serving both local and
+        # cloud models. Cloud models are available immediately without pulling.
+        # Authentication: API key via Authorization: Bearer <key> header.
+        # Create API keys at: https://ollama.com/settings/keys
+        "base_url" => "https://ollama.com",
+        "api" => "openai-completions",
+        "default_model" => "deepseek-v4-flash",
+        # Curated list of cloud-enabled models from the Ollama library.
+        # Users can type any Ollama model name manually; this list seeds the picker.
+        "models" => [
+          "glm-5.2",
+          "kimi-k3",
+          "gemma4",
+          "qwen3.5",
+          "glm-5.1",
+          "minimax-m2.7",
+          "nemotron-3-super",
+          "minimax-m3",
+          "kimi-k2.7-code",
+          "kimi-k2.6",
+          "deepseek-v4-flash",
+          "deepseek-v4-pro",
+          "nemotron-3-ultra",
+          "gemini-3-flash-preview",
+          "nemotron-3-nano",
+          "mistral-large-3",
+          "gpt-oss"
+        ],
+        # Provider-level default: many Ollama cloud models are vision-capable.
+        "capabilities" => { "vision" => true }.freeze,
+        # Model-level overrides: text-only models that don't accept image input.
+        "model_capabilities" => {
+          "glm-5.2"             => { "vision" => false }.freeze,
+          "glm-5.1"             => { "vision" => false }.freeze,
+          "minimax-m2.7"        => { "vision" => false }.freeze,
+          "deepseek-v4-pro"     => { "vision" => false }.freeze,
+          "deepseek-v4-flash"   => { "vision" => false }.freeze,
+          "nemotron-3-super"    => { "vision" => false }.freeze,
+          "nemotron-3-ultra"    => { "vision" => false }.freeze,
+          "nemotron-3-nano"     => { "vision" => false }.freeze,
+          "gpt-oss"             => { "vision" => false }.freeze
+        }.freeze,
+        # Per-primary lite pairing: subagents use smaller models for cheap/fast work.
+        "lite_models" => {
+          "glm-5.2"                => "glm-5.1",
+          "kimi-k3"                => "kimi-k2.6",
+          "gemma4"                 => "nemotron-3-nano",
+          "qwen3.5"                => "gemini-3-flash-preview",
+          "minimax-m3"             => "minimax-m2.7",
+          "kimi-k2.7-code"         => "kimi-k2.6",
+          "deepseek-v4-pro"        => "deepseek-v4-flash",
+          "mistral-large-3"        => "nemotron-3-nano",
+          "gpt-oss"                => "nemotron-3-nano",
+          "gemini-3-flash-preview"  => "nemotron-3-nano"
+        },
+        "default_ocr_model" => "kimi-k2.7-code",
+        "website_url" => "https://ollama.com/settings/keys"
+      }.freeze,
+
       "openai" => {
         "name" => "OpenAI (GPT)",
         "base_url" => "https://api.openai.com/v1",