openclacky 1.0.1 → 1.0.2

data/lib/clacky/default_skills/skill-add/scripts/install_from_zip.rb

@@ -19,7 +19,7 @@ require 'find'
 class ZipSkillInstaller
   ZIP_URL_PATTERN = %r{^https?://.+\.zip(\?.*)?$}i
 
-  def initialize(zip_source, skill_name: nil, target_dir: nil)
+  def initialize(zip_source, skill_name: nil, target_dir: nil, skip_if_exists: false)
     @zip_source = zip_source
     @local_path = local_zip_path?(zip_source)
     # skill_name can be provided explicitly (e.g. slug from the store API).
@@ -27,45 +27,72 @@ class ZipSkillInstaller
     # "ui-ux-pro-max-1.0.0.zip" → "ui-ux-pro-max".
     @skill_name = skill_name || infer_skill_name(zip_source)
     @target_dir = target_dir || File.join(Dir.home, '.clacky', 'skills')
+    # When true, existing skill directories are preserved and the install for
+    # that specific skill is skipped (recorded in @skipped_skills).
+    # Default false keeps the legacy "overwrite" behaviour for `install`.
+    @skip_if_exists   = skip_if_exists
+    # Suppresses user-facing puts for programmatic callers (set by `perform`).
+    @silent           = false
     @installed_skills = []
-    @errors = []
+    @skipped_skills   = []
+    @errors           = []
   end
 
-  # Main installation entry point.
+  # Programmatic entry point for library-style callers (e.g. onboard pre-install).
+  #
+  # Unlike `install`, this method:
+  #   - does NOT print user-facing output
+  #   - does NOT call `exit` on failure (raises instead)
+  #   - returns a result hash: { installed: [...], skipped: [...], errors: [...] }
+  #
+  # The caller is responsible for rendering feedback and deciding whether any
+  # error is fatal.
+  def perform
+    @silent = true
+    do_install
+    { installed: @installed_skills, skipped: @skipped_skills, errors: @errors }
+  end
+
+  # Main installation entry point (CLI). Prints progress, prints a final
+  # report, and calls `exit` on failure. Use `perform` for programmatic use.
   def install
+    do_install
+    report_results
+  rescue ArgumentError => e
+    puts "Error: #{e.message}"
+    exit 1
+  rescue StandardError => e
+    puts "Error: Installation failed: #{e.message}"
+    exit 1
+  end
+
+  # Shared core used by both `install` (CLI) and `perform` (library).
+  # Raises on invalid input; the caller decides how to surface errors.
+  private def do_install
     if @local_path
       # Install directly from a local zip file — no download needed.
-      # Expand tilde in path (e.g. ~/Downloads/skill.zip)
+      # Expand tilde in path (e.g. ~/Downloads/skill.zip).
       expanded = File.expand_path(@zip_source)
-      raise ArgumentError, "File not found: #{@zip_source}" unless File.exist?(expanded)
-      raise ArgumentError, "Not a zip file: #{@zip_source}" unless expanded.end_with?('.zip')
+      raise ArgumentError, "File not found: #{@zip_source}"  unless File.exist?(expanded)
+      raise ArgumentError, "Not a zip file: #{@zip_source}"  unless expanded.end_with?('.zip')
 
       Dir.mktmpdir('clacky-zip-') do |tmpdir|
         extract_zip(expanded, tmpdir)
-        extracted_dir = File.join(tmpdir, 'extracted')
-        discover_and_install_skills(extracted_dir)
+        discover_and_install_skills(File.join(tmpdir, 'extracted'))
       end
     else
       # Install from a remote URL.
       unless valid_zip_url?
-        raise ArgumentError, "Invalid zip source: #{@zip_source}\nProvide an http(s) URL ending with .zip, or an absolute path to a local zip file."
+        raise ArgumentError, "Invalid zip source: #{@zip_source}\n" \
+                             "Provide an http(s) URL ending with .zip, or an absolute path to a local zip file."
       end
 
       Dir.mktmpdir('clacky-zip-') do |tmpdir|
         zip_path = download_zip(tmpdir)
         extract_zip(zip_path, tmpdir)
-        extracted_dir = File.join(tmpdir, 'extracted')
-        discover_and_install_skills(extracted_dir)
+        discover_and_install_skills(File.join(tmpdir, 'extracted'))
       end
     end
-
-    report_results
-  rescue ArgumentError => e
-    puts "❌ #{e.message}"
-    exit 1
-  rescue StandardError => e
-    puts "❌ Installation failed: #{e.message}"
-    exit 1
   end
 
   # Return true if the source looks like a local file path (absolute or relative ending in .zip).
@@ -93,8 +120,10 @@ class ZipSkillInstaller
 
   # Download the zip file to tmpdir and return its local path.
   private def download_zip(tmpdir)
-    puts "⬇️  Downloading skill package..."
-    puts "   #{@zip_source}"
+    unless @silent
+      puts "Downloading skill package..."
+      puts "   #{@zip_source}"
+    end
 
     zip_path = File.join(tmpdir, 'skill.zip')
     uri = URI.parse(@zip_source)
@@ -129,7 +158,7 @@ class ZipSkillInstaller
 
   # Extract the zip archive into <tmpdir>/extracted/.
   private def extract_zip(zip_path, tmpdir)
-    puts "📂 Extracting package..."
+    puts "Extracting package..." unless @silent
     extracted_dir = File.join(tmpdir, 'extracted')
     FileUtils.mkdir_p(extracted_dir)
 
@@ -184,7 +213,11 @@ class ZipSkillInstaller
     target_path = File.join(@target_dir, name)
 
     if File.exist?(target_path)
-      puts "♻️  Skill '#{name}' already exists — overwriting..."
+      if @skip_if_exists
+        @skipped_skills << { name: name, path: target_path, reason: 'already exists' }
+        return
+      end
+      puts "Skill '#{name}' already exists — overwriting..." unless @silent
       FileUtils.rm_rf(target_path)
     end
 
@@ -218,7 +251,7 @@ class ZipSkillInstaller
     puts "\n" + "=" * 60
 
     if @installed_skills.empty?
-      puts "❌ No skills were installed."
+      puts "No skills were installed."
       if @errors.any?
         puts "\nErrors:"
         @errors.each { |e| puts "   • #{e}" }
@@ -226,7 +259,7 @@ class ZipSkillInstaller
       exit 1
     end
 
-    puts "✅ Installation complete!"
+    puts "Installation complete!"
     puts "\nInstalled #{@installed_skills.size} skill(s):\n\n"
     @installed_skills.each do |skill|
       puts "   ✓ #{skill[:name]}"
@@ -236,7 +269,7 @@ class ZipSkillInstaller
     end
 
     if @errors.any?
-      puts "⚠️  Warnings:"
+      puts "Warnings:"
       @errors.each { |e| puts "   • #{e}" }
       puts
     end

data/lib/clacky/providers.rb

@@ -125,6 +125,15 @@ module Clacky
         "api" => "openai-completions",
         "default_model" => "MiniMax-M2.7",
         "models" => ["MiniMax-M2.5", "MiniMax-M2.7"],
+        # MiniMax operates two regional endpoints with identical APIs & model
+        # lineup — mainland China (.com) and international (.io). Listing both
+        # lets find_by_base_url identify either one as provider "minimax",
+        # 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
+        ].freeze,
         # MiniMax M2.x does not support multimodal/vision input on this endpoint.
         "capabilities" => { "vision" => false }.freeze,
         "website_url" => "https://www.minimaxi.com/user-center/basic-information/interface-key"
@@ -136,6 +145,17 @@ module Clacky
         "api" => "openai-completions",
         "default_model" => "kimi-k2.6",
         "models" => ["kimi-k2.6", "kimi-k2.5"],
+        # Moonshot operates two regional endpoints with identical APIs & model
+        # lineup — mainland China (.cn) and international (.ai). Kimi does not
+        # distinguish pay-as-you-go vs coding-plan at the base_url level, so
+        # only two variants are needed. Listing both here lets find_by_base_url
+        # identify either one as provider "kimi", so downstream capability
+        # checks, fallback chains, and provider-specific behaviours work
+        # regardless of which endpoint the user configured.
+        "endpoint_variants" => [
+          { "label" => "Mainland China", "label_key" => "settings.models.baseurl.variant.mainland_cn",   "base_url" => "https://api.moonshot.cn/v1", "region" => "cn"   }.freeze,
+          { "label" => "International",  "label_key" => "settings.models.baseurl.variant.international", "base_url" => "https://api.moonshot.ai/v1", "region" => "intl" }.freeze
+        ].freeze,
         # k2.5 / k2.6 are multimodal; legacy k2 text-only models need model_capabilities override if added.
         "capabilities" => { "vision" => true }.freeze,
         "website_url" => "https://platform.moonshot.cn/console/api-keys"
@@ -192,11 +212,26 @@ module Clacky
       }.freeze,
 
       "glm" => {
-        "name" => "GLM (ZhipuAI)",
+        "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"],
+        # 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
+        # same model lineup & identical capability profile, so a single preset
+        # with endpoint_variants is the right shape — one source of truth for
+        # vision/model_capabilities, four URLs recognised by find_by_base_url.
+        # Without this, users pointing at api.z.ai or the /coding/ path fell
+        # through to the conservative "assume vision=true" default and got
+        # hallucinated image descriptions on text-only GLM models (C-5563).
+        "endpoint_variants" => [
+          { "label" => "Mainland · Pay-as-you-go",      "label_key" => "settings.models.baseurl.variant.mainland_cn_payg",    "base_url" => "https://open.bigmodel.cn/api/paas/v4",        "region" => "cn"   }.freeze,
+          { "label" => "Mainland · Coding Plan",        "label_key" => "settings.models.baseurl.variant.mainland_cn_coding",  "base_url" => "https://open.bigmodel.cn/api/coding/paas/v4", "region" => "cn"   }.freeze,
+          { "label" => "International · Pay-as-you-go", "label_key" => "settings.models.baseurl.variant.international_payg",  "base_url" => "https://api.z.ai/api/paas/v4",                "region" => "intl" }.freeze,
+          { "label" => "International · Coding Plan",   "label_key" => "settings.models.baseurl.variant.international_coding","base_url" => "https://api.z.ai/api/coding/paas/v4",         "region" => "intl" }.freeze
+        ].freeze,
         # GLM models are text-only except glm-5v-turbo which is vision-capable ("v" = visual).
         "capabilities" => { "vision" => false }.freeze,
         "model_capabilities" => {
@@ -376,14 +411,33 @@ module Clacky
       # Find provider ID by base URL.
       # Matches if the given URL starts with the provider's base_url (after normalisation),
       # so both exact matches and sub-path variants (e.g. "/v1") are recognised.
+      #
+      # Also scans `endpoint_variants` (when present) so providers that operate
+      # multiple regional / billing-plan endpoints under the same identity
+      # (e.g. GLM on open.bigmodel.cn + api.z.ai, MiniMax on .com + .io) are
+      # all recognised as that single provider — one capability definition,
+      # N entry URLs. Without this, users configured with a non-default
+      # variant fall back to the "unknown provider" path and miss capability
+      # enforcement (see C-5563).
       # @param base_url [String] The base URL to look up
       # @return [String, nil] The provider ID or nil if not found
       def find_by_base_url(base_url)
         return nil if base_url.nil? || base_url.empty?
         normalized = base_url.to_s.chomp("/")
         PRESETS.find do |_id, preset|
-          preset_base = preset["base_url"].to_s.chomp("/")
-          normalized == preset_base || normalized.start_with?("#{preset_base}/")
+          # Collect every URL this preset claims: the canonical base_url plus
+          # any declared endpoint_variants. Dedup so the canonical one showing
+          # up in both lists doesn't change behaviour.
+          candidates = [preset["base_url"]]
+          variants = preset["endpoint_variants"]
+          if variants.is_a?(Array)
+            variants.each { |v| candidates << v["base_url"] if v.is_a?(Hash) }
+          end
+          candidates.compact.uniq.any? do |candidate|
+            preset_base = candidate.to_s.chomp("/")
+            next false if preset_base.empty?
+            normalized == preset_base || normalized.start_with?("#{preset_base}/")
+          end
         end&.first
       end
 

data/lib/clacky/server/channel/adapters/feishu/adapter.rb

@@ -166,6 +166,20 @@ module Clacky
           # @param event [Hash] Parsed message event
           # @return [void]
           def handle_message_event(event)
+            # In group chats, only respond when the bot is explicitly @-mentioned.
+            # Private chats always respond.
+            # Fail closed: if the bot's own open_id cannot be fetched (API error,
+            # bad credentials, etc.), drop group messages instead of responding to
+            # every message and spamming the group.
+            if event[:chat_type] == :group
+              bot_id = @bot.bot_open_id
+              if bot_id.nil?
+                Clacky::Logger.warn("[feishu] bot_open_id unavailable; dropping group message to avoid spam")
+                return
+              end
+              return unless Array(event[:mentioned_open_ids]).include?(bot_id)
+            end
+
             allowed_users = @config[:allowed_users]
             if allowed_users && !allowed_users.empty?
               return unless allowed_users.include?(event[:user_id])

data/lib/clacky/server/channel/adapters/feishu/bot.rb

@@ -226,6 +226,16 @@ module Clacky
             }.join
           end
 
+          # Get this bot's own open_id (cached, fetched lazily on first use).
+          # Used to detect @bot mentions in group chats.
+          # @return [String, nil] bot open_id, or nil if the API call fails
+          def bot_open_id
+            @bot_open_id ||= get("/open-apis/bot/v3/info").dig("bot", "open_id")
+          rescue => e
+            Clacky::Logger.warn("[feishu] Failed to fetch bot_open_id: #{e.message}")
+            nil
+          end
+
           # Get tenant access token (cached)
           # @return [String] Access token
           def tenant_access_token

data/lib/clacky/server/channel/adapters/feishu/message_parser.rb

@@ -98,6 +98,7 @@ module Clacky
               message_id: message_id,
               timestamp: timestamp,
               chat_type: chat_type,
+              mentioned_open_ids: Array(message["mentions"]).filter_map { |m| m.dig("id", "open_id") },
               raw: @data
             }
           rescue JSON::ParserError

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

@@ -27,8 +27,14 @@ module Clacky
       # @param run_agent_task     [Proc] (session_id, agent, &task) — from HttpServer
       # @param interrupt_session  [Proc] (session_id) — from HttpServer
       # @param channel_config     [Clacky::ChannelConfig]
-      # @param binding_mode       [:user | :chat] how to map IM identities to sessions
-      def initialize(session_registry:, session_builder:, run_agent_task:, interrupt_session:, channel_config:, binding_mode: :user)
+      # @param binding_mode       [:user | :chat | :chat_user] how to map IM identities to sessions.
+      #   :chat_user (default) — one session per (chat, user) pair. Most natural:
+      #                          private chat = that user's session; in a group each
+      #                          user has their own session; the same user across
+      #                          different groups keeps those contexts separate.
+      #   :chat                — one session per chat (all users in a group share it).
+      #   :user                — one session per user (merges DMs and all groups).
+      def initialize(session_registry:, session_builder:, run_agent_task:, interrupt_session:, channel_config:, binding_mode: :chat_user)
         @registry          = session_registry
         @session_builder   = session_builder
         @run_agent_task    = run_agent_task
@@ -354,8 +360,10 @@ module Clacky
       def channel_key(event)
         platform = event[:platform].to_s
         case @binding_mode
-        when :chat then "#{platform}:chat:#{event[:chat_id]}"
-        else            "#{platform}:user:#{event[:user_id]}"
+        when :chat      then "#{platform}:chat:#{event[:chat_id]}"
+        when :user      then "#{platform}:user:#{event[:user_id]}"
+        else # :chat_user (default)
+          "#{platform}:chat:#{event[:chat_id]}:user:#{event[:user_id]}"
         end
       end
 

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

@@ -33,9 +33,15 @@ module Clacky
 
       # Update the reply context for the current inbound message.
       # Called at the start of each route_message so replies are threaded correctly.
-      # @param event [Hash] inbound event with :message_id
+      # Also updates chat_id — a session may span multiple chats (e.g. same user
+      # in both a direct message and a group), and each inbound event dictates
+      # where outbound replies should be routed.
+      # @param event [Hash] inbound event with :message_id and :chat_id
       def update_message_context(event)
-        @mutex.synchronize { @message_id = event[:message_id] }
+        @mutex.synchronize do
+          @message_id = event[:message_id]
+          @chat_id    = event[:chat_id] if event[:chat_id]
+        end
       end
 
       # === Output display ===

data/lib/clacky/server/http_server.rb

@@ -2706,12 +2706,16 @@ module Clacky
       def api_list_providers(res)
         providers = Clacky::Providers::PRESETS.map do |id, preset|
           {
-            id:            id,
-            name:          preset["name"],
-            base_url:      preset["base_url"],
-            default_model: preset["default_model"],
-            models:        preset["models"] || [],
-            website_url:   preset["website_url"]
+            id:                id,
+            name:              preset["name"],
+            base_url:          preset["base_url"],
+            default_model:     preset["default_model"],
+            models:            preset["models"] || [],
+            # Frontend uses this to render a Base URL dropdown (regional /
+            # billing-plan variants) when present. Absent for single-endpoint
+            # providers — UI renders a plain text input in that case.
+            endpoint_variants: preset["endpoint_variants"],
+            website_url:       preset["website_url"]
           }
         end
         json_response(res, 200, { providers: providers })

data/lib/clacky/utils/file_processor.rb

@@ -141,26 +141,14 @@ module Clacky
         FileRef.new(name: name, type: :image, original_path: path)
 
       when ".csv"
-        # CSV is plain text — read directly, no external parser needed.
-        # Try UTF-8 first, then GBK (common in Chinese-origin CSV), then binary with replacement.
-        begin
-          text         = read_text_with_encoding_fallback(path)
-          preview_path = save_preview(text, path)
-          FileRef.new(name: name, type: :csv, original_path: path, preview_path: preview_path)
-        rescue => e
-          FileRef.new(name: name, type: :csv, original_path: path, parse_error: e.message)
-        end
+        # CSV is plain text — the file itself IS the preview. No parser, no copy.
+        # FileReader handles encoding fallback via safe_utf8 when it reads the file.
+        FileRef.new(name: name, type: :csv, original_path: path, preview_path: path)
 
       when *TEXT_PREVIEW_EXTENSIONS
-        # Markdown / plain text: the file itself IS the preview.
-        # No parser needed — just copy through (with encoding normalisation).
-        begin
-          text         = read_text_with_encoding_fallback(path)
-          preview_path = save_preview(text, path)
-          FileRef.new(name: name, type: :text, original_path: path, preview_path: preview_path)
-        rescue => e
-          FileRef.new(name: name, type: :text, original_path: path, parse_error: e.message)
-        end
+        # Markdown / plain text / log: the file itself IS the preview.
+        # No parser needed, no tmpdir copy — just point preview_path at the original.
+        FileRef.new(name: name, type: :text, original_path: path, preview_path: path)
 
       else
         result = Utils::ParserManager.parse(path)
@@ -397,7 +385,14 @@ module Clacky
     end
 
     def self.save_preview(content, original_path)
-      dest = "#{original_path}.preview.md"
+      # Always write previews to a tmpdir-based path to avoid polluting the
+      # user's working directory with .preview.md sidecar files.
+      # Use the same UPLOAD_DIR that uploaded files live in; for on-disk files
+      # outside that dir (e.g. project files opened by file_reader), we still
+      # land in UPLOAD_DIR so the user's tree stays clean.
+      FileUtils.mkdir_p(UPLOAD_DIR)
+      safe_name = File.basename(original_path.to_s).gsub(/[\/\:\*?"<>|\x00]/, "_")
+      dest = File.join(UPLOAD_DIR, "#{SecureRandom.hex(8)}_#{safe_name}.preview.md")
       File.write(dest, content)
       dest
     end
@@ -413,26 +408,6 @@ module Clacky
       base.empty? ? 'upload' : base
     end
 
-    # Read a text file with automatic encoding detection.
-    # Tries UTF-8, then GBK (common for Chinese-origin CSV/text files), then
-    # falls back to binary read with invalid byte replacement.
-    def self.read_text_with_encoding_fallback(path)
-      # Try UTF-8 first (most common, fastest path)
-      raw = File.binread(path)
-      utf8 = raw.dup.force_encoding("UTF-8")
-      return utf8.encode("UTF-8") if utf8.valid_encoding?
-
-      # Try GBK (GB2312 superset — common in Chinese Windows/Excel exports)
-      begin
-        return raw.encode("UTF-8", "GBK", invalid: :replace, undef: :replace, replace: "?")
-      rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
-        # fall through
-      end
-
-      # Last resort: binary read with replacement characters
-      raw.encode("UTF-8", "binary", invalid: :replace, undef: :replace, replace: "?")
-    end
-
     # Detect the actual image MIME type from raw binary data by inspecting
     # magic bytes, ignoring the file extension. Falls back to extension-based
     # detection when magic bytes don't match any known format.
@@ -549,7 +524,6 @@ module Clacky
     end
 
     private_class_method :parse_zip_listing, :parse_tar_listing, :save_preview, :sanitize_filename,
-                         :read_text_with_encoding_fallback,
                          :downscale_png_chunky, :downscale_via_cli
   end
   end

data/lib/clacky/utils/model_pricing.rb

@@ -279,6 +279,79 @@ module Clacky
         }
       },
 
+      # GLM (Zhipu / Z.ai) — USD per 1M tokens.
+      # Source: https://docs.z.ai/guides/overview/pricing (Z.ai international).
+      # Pricing policy: we always bill at the Z.ai international flat rate,
+      # regardless of which endpoint (mainland bigmodel.cn vs intl z.ai) the
+      # user configured. Rationale:
+      #   1. Mainland GLM uses tiered pricing (≤32K / >32K / >128K) where the
+      #      >32K tier is hit by the vast majority of real requests, and is
+      #      actually a few RMB cheaper than Z.ai's flat rate — displaying the
+      #      (slightly higher) Z.ai rate gives users a "displayed ≤ actual"
+      #      experience which is psychologically safer than the reverse.
+      #   2. Single flat rate keeps the table shape consistent with every
+      #      other provider here (no special-case tier logic for just GLM).
+      # Cache-write: same convention as DeepSeek/Kimi — OpenAI-compatible
+      # endpoints don't charge separately for cache writes (Z.ai's page lists
+      # "Cached Input Storage: Limited-time Free"), so bill writes at the
+      # regular input miss rate for safe "displayed ≤ actual" behaviour.
+      "glm-5.1" => {
+        input:  { default: 1.40, over_200k: 1.40 },
+        output: { default: 4.40, over_200k: 4.40 },
+        cache:  { write: 1.40, read: 0.26 }
+      },
+
+      "glm-5" => {
+        input:  { default: 1.00, over_200k: 1.00 },
+        output: { default: 3.20, over_200k: 3.20 },
+        cache:  { write: 1.00, read: 0.20 }
+      },
+
+      "glm-5-turbo" => {
+        input:  { default: 1.20, over_200k: 1.20 },
+        output: { default: 4.00, over_200k: 4.00 },
+        cache:  { write: 1.20, read: 0.24 }
+      },
+
+      # GLM-5V-Turbo is the multimodal sibling of GLM-5-Turbo (vision capable,
+      # see providers.rb model_capabilities override). Same input/output rate
+      # as 5-Turbo per Z.ai's Vision Models table.
+      "glm-5v-turbo" => {
+        input:  { default: 1.20, over_200k: 1.20 },
+        output: { default: 4.00, over_200k: 4.00 },
+        cache:  { write: 1.20, read: 0.24 }
+      },
+
+      "glm-4.7" => {
+        input:  { default: 0.60, over_200k: 0.60 },
+        output: { default: 2.20, over_200k: 2.20 },
+        cache:  { write: 0.60, read: 0.11 }
+      },
+
+      # MiniMax — USD per 1M tokens.
+      # Source: https://platform.minimaxi.com (Pay-as-You-Go).
+      # MiniMax pricing is identical across mainland (.com) and international
+      # (.io) endpoints, verified by the team. Same cache-write convention as
+      # DeepSeek/Kimi/GLM: bill writes at the input miss rate (OpenAI-compatible
+      # usage responses from MiniMax don't reliably carry a separate
+      # cache_creation_input_tokens field, so a distinct write rate would be
+      # dead code in practice).
+      # Note: providers.rb uses the capitalised "MiniMax-M2.x" model id, but
+      # the pricing table keys are lowercased to stay consistent with the
+      # rest of this file; normalize_model_name() lowercases incoming model
+      # names before lookup.
+      "minimax-m2.5" => {
+        input:  { default: 0.30, over_200k: 0.30 },
+        output: { default: 1.20, over_200k: 1.20 },
+        cache:  { write: 0.30, read: 0.03 }
+      },
+
+      "minimax-m2.7" => {
+        input:  { default: 0.30, over_200k: 0.30 },
+        output: { default: 1.20, over_200k: 1.20 },
+        cache:  { write: 0.30, read: 0.06 }
+      },
+
     }.freeze
 
     # Threshold for tiered pricing (200K tokens)
@@ -418,6 +491,28 @@ module Clacky
           "kimi-k2.5"
         when /^kimi-k2\.?6$/i
           "kimi-k2.6"
+        # GLM (Zhipu / Z.ai) — the five models registered in providers.rb.
+        # GLM-5V-Turbo is the vision variant; all five share the same Z.ai
+        # international flat-rate pricing regardless of which endpoint
+        # (mainland bigmodel.cn vs intl z.ai) the user configured.
+        # Strict anchored match so unrelated strings like "glm-5-x-foo"
+        # don't silently borrow a nearby model's rate.
+        when /^glm-5\.1$/i
+          "glm-5.1"
+        when /^glm-5v-turbo$/i
+          "glm-5v-turbo"
+        when /^glm-5-turbo$/i
+          "glm-5-turbo"
+        when /^glm-5$/i
+          "glm-5"
+        when /^glm-4\.7$/i
+          "glm-4.7"
+        # MiniMax — model ids in providers.rb use capitalised "MiniMax-M2.x"
+        # but we match case-insensitively and map to the lowercased table key.
+        when /^minimax-m2\.5$/i
+          "minimax-m2.5"
+        when /^minimax-m2\.7$/i
+          "minimax-m2.7"
 
         # OpenAI GPT-5.x models — match various dashed/dotted/compact forms
         # (e.g. "gpt-5.5", "gpt-5-5", "gpt5.5", "gpt55")

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end