openclacky 0.9.7 → 0.9.9

data/lib/clacky/tools/invoke_skill.rb

@@ -51,16 +51,21 @@ module Clacky
             skill_type: "subagent"
           }
         else
-          # Unified injection path: delegate to SkillManager#inject_skill_as_assistant_message.
-          # This ensures brand skill transient handling, template expansion, and message
-          # structure are identical to the slash command path — single source of truth.
-          task_id = agent.instance_variable_get(:@current_task_id)
-          agent.send(:inject_skill_as_assistant_message, skill, task, task_id)
-
-          {
-            message: "Skill '#{skill_name}' instructions expanded. Proceed to execute the task.",
-            skill_type: "inline"
-          }
+          # Deferred injection path: enqueue the skill inject on the agent.
+          #
+          # Injecting inside execute() would produce an illegal message ordering for Bedrock:
+          #   assistant: {toolUse: invoke_skill}
+          #   assistant: {text: skill_instructions}   ← injected here (breaks pairing)
+          #   user:      {toolResult: invoke_skill}   ← observe() appends this too late
+          #
+          # Instead, enqueue the injection so the agent loop can flush it AFTER observe()
+          # appends the toolResult, producing the correct sequence:
+          #   assistant: {toolUse: invoke_skill}
+          #   user:      {toolResult: ...}            ← observe() appends first
+          #   assistant: {text: skill_instructions}   ← flush_pending_injections runs here
+          #   user:      "[SYSTEM] please proceed"
+          agent.enqueue_injection(skill, task)
+          "Skill '#{skill_name}' instructions expanded. Proceed to execute the task."
         end
       end
 
@@ -76,7 +81,9 @@ module Clacky
       # @param result [Hash] Tool execution result
       # @return [String] Formatted result summary
       def format_result(result)
-        if result[:error]
+        if result.is_a?(String)
+          result
+        elsif result[:error]
           "Error: #{result[:error]}"
         elsif result[:skill_type] == "subagent"
           "Subagent executed successfully"

data/lib/clacky/tools/shell.rb

@@ -339,10 +339,13 @@ module Clacky
         }
       end
 
-      # Truncate output to max_lines, adding a truncation notice if needed
+      # Truncate output to max_lines and max line length, adding a truncation notice if needed
       def truncate_output(output, max_lines)
         return output if output.nil? || output.empty?
 
+        # First truncate individual long lines (e.g. minified JS/CSS, expanded JSON)
+        output = truncate_long_lines(output, MAX_LINE_CHARS)
+
         lines = output.lines
         return output if lines.length <= max_lines
 
@@ -390,13 +393,18 @@ module Clacky
         # Return error info as-is if command failed or timed out
         return result if result[:error] || result[:state] == 'TIMEOUT' || result[:state] == 'WAITING_INPUT'
 
-        stdout = result[:stdout] || ""
-        stderr = result[:stderr] || ""
+        # Ensure all string fields are valid UTF-8 before JSON serialization.
+        # stdout/stderr are already scrubbed by EncodingSafeBuffer, but :command
+        # (and any other string field) may still carry ASCII-8BIT encoding when
+        # the caller built the command from binary paths or ENV values.
+        enc = Clacky::Utils::Encoding
+        stdout = enc.to_utf8(result[:stdout] || "")
+        stderr = enc.to_utf8(result[:stderr] || "")
         exit_code = result[:exit_code] || 0
 
         # Build compact result with truncated output
         compact = {
-          command: result[:command],
+          command: enc.to_utf8(result[:command].to_s),
           exit_code: exit_code,
           success: result[:success]
         }
@@ -405,7 +413,7 @@ module Clacky
         compact[:elapsed] = result[:elapsed] if result[:elapsed]
 
         # Extract command name for temp file naming
-        command_name = extract_command_name(result[:command])
+        command_name = extract_command_name(compact[:command])
 
         # Process stdout: truncate and optionally save to temp file
         stdout_info = truncate_and_save(stdout, MAX_LLM_OUTPUT_CHARS, "stdout", command_name)
@@ -433,8 +441,9 @@ module Clacky
       def truncate_and_save(output, max_chars, label, command_name)
         return { content: "", temp_file: nil } if output.empty?
 
-        # Truncate individual long lines first (e.g., minified CSS/JS files)
-        # This prevents a single huge line from consuming all token budget
+        # Truncate individual long lines (e.g., minified CSS/JS files)
+        # truncate_output already does this, but truncate_and_save may be called
+        # with raw output that hasn't gone through truncate_output
         output = truncate_long_lines(output, MAX_LINE_CHARS)
 
         return { content: output, temp_file: nil } if output.length <= max_chars

data/lib/clacky/tools/web_fetch.rb

@@ -119,7 +119,9 @@ module Clacky
             raise "Too many redirects" if redirects > max_redirects
 
             location = response["location"]
-            uri = URI.parse(location)
+            new_uri = URI.parse(location)
+            # Handle relative redirects by merging with the current URI
+            uri = new_uri.relative? ? uri.merge(new_uri) : new_uri
           else
             raise "HTTP error: #{response.code} #{response.message}"
           end

data/lib/clacky/ui2/README.md

@@ -68,7 +68,7 @@ The Agent calls these methods directly:
 ```ruby
 # Show messages
 @ui.show_assistant_message("Hello!")
-@ui.show_user_message("Hi there", images: [])
+@ui.show_user_message("Hi there", files: [])
 
 # Show tool operations
 @ui.show_tool_call("file_reader", { path: "test.rb" })

data/lib/clacky/ui2/components/input_area.rb

@@ -292,7 +292,9 @@ module Clacky
           @files.each_with_index do |f, idx|
             move_cursor(current_row, 0)
             filename = f[:name] || f["name"] || "file"
-            content = @pastel.dim("[File #{idx + 1}] #{filename} (Ctrl+D to delete)")
+            size     = f[:size] || f["size"]
+            size_str = size ? " #{format_filesize(size)}" : ""
+            content = @pastel.dim("[File #{idx + 1}] #{filename}#{size_str} (Ctrl+D to delete)")
             print_with_padding(content)
             current_row += 1
           end
@@ -881,7 +883,8 @@ module Clacky
           if pasted[:type] == :image
             path = pasted[:path]
             mime_type = pasted[:mime_type] || "image/png"
-            @files << { name: File.basename(path), mime_type: mime_type, path: path }
+            size = File.exist?(path) ? File.size(path) : 0
+            @files << { name: File.basename(path), mime_type: mime_type, path: path, size: size }
             clear_tips
           else
             insert_text(pasted[:text])

data/lib/clacky/ui2/components/welcome_banner.rb

@@ -3,6 +3,7 @@
 require "pastel"
 require_relative "../../version"
 require_relative "../block_font"
+require_relative "../../utils/workspace_rules"
 
 module Clacky
   module UI2
@@ -85,10 +86,32 @@ module Clacky
           lines << ""
           lines << info_line("Working Directory", working_dir)
           lines << info_line("Permission Mode", mode)
+
+          # Show loaded project rules file if present
+          main = Utils::WorkspaceRules.find_main(working_dir)
+          lines << info_line("Project Rules", "#{main[:name]} ✓") if main
+
           lines << ""
           lines << theme.format_text("[!] Type 'exit' or 'quit' to terminate session", :thinking)
           lines << separator("-")
           lines << ""
+
+          # Show sub-project agents block if any sub-dirs have .clackyrules
+          sub_projects = Utils::WorkspaceRules.find_sub_projects(working_dir)
+          unless sub_projects.empty?
+            lines << @pastel.bright_cyan("[>] SUB-PROJECT AGENT MODE")
+            lines << @pastel.dim("    #{sub_projects.size} sub-project(s) detected with rules:")
+            sub_projects.each do |sp|
+              first_line = sp[:summary].lines.first&.strip&.delete_prefix("#")&.strip
+              label = @pastel.cyan("    • #{sp[:sub_name]}/")
+              desc = first_line && !first_line.empty? ? @pastel.dim(" — #{first_line}") : ""
+              lines << "#{label}#{desc}"
+            end
+            lines << @pastel.dim("    AI will read each sub-project's full .clackyrules before working in it.")
+            lines << separator("-")
+            lines << ""
+          end
+
           lines.join("\n")
         end
 

data/lib/clacky/ui2/ui_controller.rb

@@ -290,9 +290,15 @@ module Clacky
         token_info << pastel.dim("Total: #{token_data[:total_tokens]}")
 
         # Cost for this iteration with color coding (red/yellow for high cost, dim for normal)
-        if token_data[:cost]
+        # :api    => "$0.001234"      (exact, from API)
+        # :price  => "~$0.001234"     (estimated from pricing table)
+        # :default => "N/A"           (model not in pricing table, unknown cost)
+        cost_source = token_data[:cost_source]
+        if cost_source == :default
+          token_info << pastel.dim("Cost: N/A")
+        elsif token_data[:cost]
           cost = token_data[:cost]
-          cost_value = "$#{cost.round(6)}"
+          cost_value = cost_source == :price ? "~$#{cost.round(6)}" : "$#{cost.round(6)}"
           if cost >= 0.1
             # High cost - red warning
             colored_cost = pastel.decorate(cost_value, :red, :dim)
@@ -585,6 +591,14 @@ module Clacky
         append_output(output)
       end
 
+      # Show idle compression status (two-phase: start → end).
+      # In terminal mode, only the final state is printed.
+      def show_idle_status(phase:, message:)
+        return unless phase.to_s == "end"
+        output = @renderer.render_system_message(message)
+        append_output(output)
+      end
+
       # Show warning message
       # @param message [String] Warning message
       def show_warning(message)

data/lib/clacky/ui_interface.rb

@@ -38,6 +38,12 @@ module Clacky
     def set_working_status; end
     def set_idle_status; end
 
+    # === Idle compression status ===
+    # Emits a two-phase idle compression status update.
+    # phase: :start  → show "Idle detected. Compressing..." (with spinner)
+    # phase: :end    → update same element with final result (skipped / compressed)
+    def show_idle_status(phase:, message:); end
+
     # === Blocking interaction ===
     def request_confirmation(message, default: true); end
 
@@ -45,6 +51,7 @@ module Clacky
     def clear_input; end
     def set_input_tips(message, type: :info); end
 
+    # === Path redaction (for encrypted brand skill tmpdirs) ===
     # === Lifecycle ===
     def stop; end
   end

data/lib/clacky/utils/file_processor.rb

@@ -5,29 +5,23 @@ require "fileutils"
 require "securerandom"
 require "stringio"
 
-require_relative "file_parser/docx_parser"
-require_relative "file_parser/xlsx_parser"
-require_relative "file_parser/pptx_parser"
-require_relative "file_parser/zip_parser"
+require_relative "parser_manager"
+require "zip"
 
 module Clacky
   module Utils
-  # Unified file processing pipeline.
+  # File processing pipeline.
   #
-  # For every uploaded file we:
-  #   1. Save the original to disk (so the agent can always access the raw bytes).
-  #   2. Generate a structured preview (Markdown) where possible.
-  #   3. Return a FileRef struct describing both paths.
+  # Two entry points:
+  #   FileProcessor.save(body:, filename:)
+  #     → Store raw bytes to disk only. Returns { name:, path: }.
+  #       Used by http_server and channel adapters — no parsing here.
   #
-  # The agent prompt receives a concise block like:
+  #   FileProcessor.process_path(path, name: nil)
+  #     → Parse an already-saved file. Returns FileRef (with preview_path or parse_error).
+  #       Used by agent.run when building the file prompt.
   #
-  #   [File: contract.docx]
-  #   Type: document
-  #   Original: /tmp/clacky-uploads/abc123.docx
-  #   Preview (Markdown): /tmp/clacky-uploads/abc123.docx.preview.md
-  #
-  # This gives the LLM structure-aware content immediately while keeping the
-  # original available for deeper processing via shell tools.
+  # (FileProcessor.process = save + process_path in one call, for convenience.)
   module FileProcessor
     UPLOAD_DIR      = File.join(Dir.tmpdir, "clacky-uploads").freeze
     MAX_FILE_BYTES  = 32 * 1024 * 1024  # 32 MB
@@ -46,12 +40,10 @@ module Clacky
       .db .sqlite .bin .dat
     ].freeze
 
-    # Binary files that glob should still return (useful as file references even if unreadable)
     GLOB_ALLOWED_BINARY_EXTENSIONS = %w[
       .pdf .doc .docx .ppt .pptx .xls .xlsx .odt .odp .ods
     ].freeze
 
-    # Extensions that can be sent to LLM as base64 (images + PDF)
     LLM_BINARY_EXTENSIONS = %w[.png .jpg .jpeg .gif .webp .pdf].freeze
 
     MIME_TYPES = {
@@ -63,175 +55,130 @@ module Clacky
       ".pdf"  => "application/pdf"
     }.freeze
 
-    # Result struct returned by .process
-    FileRef = Struct.new(:name, :type, :original_path, :preview_path, keyword_init: true) do
-      # Returns a formatted string to inject into the agent prompt.
-      def to_prompt
-        lines = ["[File: #{name}]", "Type: #{type}"]
-        lines << "Original: #{original_path}" if original_path
-        lines << "Preview (Markdown): #{preview_path}" if preview_path
-        lines.join("\n")
+    FILE_TYPES = {
+      ".docx" => :document,  ".doc"  => :document,
+      ".xlsx" => :spreadsheet, ".xls" => :spreadsheet,
+      ".pptx" => :presentation, ".ppt" => :presentation,
+      ".pdf"  => :pdf,
+      ".zip"  => :zip, ".gz" => :zip, ".tar" => :zip, ".rar" => :zip, ".7z" => :zip,
+      ".png"  => :image, ".jpg" => :image, ".jpeg" => :image,
+      ".gif"  => :image, ".webp" => :image
+    }.freeze
+
+    # FileRef: result of process / process_path.
+    FileRef = Struct.new(:name, :type, :original_path, :preview_path, :parse_error, :parser_path, keyword_init: true) do
+      def parse_failed?
+        preview_path.nil? && !parse_error.nil?
       end
     end
 
-    # Process an uploaded file.
+    # ---------------------------------------------------------------------------
+    # Public API
+    # ---------------------------------------------------------------------------
+
+    # Store raw bytes to disk — no parsing.
+    # Used by http_server upload endpoint and channel adapters.
     #
-    # @param body      [String] Raw file bytes
-    # @param filename  [String] Original filename (used for extension detection + display)
-    # @return [FileRef]
-    def self.process(body:, filename:)
+    # @return [Hash] { name: String, path: String }
+    def self.save(body:, filename:)
       FileUtils.mkdir_p(UPLOAD_DIR)
-
-      ext       = File.extname(filename.to_s).downcase
       safe_name = sanitize_filename(filename)
-      file_id   = SecureRandom.hex(8)
-
-      case ext
-      when ".docx", ".doc"
-        process_office(body, file_id, safe_name, :document) { FileParser::DocxParser.parse(body) }
-
-      when ".xlsx", ".xls"
-        process_office(body, file_id, safe_name, :spreadsheet) { FileParser::XlsxParser.parse(body) }
+      dest      = File.join(UPLOAD_DIR, "#{SecureRandom.hex(8)}_#{safe_name}")
+      File.binwrite(dest, body)
+      { name: safe_name, path: dest }
+    end
 
-      when ".pptx", ".ppt"
-        process_office(body, file_id, safe_name, :presentation) { FileParser::PptxParser.parse(body) }
+    # Parse an already-saved file and return a FileRef.
+    # Called by agent.run for each disk file before building the prompt.
+    #
+    # @param path [String] Path to the file on disk
+    # @param name [String] Display name (defaults to basename)
+    # @return [FileRef]
+    def self.process_path(path, name: nil)
+      name ||= File.basename(path.to_s)
+      ext   = File.extname(path.to_s).downcase
+      type  = FILE_TYPES[ext] || :file
 
+      case ext
       when ".zip"
-        process_zip(body, file_id, safe_name)
-
-      when ".pdf"
-        process_binary(body, file_id, safe_name, :pdf)
+        body            = File.binread(path)
+        preview_content = parse_zip_listing(body)
+        preview_path    = save_preview(preview_content, path)
+        FileRef.new(name: name, type: :zip, original_path: path, preview_path: preview_path)
 
       when ".png", ".jpg", ".jpeg", ".gif", ".webp"
-        process_binary(body, file_id, safe_name, :image)
+        FileRef.new(name: name, type: :image, original_path: path)
 
       else
-        process_binary(body, file_id, safe_name, :file)
+        result = Utils::ParserManager.parse(path)
+        if result[:success]
+          preview_path = save_preview(result[:text], path)
+          FileRef.new(name: name, type: type, original_path: path, preview_path: preview_path)
+        else
+          FileRef.new(name: name, type: type, original_path: path,
+                      parse_error: result[:error], parser_path: result[:parser_path])
+        end
       end
     end
 
-    # --- private ---
-
-    # Save original + generate markdown preview via the given block.
-    def self.process_office(body, file_id, safe_name, type)
-      original_path = save_original(body, file_id, safe_name)
-
-      preview_content = yield
-      preview_path    = save_preview(preview_content, file_id, safe_name)
-
-      FileRef.new(name: safe_name, type: type, original_path: original_path, preview_path: preview_path)
-    rescue => e
-      # If preview generation fails, still return the original path
-      FileRef.new(name: safe_name, type: type, original_path: original_path,
-                  preview_path: nil)
-    end
-
-    # ZIP: save original + generate directory listing as preview.
-    def self.process_zip(body, file_id, safe_name)
-      original_path   = save_original(body, file_id, safe_name)
-      preview_content = FileParser::ZipParser.parse(body)
-      preview_path    = save_preview(preview_content, file_id, safe_name)
-
-      FileRef.new(name: safe_name, type: :zip, original_path: original_path, preview_path: preview_path)
-    end
-
-    # Binary files (PDF, images, unknown): save original only.
-    def self.process_binary(body, file_id, safe_name, type)
-      original_path = save_original(body, file_id, safe_name)
-      FileRef.new(name: safe_name, type: type, original_path: original_path, preview_path: nil)
+    # Save + parse in one call (convenience method).
+    #
+    # @return [FileRef]
+    def self.process(body:, filename:)
+      saved = save(body: body, filename: filename)
+      process_path(saved[:path], name: saved[:name])
     end
 
-    def self.save_original(body, file_id, safe_name)
-      dest = File.join(UPLOAD_DIR, "#{file_id}_#{safe_name}")
+    # Save raw image bytes to disk and return a FileRef.
+    # Used by agent when an image exceeds MAX_IMAGE_BYTES and must be downgraded to disk.
+    def self.save_image_to_disk(body:, mime_type:, filename: "image.jpg")
+      FileUtils.mkdir_p(UPLOAD_DIR)
+      safe_name = sanitize_filename(filename)
+      dest      = File.join(UPLOAD_DIR, "#{SecureRandom.hex(8)}_#{safe_name}")
       File.binwrite(dest, body)
-      dest
+      FileRef.new(name: safe_name, type: :image, original_path: dest)
     end
 
-    def self.save_preview(content, file_id, safe_name)
-      dest = File.join(UPLOAD_DIR, "#{file_id}_#{safe_name}.preview.md")
-      File.write(dest, content, encoding: "UTF-8")
-      dest
-    end
+    # ---------------------------------------------------------------------------
+    # File type helpers (used by tools and agent)
+    # ---------------------------------------------------------------------------
 
-    def self.sanitize_filename(name)
-      base = File.basename(name.to_s).gsub(/[^\w.\-]/, "_")
-      base.empty? ? "upload" : base
-    end
-
-    # Returns true if the file is binary (non-text).
     def self.binary_file_path?(path)
       ext = File.extname(path).downcase
       return true if BINARY_EXTENSIONS.include?(ext)
-
-      # Fallback: sniff first 512 bytes for null bytes
-      sample = File.binread(path, 512).to_s
-      sample.include?("\x00")
+      File.binread(path, 512).to_s.include?("\x00")
     rescue
       false
     end
 
-    # Returns true if the file is binary but should still appear in glob results.
-    # (e.g. PDF, Office docs — useful as file references even if content is unreadable)
     def self.glob_allowed_binary?(path)
-      ext = File.extname(path).downcase
-      GLOB_ALLOWED_BINARY_EXTENSIONS.include?(ext)
+      GLOB_ALLOWED_BINARY_EXTENSIONS.include?(File.extname(path).downcase)
     end
 
-    # Returns true if the binary file can be sent to LLM as base64.
     def self.supported_binary_file?(path)
-      ext = File.extname(path).downcase
-      LLM_BINARY_EXTENSIONS.include?(ext)
+      LLM_BINARY_EXTENSIONS.include?(File.extname(path).downcase)
     end
 
-    # Save raw image bytes to disk and return a FileRef.
-    # Used by agent when an image exceeds MAX_IMAGE_BYTES and must be downgraded to a file.
-    # @param body      [String] Raw image bytes
-    # @param mime_type [String] e.g. "image/jpeg"
-    # @param filename  [String] Suggested filename
-    # @return [FileRef]
-    def self.save_image_to_disk(body:, mime_type:, filename: "image.jpg")
-      FileUtils.mkdir_p(UPLOAD_DIR)
-      ext       = File.extname(filename).downcase
-      ext       = ".#{mime_type.split('/').last}" if ext.empty? && mime_type.to_s.start_with?("image/")
-      ext       = ".jpg" if ext.empty?
-      safe_name = sanitize_filename(filename)
-      file_id   = SecureRandom.hex(8)
-      process_binary(body, file_id, safe_name, :image)
+    def self.detect_mime_type(path, _data = nil)
+      MIME_TYPES[File.extname(path).downcase] || "application/octet-stream"
     end
 
-    # Convert a binary file (image/PDF) to base64 for LLM consumption.
-    # @return [Hash] { format:, mime_type:, size_bytes:, base64_data: }
     def self.file_to_base64(path)
       require "base64"
       ext  = File.extname(path).downcase
       size = File.size(path)
-
       raise ArgumentError, "File too large: #{path}" if size > MAX_FILE_BYTES
-
       mime = MIME_TYPES[ext] || "application/octet-stream"
       data = Base64.strict_encode64(File.binread(path))
-
       { format: ext[1..], mime_type: mime, size_bytes: size, base64_data: data }
     end
 
-    # Detect MIME type from file extension (and optionally data bytes).
-    def self.detect_mime_type(path, _data = nil)
-      MIME_TYPES[File.extname(path).downcase] || "application/octet-stream"
-    end
-
-    # Convert a local image file path to a data: URL for vision APIs.
-    # Used by CLI --image flag path → agent format_user_content.
-    #
-    # @param path [String] Local image file path
-    # @return [String] "data:<mime>;base64,<encoded>"
     def self.image_path_to_data_url(path)
       raise ArgumentError, "Image file not found: #{path}" unless File.exist?(path)
-
       size = File.size(path)
       if size > MAX_IMAGE_BYTES
-        raise ArgumentError, "Image too large (#{size / 1024 / 1024}MB > #{MAX_IMAGE_BYTES / 1024 / 1024}MB): #{path}"
+        raise ArgumentError, "Image too large (#{size / 1024}KB > #{MAX_IMAGE_BYTES / 1024}KB): #{path}"
       end
-
       require "base64"
       ext  = File.extname(path).downcase.delete(".")
       mime = case ext
@@ -241,12 +188,42 @@ module Clacky
              when "webp"        then "image/webp"
              else "image/#{ext}"
              end
-
       "data:#{mime};base64,#{Base64.strict_encode64(File.binread(path))}"
     end
 
-    private_class_method :process_office, :process_zip, :process_binary,
-                         :save_original, :save_preview, :sanitize_filename
+    # ---------------------------------------------------------------------------
+    # Private helpers
+    # ---------------------------------------------------------------------------
+
+    def self.parse_zip_listing(body)
+      lines = ["# ZIP Contents\n"]
+      Zip::InputStream.open(StringIO.new(body)) do |zis|
+        while (entry = zis.get_next_entry)
+          size = entry.size ? " (#{entry.size} bytes)" : ""
+          lines << "- #{entry.name}#{size}"
+        end
+      end
+      lines.join("\n")
+    rescue => e
+      "# ZIP Contents\n(could not list entries: #{e.message})"
+    end
+
+    def self.save_preview(content, original_path)
+      dest = "#{original_path}.preview.md"
+      File.write(dest, content, encoding: "UTF-8")
+      dest
+    end
+
+    def self.sanitize_filename(name)
+      # Keep Unicode letters/digits (including CJK), ASCII word chars, dots, hyphens, spaces.
+      # Only strip characters that are unsafe on common filesystems: / \ : * ? " < > | \0
+      base = File.basename(name.to_s)
+               .gsub(/[\/\\\:\*\?"<>|\x00]/, "_")
+               .strip
+      base.empty? ? "upload" : base
+    end
+
+    private_class_method :parse_zip_listing, :save_preview, :sanitize_filename
   end
   end
 end

data/lib/clacky/utils/model_pricing.rb

@@ -224,13 +224,14 @@ module Clacky
         return model if PRICING_TABLE.key?(model)
         
         # Check for Claude model variations
-        # Support both dot and dash separators (e.g., "4.5" or "4-5")
+        # Support both dot and dash separators (e.g., "4.5", "4-5", "4-6")
+        # Also handles Bedrock cross-region prefixes (e.g. "jp.anthropic.claude-sonnet-4-6")
         case model
-        when /claude.*opus.*4[.-]?5/i
+        when /claude.*opus.*4[.-]?[56]/i
           "claude-opus-4.5"
-        when /claude.*sonnet.*4[.-]?5/i
+        when /claude.*sonnet.*4[.-]?[56]/i
           "claude-sonnet-4.5"
-        when /claude.*haiku.*4[.-]?5/i
+        when /claude.*haiku.*4[.-]?[56]/i
           "claude-haiku-4.5"
         when /claude-3-5-sonnet-20241022/i
           "claude-3-5-sonnet-20241022"