openclacky 1.5.13 → 1.5.14

data/lib/clacky/ui2/ui_controller.rb

@@ -31,6 +31,7 @@ module Clacky
           working_dir: config[:working_dir],
           mode: config[:mode],
           model: config[:model],
+          reasoning_effort: config[:reasoning_effort],
           theme: config[:theme]
         }
 
@@ -81,6 +82,7 @@ module Clacky
           working_dir: @config[:working_dir],
           mode: @config[:mode],
           model: @config[:model],
+          reasoning_effort: @config[:reasoning_effort],
           tasks: @tasks_count,
           cost: @total_cost
         )
@@ -124,6 +126,7 @@ module Clacky
           working_dir: @config[:working_dir],
           mode: @config[:mode],
           model: @config[:model],
+          reasoning_effort: @config[:reasoning_effort],
           tasks: @tasks_count,
           cost: @total_cost,
           cost_source: cost_source,
@@ -1271,6 +1274,7 @@ module Clacky
           "",
           theme.format_text("Commands:", :info),
           "  #{theme.format_text("/model", :success)}       - Quickly switch the current model",
+          "  #{theme.format_text("/think", :success)}       - Set the thinking (reasoning) effort level",
           "  #{theme.format_text("/config", :success)}      - Configure models, API keys, settings",
           "  #{theme.format_text("/goal", :success)}        - Set a standing goal for autonomous work",
           "    #{theme.format_text("/goal <text>", :dim)}       Set a goal and start working toward it",
@@ -1803,6 +1807,7 @@ module Clacky
             working_dir: @config[:working_dir],
             mode: @config[:mode],
             model: @config[:model],
+            reasoning_effort: @config[:reasoning_effort],
             tasks: @tasks_count,
             cost: @total_cost
           )
@@ -1871,14 +1876,15 @@ module Clacky
             }
           end
 
-          # Add action buttons
-          choices << { name: "─" * 50, disabled: true }
-          choices << { name: "[+] Add New Model", value: { action: :add } }
+          # Add action buttons (sticky: always visible below the scrollable
+          # model list, so a long model list can't push them off screen)
+          choices << { name: "─" * 50, disabled: true, sticky: true }
+          choices << { name: "[+] Add New Model", value: { action: :add }, sticky: true }
           if current_config.models.length > 0
-            choices << { name: "[*] Edit Current Model", value: { action: :edit } }
-            choices << { name: "[-] Delete Model", value: { action: :delete } } if current_config.models.length > 1
+            choices << { name: "[*] Edit Current Model", value: { action: :edit }, sticky: true }
+            choices << { name: "[-] Delete Model", value: { action: :delete }, sticky: true } if current_config.models.length > 1
           end
-          choices << { name: "[X] Close", value: { action: :close } }
+          choices << { name: "[X] Close", value: { action: :close }, sticky: true }
 
           # Show menu
           result = modal.show(
@@ -1903,7 +1909,7 @@ module Clacky
             if new_model
               # Determine anthropic_format based on provider
               # For Anthropic provider, use Anthropic API format
-              anthropic_format = new_model[:provider] == "anthropic"
+              anthropic_format = new_model[:provider] == Clacky::Providers::ANTHROPIC_ID
 
               current_config.add_model(
                 model: new_model[:model],
@@ -2121,6 +2127,37 @@ module Clacky
         result # Return selected task_id or nil
       end
 
+      # Show a reasoning-effort picker for the `/think` command.
+      # @param current_effort [String, nil] the agent's current effort level
+      # @return [String, nil] the chosen level ("off"/"low"/.../"max") or nil if cancelled
+      public def show_reasoning_effort_menu(current_effort)
+        modal = Components::ModalComponent.new
+
+        descriptions = {
+          "off"    => "Provider default (no effort override)",
+          "low"    => "Light reasoning - fastest",
+          "medium" => "Balanced reasoning",
+          "high"   => "Deep reasoning",
+          "xhigh"  => "Extra deep reasoning",
+          "max"    => "Maximum reasoning - slowest"
+        }
+
+        active_index = nil
+        choices = descriptions.keys.each_with_index.map do |level, idx|
+          is_current = current_effort.nil? ? level == "off" : level == current_effort
+          active_index = idx if is_current
+          marker = is_current ? "● " : "  "
+          { name: "#{marker}#{level} - #{descriptions[level]}", value: level }
+        end
+
+        modal.show(
+          title: "Thinking Level - Set Reasoning Effort",
+          choices: choices,
+          initial_index: active_index,
+          on_close: -> { @layout.rerender_all }
+        )
+      end
+
       # Show form for editing a model
       # @param model [Hash, nil] Existing model hash or nil for new model
       # @return [Hash, nil] Updated model hash or nil if cancelled

data/lib/clacky/utils/file_processor.rb

@@ -299,7 +299,9 @@ module Clacky
       Zip::InputStream.open(StringIO.new(body)) do |zis|
         while (entry = zis.get_next_entry)
           size = entry.size ? " (#{entry.size} bytes)" : ""
-          lines << "- #{entry.name}#{size}"
+          # rubyzip returns names as raw ASCII-8BIT bytes regardless of the zip's
+          # UTF-8 flag; convert so the listing never carries binary encoding.
+          lines << "- #{Clacky::Utils::Encoding.to_utf8(entry.name)}#{size}"
         end
       end
       lines.join("\n")
@@ -325,7 +327,7 @@ module Clacky
             tar.each do |entry|
               kind = entry.directory? ? "[dir] " : ""
               size = entry.header.size ? " (#{entry.header.size} bytes)" : ""
-              lines << "- #{kind}#{entry.full_name}#{size}"
+              lines << "- #{kind}#{Clacky::Utils::Encoding.to_utf8(entry.full_name)}#{size}"
             end
           end
         end
@@ -339,7 +341,7 @@ module Clacky
               tar.each do |entry|
                 kind = entry.directory? ? "[dir] " : ""
                 size = entry.header.size ? " (#{entry.header.size} bytes)" : ""
-                lines << "- #{kind}#{entry.full_name}#{size}"
+                lines << "- #{kind}#{Clacky::Utils::Encoding.to_utf8(entry.full_name)}#{size}"
               end
             end
           end
@@ -359,7 +361,7 @@ module Clacky
                   found_tar = true
                   kind = entry.directory? ? "[dir] " : ""
                   size = entry.header.size ? " (#{entry.header.size} bytes)" : ""
-                  lines << "- #{kind}#{entry.full_name}#{size}"
+                  lines << "- #{kind}#{Clacky::Utils::Encoding.to_utf8(entry.full_name)}#{size}"
                 end
               end
             end
@@ -388,7 +390,8 @@ module Clacky
           end
         end
         lines = ["# GZIP Contents\n"]
-        lines << "- Original filename: #{original_name || "(not recorded)"}"
+        display_name = original_name ? Clacky::Utils::Encoding.to_utf8(original_name) : "(not recorded)"
+        lines << "- Original filename: #{display_name}"
         lines << "- Compressed size:   #{File.size(path)} bytes"
         lines << "- Uncompressed size: #{uncompressed} bytes#{uncompressed && uncompressed > 64 * 1024 * 1024 ? " (truncated)" : ""}"
         lines.join("\n")
@@ -406,7 +409,14 @@ module Clacky
       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)
+      # File.write transcodes to the default external encoding and raises
+      # "\xE8 from ASCII-8BIT to UTF-8" on binary (ASCII-8BIT) content, which
+      # can leak in from archive entry names / external parsers.
+      text = content.to_s
+      unless text.encoding == ::Encoding::UTF_8 && text.valid_encoding?
+        text = Clacky::Utils::Encoding.to_utf8(text)
+      end
+      File.write(dest, text)
       dest
     end
 
@@ -540,7 +550,9 @@ module Clacky
     LOCAL_IMAGE_EXTENSIONS = %w[.png .jpg .jpeg .gif .webp].freeze
     LOCAL_VIDEO_EXTENSIONS = %w[.mp4 .webm .mov].freeze
     LOCAL_AUDIO_EXTENSIONS = %w[.wav .mp3 .ogg .aac .flac .m4a].freeze
-    LOCAL_MEDIA_EXTENSIONS = (LOCAL_IMAGE_EXTENSIONS + LOCAL_VIDEO_EXTENSIONS + LOCAL_AUDIO_EXTENSIONS).freeze
+    # .pdf: served by /api/local-image so the WebUI file viewer can embed it
+    # in an iframe (browser-native PDF rendering, no extra dependency).
+    LOCAL_MEDIA_EXTENSIONS = (LOCAL_IMAGE_EXTENSIONS + LOCAL_VIDEO_EXTENSIONS + LOCAL_AUDIO_EXTENSIONS + %w[.pdf]).freeze
 
     # Replace local image paths in markdown content with base64 data URLs.
     #

data/lib/clacky/utils/mac_app_detector.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "open3"
+require "digest"
+require_relative "environment_detector"
+
+module Clacky
+  module Utils
+    # Detects installed macOS applications able to open a given file type.
+    #
+    # Builds an extension → apps index by scanning application bundles and
+    # parsing their Info.plist document declarations (CFBundleDocumentTypes),
+    # then applies a static supplement for well-known apps whose cross-format
+    # abilities are not declared in the plist — e.g. Keynote opens ppt/pptx
+    # without listing them. Non-macOS hosts always answer with an empty list.
+    module MacAppDetector
+      SEARCH_DIRS = [
+        "/Applications",
+        "/System/Applications",
+        File.expand_path("~/Applications")
+      ].freeze
+
+      # bundle name (without .app) => extensions it handles but does not
+      # declare in CFBundleDocumentTypes.
+      EXTRA_ABILITIES = {
+        "Keynote"              => %w[key kth ppt pptx pot pps ppsx],
+        "Pages"                => %w[pages doc docx dot rtf],
+        "Numbers"              => %w[numbers xls xlsx csv],
+        "Preview"              => %w[pdf png jpg jpeg gif tiff tif heic webp svg bmp],
+        "Microsoft PowerPoint" => %w[ppt pptx pot pps ppsx],
+        "Microsoft Word"       => %w[doc docx dot rtf],
+        "Microsoft Excel"      => %w[xls xlsx csv],
+      }.freeze
+
+      # @param ext [String] file extension, with or without leading dot
+      # @return [Array<Hash>] [{ "name" => ..., "path" => bundle path }]
+      def self.apps_for_ext(ext)
+        return [] unless Utils::EnvironmentDetector.os_type == :macos
+
+        ext = ext.to_s.downcase.sub(/\A\./, "")
+        return [] if ext.empty?
+
+        index[ext].sort_by { |a| a["name"] }
+      end
+
+      # Resolve an app name or bundle path to a scanned bundle path.
+      # @return [String, nil]
+      def self.app_path(name_or_path)
+        return nil unless Utils::EnvironmentDetector.os_type == :macos
+
+        all_apps[name_or_path.to_s] || all_apps.key(name_or_path.to_s)
+      end
+
+      # Return the application macOS would use to open `path` (the handler the
+      # plain `open` command would pick). Cached per file extension.
+      # @param path [String] absolute file path
+      # @return [Hash, nil] { "name" => ..., "path" => bundle path }
+      def self.default_app_for(path)
+        return nil unless Utils::EnvironmentDetector.os_type == :macos
+
+        ext = File.extname(path).downcase.sub(/\A\./, "")
+        return nil if ext.empty?
+
+        @default_app_cache ||= {}
+        return @default_app_cache[ext] if @default_app_cache.key?(ext)
+
+        bundle = default_app_bundle(path)
+        @default_app_cache[ext] =
+          if bundle && File.directory?(bundle)
+            { "name" => File.basename(bundle, ".app"), "path" => bundle }
+          end
+      end
+
+      # Query LaunchServices for the default handler of `path` via NSWorkspace.
+      # @return [String, nil] bundle path (…/*.app)
+      def self.default_app_bundle(path)
+        script = <<~JXA
+          (function() {
+            ObjC.import("AppKit");
+            var url = $.NSURL.fileURLWithPath(#{path.to_json});
+            var app = $.NSWorkspace.sharedWorkspace.URLForApplicationToOpenURL(url);
+            return app ? app.path.js : "";
+          })()
+        JXA
+        out, _err, _status = Open3.capture3("osascript", "-l", "JavaScript", "-e", script)
+        result = out.strip
+        result.empty? ? nil : result
+      rescue StandardError
+        nil
+      end
+
+      # Convert an application bundle icon (.icns) to a cached 64px PNG via the
+      # system `sips` tool. Used by the Web UI "open with" dropdown.
+      # @param bundle_path [String] application bundle path (…/*.app)
+      # @return [String, nil] path to the cached PNG file
+      def self.icon_png(bundle_path)
+        return nil unless Utils::EnvironmentDetector.os_type == :macos
+
+        bundle = bundle_path.to_s
+        return nil unless bundle.end_with?(".app") && File.directory?(bundle)
+
+        cache_dir = File.join(Dir.home, "Library", "Caches", "openclacky", "app-icons")
+        cache = File.join(cache_dir, Digest::MD5.hexdigest(bundle) + ".png")
+        return cache if File.exist?(cache)
+
+        info = read_plist(File.join(bundle, "Contents", "Info.plist"))
+        return nil unless info
+
+        icon = info["CFBundleIconFile"].to_s
+        return nil if icon.empty?
+        icon += ".icns" unless icon =~ /\.icns\z/i
+        icns = File.join(bundle, "Contents", "Resources", icon)
+        return nil unless File.exist?(icns)
+
+        require "fileutils"
+        FileUtils.mkdir_p(cache_dir)
+        ok = system("sips", "-s", "format", "png", "--resampleWidth", "64",
+                    icns, "--out", cache, out: File::NULL, err: File::NULL)
+        return nil unless ok && File.exist?(cache)
+        cache
+      end
+
+      # Open a file with a specific installed application (macOS only).
+      # @param path [String] absolute file path
+      # @param app [String] app name or bundle path, must be a scanned app
+      # @return [Boolean, nil] system() result, nil when the app is unknown
+      def self.open_with(path, app)
+        bundle = app_path(app.to_s)
+        return nil unless bundle
+        system("open", "-a", bundle, path)
+      end
+
+      def self.all_apps
+        return @all_apps if defined?(@all_apps)
+
+        @all_apps = {}
+        SEARCH_DIRS.each do |dir|
+          next unless File.directory?(dir)
+          Dir.glob(File.join(dir, "*.app")).each do |bundle|
+            @all_apps[File.basename(bundle, ".app")] = bundle
+          end
+        end
+        @all_apps
+      end
+
+      def self.index
+        return @index if defined?(@index)
+
+        @index = Hash.new { |h, k| h[k] = [] }
+
+        all_apps.each do |name, bundle|
+          info = read_plist(File.join(bundle, "Contents", "Info.plist"))
+          next unless info
+          (info["CFBundleDocumentTypes"] || []).each do |dt|
+            (dt["CFBundleTypeExtensions"] || []).each do |e|
+              add(@index, e.to_s.downcase, name, bundle)
+            end
+          end
+        end
+
+        EXTRA_ABILITIES.each do |name, exts|
+          bundle = all_apps[name]
+          next unless bundle
+          exts.each { |e| add(@index, e, name, bundle) }
+        end
+
+        @index
+      end
+
+      def self.add(index, ext, name, bundle)
+        return if ext.empty?
+        list = index[ext]
+        list << { "name" => name, "path" => bundle } unless list.any? { |a| a["path"] == bundle }
+      end
+
+      def self.read_plist(path)
+        out, _err, _status = Open3.capture3("plutil", "-convert", "json", "-o", "-", path)
+        return nil if out.nil? || out.empty?
+        require "json"
+        JSON.parse(out)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/clacky/utils/model_pricing.rb

@@ -176,28 +176,40 @@ module Clacky
       #   - "cache miss input" = regular prompt_tokens rate
       #   - "cache hit input"  = cache_read rate (DeepSeek has no separate cache-write charge)
       #   - No tiered pricing (single rate regardless of context length)
-      # Effective 2026-08-16 16:00 UTC DeepSeek switched to peak/off-peak billing
-      # (off-peak = half of peak; peak = 01:00-04:00 & 06:00-10:00 UTC).
-      # Effective 2026-08-23 00:00 Beijing time, weekends (Sat/Sun, Beijing
-      # time) are billed entirely at off-peak rates regardless of hour.
-      # Each entry carries legacy/peak/off_peak tiers; calculate_cost resolves
-      # the active tier from the request time.
-      "deepseek-v4-flash" => {
+      # Peak/off-peak billing (off-peak = half of peak; peak = 01:00-04:00 &
+      # 06:00-10:00 UTC). Weekends (Sat/Sun, Beijing time) are billed entirely
+      # at off-peak rates regardless of hour.
+      # v4-pro keeps its own rates until 2026-09-14, when it is routed to
+      # V4.1 Flash and billed at the flash rates (see flash_peak/flash_off_peak).
+      # Each entry carries peak/off_peak tiers; calculate_cost resolves the
+      # active tier from the request time.
+      # V4.1 Flash — new canonical model id. Native multimodal; the retired
+      # v4-flash / v4-flash-vision-exp ids are routed here for compatibility.
+      "deepseek-flash" => {
         deepseek: true,
-        legacy: {
-          input:  { default: 0.14,   over_200k: 0.14 },   # $0.14/MTok  (pre-cutover flat)
-          output: { default: 0.28,   over_200k: 0.28 },   # $0.28/MTok
-          cache:  { write: 0.14,     read: 0.0028 }       # $0.0028/MTok cache hit
+        peak: {
+          input:  { default: 0.30,   over_200k: 0.30 },
+          output: { default: 1.20,   over_200k: 1.20 },
+          cache:  { write: 0.30,     read: 0.006 }
         },
+        off_peak: {
+          input:  { default: 0.15,   over_200k: 0.15 },
+          output: { default: 0.60,   over_200k: 0.60 },
+          cache:  { write: 0.15,     read: 0.003 }
+        }
+      },
+
+      "deepseek-v4-flash" => {
+        deepseek: true,
         peak: {
-          input:  { default: 0.44,   over_200k: 0.44 },   # $0.44/MTok  cache miss (peak)
-          output: { default: 1.32,   over_200k: 1.32 },   # $1.32/MTok
-          cache:  { write: 0.44,     read: 0.014 }        # $0.014/MTok cache hit
+          input:  { default: 0.30,   over_200k: 0.30 },   # $0.30/MTok  cache miss (peak)
+          output: { default: 1.20,   over_200k: 1.20 },   # $1.20/MTok
+          cache:  { write: 0.30,     read: 0.006 }        # $0.006/MTok cache hit
         },
         off_peak: {
-          input:  { default: 0.22,   over_200k: 0.22 },   # $0.22/MTok  (half of peak)
-          output: { default: 0.66,   over_200k: 0.66 },   # $0.66/MTok
-          cache:  { write: 0.22,     read: 0.007 }        # $0.007/MTok cache hit
+          input:  { default: 0.15,   over_200k: 0.15 },   # $0.15/MTok  (half of peak)
+          output: { default: 0.60,   over_200k: 0.60 },   # $0.60/MTok
+          cache:  { write: 0.15,     read: 0.003 }        # $0.003/MTok cache hit
         }
       },
 
@@ -205,30 +217,20 @@ module Clacky
       # as tokens per DeepSeek's image tokenization rules).
       "deepseek-v4-flash-vision-exp" => {
         deepseek: true,
-        legacy: {
-          input:  { default: 0.14,   over_200k: 0.14 },
-          output: { default: 0.28,   over_200k: 0.28 },
-          cache:  { write: 0.14,     read: 0.0028 }
-        },
         peak: {
-          input:  { default: 0.44,   over_200k: 0.44 },
-          output: { default: 1.32,   over_200k: 1.32 },
-          cache:  { write: 0.44,     read: 0.014 }
+          input:  { default: 0.30,   over_200k: 0.30 },
+          output: { default: 1.20,   over_200k: 1.20 },
+          cache:  { write: 0.30,     read: 0.006 }
         },
         off_peak: {
-          input:  { default: 0.22,   over_200k: 0.22 },
-          output: { default: 0.66,   over_200k: 0.66 },
-          cache:  { write: 0.22,     read: 0.007 }
+          input:  { default: 0.15,   over_200k: 0.15 },
+          output: { default: 0.60,   over_200k: 0.60 },
+          cache:  { write: 0.15,     read: 0.003 }
         }
       },
 
       "deepseek-v4-pro" => {
         deepseek: true,
-        legacy: {
-          input:  { default: 0.435,  over_200k: 0.435 },  # $0.435/MTok  (pre-cutover flat)
-          output: { default: 0.87,   over_200k: 0.87 },   # $0.87/MTok
-          cache:  { write: 0.435,    read: 0.003625 }     # $0.003625/MTok cache hit
-        },
         peak: {
           input:  { default: 1.32,   over_200k: 1.32 },   # $1.32/MTok  cache miss (peak)
           output: { default: 3.96,   over_200k: 3.96 },   # $3.96/MTok
@@ -238,6 +240,18 @@ module Clacky
           input:  { default: 0.66,   over_200k: 0.66 },   # $0.66/MTok  (half of peak)
           output: { default: 1.98,   over_200k: 1.98 },   # $1.98/MTok
           cache:  { write: 0.66,     read: 0.022 }        # $0.022/MTok cache hit
+        },
+        # Routed to V4.1 Flash from 2026-09-14 12:00 Beijing time and billed
+        # at the flash rates.
+        flash_peak: {
+          input:  { default: 0.30,   over_200k: 0.30 },
+          output: { default: 1.20,   over_200k: 1.20 },
+          cache:  { write: 0.30,     read: 0.006 }
+        },
+        flash_off_peak: {
+          input:  { default: 0.15,   over_200k: 0.15 },
+          output: { default: 0.60,   over_200k: 0.60 },
+          cache:  { write: 0.15,     read: 0.003 }
         }
       },
 
@@ -484,53 +498,80 @@ module Clacky
         }
       },
 
-      # GPT-5.6 flat-rate models (no breakpoint, single rate regardless of
-      # context; *-pro variants are priced identically to the base tier).
-      # Source: OpenAI list price ($/MTok) via OpenRouter model pages, incl.
-      # the OpenAI-direct provider row (verified 2026-08-18). Cache write is
-      # not published separately; it follows the GPT-5.5 convention (= input).
+      # GPT-5.6 via Bedrock's OpenAI-compatible endpoint (Global CRIS).
+      # Tiered at 272K input tokens (OpenAI's breakpoint) — same caveat as
+      # GPT-6 Astra below. USD per 1M tokens, source: llm_proxy bedrock_openai
+      # pricing. *-pro variants are priced identically to the base tier.
       "gpt-5.6-sol" => {
         input: {
-          default: 2.50,
-          over_200k: 2.50
+          default: 4.00,
+          over_200k: 8.00
         },
         output: {
-          default: 15.00,
-          over_200k: 15.00
+          default: 20.00,
+          over_200k: 30.00
         },
         cache: {
-          write: 2.50,
-          read: 0.25
+          write_default: 5.00,
+          write_over_200k: 10.00,
+          read_default: 0.40,
+          read_over_200k: 0.80
         }
       },
 
       "gpt-5.6-terra" => {
         input: {
           default: 2.00,
-          over_200k: 2.00
+          over_200k: 4.00
         },
         output: {
           default: 12.00,
-          over_200k: 12.00
+          over_200k: 18.00
         },
         cache: {
-          write: 2.00,
-          read: 0.20
+          write_default: 2.50,
+          write_over_200k: 5.00,
+          read_default: 0.20,
+          read_over_200k: 0.40
         }
       },
 
       "gpt-5.6-luna" => {
         input: {
           default: 0.20,
-          over_200k: 0.20
+          over_200k: 0.40
         },
         output: {
           default: 1.20,
-          over_200k: 1.20
+          over_200k: 1.80
         },
         cache: {
-          write: 0.20,
-          read: 0.02
+          write_default: 0.25,
+          write_over_200k: 0.50,
+          read_default: 0.02,
+          read_over_200k: 0.04
+        }
+      },
+
+      # GPT-6 Astra via Bedrock's OpenAI-compatible endpoint (Global CRIS).
+      # Tiered at 272K input tokens (OpenAI's breakpoint, not the global 200K)
+      # — the 200K–272K band is slightly over-estimated, same caveat as
+      # GPT-5.5/5.4 below. USD per 1M tokens, source: llm_proxy bedrock_openai
+      # pricing.
+      "gpt-6-astra" => {
+        input: {
+          default: 10.00,
+          over_200k: 20.00
+        },
+        output: {
+          default: 50.00,
+          over_200k: 75.00
+        },
+        cache: {
+          write_default: 12.50,
+          write_over_200k: 25.00,
+          read_default: 1.00,
+          read_over_200k: 2.00
         }
       },
 
@@ -854,9 +895,9 @@ module Clacky
     # Costs for prompts between 200K–272K will be slightly over-estimated.
     TIERED_PRICING_THRESHOLD = 200_000
 
-    # DeepSeek switched from flat legacy rates to peak/off-peak billing at
-    # 2026-08-17 00:00 Beijing time (= 2026-08-16 16:00 UTC).
-    DEEPSEEK_PEAK_PRICING_START = Time.utc(2026, 8, 16, 16, 0, 0).freeze
+    # v4-pro is routed to V4.1 Flash and billed at the flash rates from
+    # 2026-09-14 12:00 Beijing time (= 04:00 UTC).
+    DEEPSEEK_V4_PRO_FLASH_START = Time.utc(2026, 9, 14, 4, 0, 0)
 
     class << self
       # Calculate cost for the given model and usage
@@ -1000,6 +1041,9 @@ module Clacky
           "deepseek-v4-flash-vision-exp"
         when /deepseek-v4-flash/i, /deepseek.*v4.*flash/i
           "deepseek-v4-flash"
+        # V4.1 Flash — new canonical id; native multimodal.
+        when /deepseek-flash/i
+          "deepseek-flash"
         # Legacy aliases: deepseek-chat and deepseek-reasoner are being
         # deprecated on 2026-07-24 and map to deepseek-v4-flash's
         # non-thinking / thinking modes respectively. Bill at flash rates.
@@ -1102,11 +1146,13 @@ module Clacky
         # anchored rules above would otherwise miss it) and the "-pro"
         # suffix (pro is priced identically to the base tier). Batch ids
         # (":batch") stay unmatched - they bill at half price.
-        when %r{^(openai/)?gpt-?5[\.-]?6[\.-]?sol(-pro)?$}i
+        when /^(?:abs-|us\.openai\.|global\.openai\.|openai\/)?gpt-?6[.-]?astra$/i
+          "gpt-6-astra"
+        when %r{^(?:abs-|global\.openai\.|openai/)?gpt-?5[\.-]?6[\.-]?sol(-pro)?$}i
           "gpt-5.6-sol"
-        when %r{^(openai/)?gpt-?5[\.-]?6[\.-]?terra(-pro)?$}i
+        when %r{^(?:abs-|global\.openai\.|openai/)?gpt-?5[\.-]?6[\.-]?terra(-pro)?$}i
           "gpt-5.6-terra"
-        when %r{^(openai/)?gpt-?5[\.-]?6[\.-]?luna(-pro)?$}i
+        when %r{^(?:abs-|global\.openai\.|openai/)?gpt-?5[\.-]?6[\.-]?luna(-pro)?$}i
           "gpt-5.6-luna"
         when /^gpt-?5\.?5$/i, /^gpt-?5[\.-]?5$/i
           "gpt-5.5"        
@@ -1163,17 +1209,19 @@ module Clacky
         cache_cost
       end
 
-      # Resolve a DeepSeek pricing entry (which holds legacy/peak/off_peak
-      # tiers) to the single tier that applies at the given time.
+      # Resolve a DeepSeek pricing entry (which holds peak/off_peak tiers) to
+      # the single tier that applies at the given time.
       def resolve_deepseek_tier(pricing, now)
-        if now < DEEPSEEK_PEAK_PRICING_START
-          pricing[:legacy]
-        elsif deepseek_weekend?(now)
+        # v4-pro migrates to V4.1 Flash on 2026-09-14; its entry carries
+        # flash_peak/flash_off_peak.
+        if pricing.key?(:flash_peak) && now >= DEEPSEEK_V4_PRO_FLASH_START
+          return deepseek_weekend?(now) || !deepseek_peak_hour?(now) ? pricing[:flash_off_peak] : pricing[:flash_peak]
+        end
+
+        if deepseek_weekend?(now) || !deepseek_peak_hour?(now)
           pricing[:off_peak]
-        elsif deepseek_peak_hour?(now)
-          pricing[:peak]
         else
-          pricing[:off_peak]
+          pricing[:peak]
         end
       end