openclacky 1.5.19 → 1.5.21

data/lib/clacky/agent.rb

@@ -24,6 +24,7 @@ require_relative "agent/skill_evolution"
 require_relative "agent/skill_reflector"
 require_relative "agent/skill_auto_creator"
 require_relative "agent/fake_tool_call_detector"
+require_relative "agent/feedback"
 require_relative "agent/goal_state"
 require_relative "agent/goal_manager"
 
@@ -31,6 +32,7 @@ module Clacky
   class Agent
     # Include all functionality modules
     include MessageCompressorHelper
+    include Feedback
     include ToolExecutor
     include CostTracker
     include SessionSerializer
@@ -52,8 +54,18 @@ module Clacky
     attr_accessor :pinned
     attr_accessor :channel_info
     attr_accessor :project_id
+    # ISO8601 stamp set when the user archives the session; nil = active.
+    # Archived sessions stay on disk but drop out of every normal list.
+    attr_accessor :archived_at
 
     REASONING_EFFORTS = %w[low medium high xhigh max].freeze
+    # Sessionbar/config values meaning "no explicit level". They stay a string
+    # instead of collapsing to nil so format adapters can tell an explicit
+    # "default" apart from "user never chose": for models whose provider
+    # default is the deepest level (MiniMax M3.1-Flash, GLM-5.3) the adapters
+    # map this value to their lightest effort.
+    REASONING_DEFAULT = "off"
+    REASONING_DEFAULT_ALIASES = %w[off none disabled nothink].freeze
     MAX_VIDEO_UNDERSTANDING_BYTES = Utils::FileProcessor::MAX_FILE_BYTES
     MAX_VIDEO_BASE64_BYTES = 45 * 1024 * 1024
     MAX_VIDEO_DESCRIPTION_CHARS = 500
@@ -68,6 +80,16 @@ module Clacky
       @config&.permission_mode&.to_s || ""
     end
 
+    # Persist an explicit session choice separately from temporary goal mode.
+    def permission_mode=(value)
+      mode = value.to_s
+      raise ArgumentError, "Invalid permission mode" unless %w[confirm_all auto_approve].include?(mode)
+      @permission_mode_override = mode
+      @config.permission_mode = mode.to_sym
+      @pre_goal_permission_mode = nil
+      notify_permission_mode_change(mode.to_sym)
+    end
+
     def reasoning_effort=(value)
       @reasoning_effort = normalize_reasoning_effort(value)
     end
@@ -75,7 +97,8 @@ module Clacky
     private def normalize_reasoning_effort(value)
       return nil if value.nil?
       str = value.to_s.strip.downcase
-      return nil if str.empty? || str == "off" || str == "none"
+      return nil if str.empty?
+      return REASONING_DEFAULT if REASONING_DEFAULT_ALIASES.include?(str)
       return str if REASONING_EFFORTS.include?(str)
       nil
     end
@@ -85,6 +108,7 @@ module Clacky
     def initialize(client, config, working_dir:, ui:, profile:, session_id:, source:)
       @client = client  # Client for current model
       @config = config.is_a?(AgentConfig) ? config : AgentConfig.new(config)
+      @client_options = @config.client_options
       @agent_profile = AgentProfile.load(profile)
       @source = source.to_sym  # :manual | :cron | :channel
       @channel_info = nil  # { platform:, user_id:, user_name:, chat_id: } set by ChannelManager
@@ -93,6 +117,7 @@ module Clacky
       @session_id = session_id
       @name = ""
       @pinned = false
+      @archived_at = nil
       @history = MessageHistory.new
       @todos = []  # Store todos in memory
       @iterations = 0
@@ -113,7 +138,7 @@ module Clacky
       @task_cost_source = :estimated  # Track cost source for current task
       @previous_total_tokens = 0  # Track tokens from previous iteration for delta calculation
       @latest_latency = nil  # Most recent LLM call's latency metrics (see Client#send_messages_with_tools)
-      @reasoning_effort = nil  # Per-session reasoning effort override; nil = provider default
+      @reasoning_effort = REASONING_DEFAULT  # Sessionbar shows "Default" for a fresh session; adapters resolve it per model
       @ui = ui  # UIController for direct UI interaction
       @debug_logs = []  # Debug logs for troubleshooting
       @input_mutex = Mutex.new
@@ -235,23 +260,25 @@ module Clacky
     # Rebuild the underlying Client (and dependent components) to pick up
     # credentials/model name from the currently-selected model in @config.
     private def rebuild_client_for_current_model!
-      entry = @config.current_model
-      @client = Clacky::Client.new(
-        @config.api_key,
-        base_url: @config.base_url,
-        model: @config.model_name,
-        anthropic_format: @config.anthropic_format?,
-        api_format: @config.api_format,
-        provider_id: @config.provider_id_for(entry),
-        capabilities: entry && entry["capabilities"]
-      )
-      # Update message compressor with new client and model
-      @message_compressor = MessageCompressor.new(@client, model: current_model)
+      build_client!
 
       # Inject a new session context to notify the AI of the model switch
       inject_session_context
     end
 
+    private def build_client!
+      @client_options = @config.client_options
+      opts = @client_options.dup
+      @client = Clacky::Client.new(opts.delete(:api_key), **opts)
+      # Update message compressor with new client and model
+      @message_compressor = MessageCompressor.new(@client, model: current_model)
+    end
+
+    # The shared model card can be edited (Settings, config reload) under a live session.
+    private def refresh_client_if_card_changed!
+      build_client! unless @config.client_options == @client_options
+    end
+
     # Change the working directory for this session
     # Injects a new session context to notify the AI of the directory change
     def change_working_dir(new_dir)
@@ -329,6 +356,14 @@ module Clacky
       self
     end
 
+    # Built-in run failures share the persisted event trail, without exposing
+    # built-in event types through the extension API.
+    def record_error_event(message, code: nil, top_up_url: nil, raw_message: nil)
+      data = { message: message, code: code, top_up_url: top_up_url, raw_message: raw_message }.compact
+      @history.append_ext_event({ type: "error", data: data })
+      self
+    end
+
     # Resolve the model name the goal judge should use. Prefer the provider's
     # lite model (cheap/fast for a one-line verdict); fall back to the primary
     # model when no lite is resolvable.
@@ -757,7 +792,7 @@ module Clacky
         @ui&.show_token_usage(response[:token_usage]) if response[:token_usage]
 
         # Act: Execute tool calls
-        action_result = act(response[:tool_calls])
+        action_result = act(response[:tool_calls], assistant_message: response.delete(:history_message))
 
         # Check if ask_user was called
         if action_result[:awaiting_feedback]
@@ -928,6 +963,33 @@ module Clacky
     private def append_user_input(user_input, files: nil, reference_contexts: nil,
                                   display_text: nil, created_at: nil, references_display: nil,
                                   task_id: @current_task_id)
+      # Resolve lightweight metadata first, then commit the accepted user turn
+      # before any attachment parser/OCR/sidecar work can block or fail. Session
+      # switching and graceful shutdown both read from @history, so the turn
+      # must already be authoritative while those slow operations are running.
+      skill_command = parse_skill_command(user_input)
+      skill_command_display = if skill_command[:found] && skill_command[:skill]
+                                skill_command[:skill].display_name(Thread.current[:lang])
+                              end
+      created_at ||= Time.now.to_f
+      message_id = SecureRandom.uuid
+      staged = Array(files).any?
+      staged_display_files = display_files_for(files)
+      message_metadata = {
+        role: "user", message_id: message_id, task_id: task_id, created_at: created_at,
+        display_text: display_text,
+        skill_command: skill_command[:found] ? skill_command[:skill_name] : nil,
+        skill_command_display: skill_command_display,
+        display_references: Array(references_display).empty? ? nil : references_display
+      }
+      if staged
+        @history.append(message_metadata.merge(
+          content: user_input,
+          display_files: staged_display_files.empty? ? nil : staged_display_files
+        ))
+        staged_message_id = message_id
+      end
+
       # Split files into vision images and disk files; downgrade oversized images to disk
       image_files, disk_files = partition_files(Array(files))
       vision_images, downgraded = resolve_vision_images(image_files)
@@ -999,37 +1061,21 @@ module Clacky
       # stored here — they recover from image_url blocks in user_content. Downgraded
       # images (provider has no vision / too large / OCR'd) DO need path here so the
       # UI can re-render them from the on-disk copy across session switches.
-      display_files = all_disk_files.filter_map do |f|
-        # @mention file/directory references are replayed from display_references
-        # (with mention badges), so skip them here to avoid double-rendering as
-        # plain attachment badges.
-        next if f[:reference] || f["reference"]
-        name = f[:name] || f["name"]
-        next unless name
-        { name: name, type: f[:type] || f["type"] || "file",
-          path: f[:path] || f["path"],
-          preview_path: f[:preview_path] || f["preview_path"] }
+      display_files = display_files_for(all_disk_files)
+      resolved_message = message_metadata.merge(
+        content: user_content,
+        display_files: display_files.empty? ? nil : display_files
+      )
+      if staged
+        replaced = @history.replace_user_message(
+          message_id: message_id,
+          message: resolved_message
+        )
+        raise AgentError, "Accepted user message disappeared during attachment processing" unless replaced
+      else
+        @history.append(resolved_message)
       end
 
-      # Resolved once here (not after append) so the user message can carry the
-      # confirmed skill name: only a skill that actually dispatches gets marked,
-      # so the UI never highlights a typo'd or unavailable command. The display
-      # name is resolved against the client's language (Thread.current[:lang],
-      # seeded from the WS message / X-Lang header) so the Web UI and third-party
-      # clients can render a localized label without re-resolving the skill.
-      skill_command = parse_skill_command(user_input)
-      skill_command_display = if skill_command[:found] && skill_command[:skill]
-                                skill_command[:skill].display_name(Thread.current[:lang])
-                              end
-
-      created_at ||= Time.now.to_f
-      @history.append({ role: "user", content: user_content, task_id: task_id, created_at: created_at,
-                        display_text: display_text,
-                        skill_command: skill_command[:found] ? skill_command[:skill_name] : nil,
-                        skill_command_display: skill_command_display,
-                        display_files: display_files.empty? ? nil : display_files,
-                        display_references: Array(references_display).empty? ? nil : references_display })
-
       # Inject disk file references as a system_injected message so:
       #   - LLM sees the file info (system_injected is NOT stripped from to_api)
       #   - replay_history skips it (next if ev[:system_injected]), keeping the user bubble clean
@@ -1144,6 +1190,36 @@ module Clacky
       # skill-declared model not found) still stops the progress spinner.
       inject_skill_command_as_assistant_message(skill_command, task_id)
 
+    rescue Clacky::AgentInterrupted, StandardError
+      # The staged turn exists only to make an accepted upload replayable while
+      # attachment work is in progress. If that work crashes, remove this turn
+      # and anything injected after it so the next request cannot inherit a
+      # half-resolved attachment context. Parser failures returned as FileRef
+      # metadata do not raise and therefore remain visible/actionable.
+      @history.truncate_from_message(staged_message_id) if staged_message_id
+      raise
+    end
+
+    # Build replay-only attachment metadata without parsing file contents.
+    # @mention references render through display_references and must not also
+    # appear as plain attachment badges.
+    private def display_files_for(files)
+      Array(files).filter_map do |file|
+        next if file[:reference] || file["reference"]
+
+        name = file[:name] || file["name"]
+        next unless name
+
+        mime_type = file[:mime_type] || file["mime_type"]
+        type = file[:type] || file["type"]
+        type ||= "image" if mime_type.to_s.start_with?("image/")
+        {
+          name: name,
+          type: type || "file",
+          path: file[:path] || file["path"],
+          preview_path: file[:preview_path] || file["preview_path"]
+        }
+      end
     end
 
     def enqueue_input(content, delivery: :queue, **options)
@@ -1482,7 +1558,7 @@ module Clacky
       # "reasoning_content must be passed back" contract.
       msg[:reasoning_content] = response[:reasoning_content] if response[:reasoning_content]
       check_stale!
-      @history.append(msg)
+      @history.append(msg) { |stored_message| response[:history_message] = stored_message }
 
       # Close the thinking spinner before returning. The caller (run loop)
       # is about to render the assistant message and/or tool invocations,
@@ -1506,7 +1582,7 @@ module Clacky
       raise Clacky::AgentInterrupted, "Task superseded by a newer task on another thread"
     end
 
-    private def act(tool_calls)
+    private def act(tool_calls, assistant_message: nil)
       return { denied: false, feedback: nil, tool_results: [], awaiting_feedback: false } unless tool_calls
 
       denied = false
@@ -1687,20 +1763,21 @@ module Clacky
           # result path so the model sees the error and can retry.
           if Tools::AskUser.feedback_tool?(call[:name]) &&
               result.is_a?(Hash) && result[:awaiting_feedback]
-            # Pass the raw call arguments to show_tool_call so the WebUI controller
-            # can extract the questions and emit a "request_feedback" event
-            # (renders as a clickable card in the browser).
-            # Fallback UIs (terminal, IM channels) receive the formatted text message.
-            @ui&.show_tool_call(call[:name], call[:arguments])
+            # Prepare and persist the complete request before displaying it or
+            # starting the wait. Extensions and native questions share one result.
+            request = prepare_feedback_request(call, result, assistant_message: assistant_message)
+            @ui&.show_tool_call(call[:name], request)
 
             if @config.permission_mode == :auto_approve
               # auto_approve means the agent runs unattended by default, but a
               # human MAY be watching the terminal. Show a short interactive
               # countdown: if the user steps in, hand control over and wait for
               # their answer; otherwise auto-decide and keep going.
-              countdown = @ui&.request_feedback_with_countdown(seconds: 10)
+              countdown = @ui&.request_feedback_with_countdown(seconds: @config.ask_user_timeout_seconds)
 
-              if @ui.nil? || countdown == :timeout
+              if countdown == :timeout && @config.permission_mode != :auto_approve
+                awaiting_feedback = true
+              elsif @ui.nil? || countdown == :timeout
                 result = result.merge(
                   auto_reply: "No user is available. Please make a reasonable decision based on the context and continue."
                 )
@@ -2038,8 +2115,11 @@ module Clacky
       @tool_registry.register(Tools::Edit.new)
       @tool_registry.register(Tools::Glob.new)
       @tool_registry.register(Tools::Grep.new)
-      @tool_registry.register(Tools::WebSearch.new)
-      @tool_registry.register(Tools::WebFetch.new)
+      [Tools::WebSearch, Tools::WebFetch].each do |klass|
+        tool = klass.new
+        tool.agent = self
+        @tool_registry.register(tool)
+      end
       @tool_registry.register(Tools::TodoManager.new)
       @tool_registry.register(Tools::AskUser.new)
       @tool_registry.register(Tools::InvokeSkill.new)

data/lib/clacky/agent_config.rb

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

data/lib/clacky/billing/platform_billing.rb

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

data/lib/clacky/brand_config.rb

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

data/lib/clacky/cli.rb

@@ -346,8 +346,9 @@ module Clacky
       end
 
       # Handle the `/think` slash command — pick the reasoning effort level
-      # for the current session. "off" normalizes to nil (provider default),
-      # matching the Web UI's reasoning_effort switcher semantics.
+      # for the current session. "off" is kept as an explicit choice so model
+      # adapters can resolve it per family (MiniMax Flash and GLM-5.3 turn it
+      # into their lightest effort instead of the provider's deepest default).
       private def handle_think_command(ui_controller, agent, session_manager = nil)
         choice = ui_controller.show_reasoning_effort_menu(agent.reasoning_effort)
         return if choice.nil?
@@ -481,8 +482,8 @@ module Clacky
       private def auto_name_session(agent, input)
         return unless agent.history.empty?
 
-        auto_name = input.to_s.gsub(/\s+/, " ").strip[0, 30]
-        auto_name += "…" if input.to_s.strip.length > 30
+        auto_name = input.to_s.gsub(/\s+/, " ").strip[0, 80]
+        auto_name += "…" if input.to_s.strip.length > 80
         agent.rename(auto_name)
       end
 

data/lib/clacky/client.rb

@@ -56,6 +56,13 @@ module Clacky
       @read_timeout = read_timeout
     end
 
+    # Console URL where the user can inspect credit / API key state. nil when
+    # the provider has no preset (custom base_url).
+    def account_url
+      preset = Providers.get(@provider_id)
+      preset && preset["website_url"]
+    end
+
     # Returns true when the client is using the AWS Bedrock Converse API.
     def bedrock?
       @use_bedrock
@@ -122,7 +129,7 @@ module Clacky
         response = bedrock_connection.post(bedrock_endpoint(api_model)) { |r| r.body = body.to_json }
         parse_simple_bedrock_response(response)
       elsif anthropic_format?
-        body     = MessageFormat::Anthropic.build_request_body(messages, api_model, [], max_tokens, false)
+        body     = MessageFormat::Anthropic.build_request_body(messages, api_model, [], max_tokens, false, reasoning_effort: reasoning_effort)
         response = anthropic_connection.post(anthropic_messages_path) { |r| r.body = body.to_json }
         parse_simple_anthropic_response(response)
       elsif responses_format?
@@ -349,10 +356,10 @@ module Clacky
       end
 
       unless response.status == 200
-        recovered_body = response.body.to_s
-        recovered_body = sse_buf.to_s if recovered_body.empty?
-        recovered = Struct.new(:status, :body).new(response.status, recovered_body)
-        raise_error(recovered)
+        # Recover the streamed error body on the original response so headers
+        # remain available to error classification and routed-tier attribution.
+        response.env.body = sse_buf if response.body.to_s.empty?
+        raise_error(response)
       end
 
       result = aggregator.to_h