openclacky 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29e2af05d27f902fc645a1399eb16d16d41681ec03312ee861fdd594292368c2
-  data.tar.gz: bbb62ec065f07867a2085b6dc0f81d5702c34cf0ff4e10e0b88513daa5fb4541
+  metadata.gz: 85707cf41b28f7283581fde4a77cbdf136ac525d9671743c13cfe268cf71c230
+  data.tar.gz: f2ccf13cf87f8aeb4e9ac2a27a7f7d3f1c8be53f196d52b39d412ae54bbd791a
 SHA512:
-  metadata.gz: bf7f4ad60821686404ee3b43607e59c51cb0d38420171b94eaea2c6d2877d71c03052f9147b56f61aeb5fc01155127d4aab15a8f0b6ecc0b73d6b294fb0bbe3c
-  data.tar.gz: ba3a05a10e80fd8b48f10f0778388c5417ce8fa79e0f3936cb6ef734117609bc85f56868227e174675e4132d0c619a8b385619c7aaf62e75039fc3f4895d15f8
+  metadata.gz: 33a52baaf3983e25e121d6e5200424d57b20d50af5226168df47b730e202add9ab296ecf9d480dc1380302d95b24273ad399b808290954875a139748c4879de8
+  data.tar.gz: c06c55d0765c8f657606dae02f214aeb938dc484522af5698bcd408b34379160e2bd850a9abdc91a82d4bf3f9925a20b698c3973a35839bb8886170f10d4215d

data/CHANGELOG.md

@@ -4,6 +4,61 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
+## [1.5.0] - 2026-07-23
+
+### Added
+- Volcengine Ark (Doubao) provider with endpoint-aware model-id mapping
+- Brand tab in extension marketplace for brand-private extensions
+- Auto-install all brand skills on license activation
+- Multi-background theme support with refactored theme engine
+- Short hash suffix in session-info-bar session file label with tooltips
+- Guide ext-develop skill to the host-API reference
+
+### Improved
+- Ext-developer skill prompt updated with engineering discipline guidelines
+- ext-develop skill merged into a single consolidated guide
+- Brand status fetch moved from view layer to store (cleaner architecture)
+- README check prompted before publishing extension
+- MCP page copy updated (removed Clacky brand name)
+- Floating window border effect added to content area
+
+### Fixed
+- CRLF normalization in SSE chunks for servers sending `\r\n\r\n` event separators
+- Subagent tool-item completion with DOM fallback when element not yet in DOM
+- AgentError now carries raw_message for LLM network/timeout errors
+- Extension data persisted outside package dir (C-5729)
+- Idle compression worker shutdown before process exit
+- Install button shown for all extension origins when download_url is present
+
+## [1.4.1] - 2026-07-20
+
+### Added
+- Extension README edit/validate flow and screenshot upload in ext-studio publish
+- Kimi k3 and k2.7-code models added to Kimi preset
+- New session split-button with improved styling
+- Rename-on-name-conflict flow in ext-studio publish
+- Skip OpenClacky AI Keys card for branded onboarding
+
+### Improved
+- Secondary API host added with reduced failover latency
+- Extensions default sort changed to most-installed (downloads first)
+
+### Fixed
+- WSL file panel "Copy Path" now copies Windows-accessible UNC path via `wslpath` (C-5693)
+- Edit button hidden on compressed user messages archived to chunk (C-5723)
+- Message-edit Enter key blocked during IME composition (C-5742)
+- Markdown images with `file://~/` tilde paths now render correctly (C-5747)
+- Local `file://` path resolution unified for Windows drive letters (C-5746, C-5708)
+- Brand extension installs under its real ID, not as unpacked (C-5735)
+- Backup success status no longer stays displayed forever (C-5711)
+- `grep` tool defaults to recursive behavior
+- `display_name` fields included in installed extensions API response
+- Published list reloads after setup entry point and publish
+- Unpublish button size matches iterate button in ext-studio
+- `device_token` correctly passed in screenshot upload multipart fields
+- MCP tool list rendering fixed and display styling improved
+- Uninstall script now removes all openclacky gem versions
+
 ## [1.4.0] - 2026-07-14
 
 ### Added

data/lib/clacky/agent/llm_caller.rb

@@ -201,7 +201,7 @@ module Clacky
             sleep retry_delay
             retry
           else
-            raise AgentError, "[LLM] #{I18n.t("llm.error.request_timeout", retries: max_retries)}"
+            raise AgentError.new("[LLM] #{I18n.t("llm.error.request_timeout", retries: max_retries)}", raw_message: e.message)
           end
 
         rescue Faraday::ConnectionFailed, Faraday::SSLError, Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::EPIPE => e
@@ -236,7 +236,7 @@ module Clacky
           else
             # Don't show_error here — let the outer rescue block handle it to avoid duplicates.
             # Progress cleanup is the caller's responsibility (via its own ensure block).
-            raise AgentError, "[LLM] #{I18n.t("llm.error.network_failed", retries: max_retries)}"
+            raise AgentError.new("[LLM] #{I18n.t("llm.error.network_failed", retries: max_retries)}", raw_message: e.message)
           end
 
         rescue RetryableError => e
@@ -274,7 +274,7 @@ module Clacky
         else
           # Don't show_error here — let the outer rescue block handle it to avoid duplicates.
           # Progress cleanup is the caller's responsibility (via its own ensure block).
-          raise AgentError, "[LLM] #{I18n.t("llm.error.service_unavailable", retries: current_max)}"
+          raise AgentError.new("[LLM] #{I18n.t("llm.error.service_unavailable", retries: current_max)}", raw_message: e.message)
         end
 
         rescue Clacky::BadRequestError => e

data/lib/clacky/agent/session_serializer.rb

@@ -68,6 +68,7 @@ module Clacky
           }
         end
         backfill_task_meta_from_history!
+        heal_missing_chunk_paths!
 
         # Check if the session ended with an error.
         # We record the rollback intent here but do NOT truncate history immediately —
@@ -143,6 +144,31 @@ module Clacky
         end
       end
 
+      # Repair compressed_summary messages whose chunk_path is missing or points
+      # at a file that no longer exists. This happens when a hot restart's
+      # SIGKILL killed the worker after the chunk file was written to disk but
+      # before its path was persisted into session.json — the archived history
+      # then never renders on replay. Rediscover the chunk on disk from
+      # session_id + created_at and write the real path back, once, at load time.
+      private def heal_missing_chunk_paths!
+        return unless @session_id && @created_at
+
+        broken = @history.to_a.select do |m|
+          m[:compressed_summary] && !(m[:chunk_path] && File.exist?(m[:chunk_path].to_s))
+        end
+        return if broken.empty?
+
+        chunks = session_manager.chunks_for_current(@session_id, @created_at)
+        return if chunks.empty?
+
+        latest_path = chunks.last[:path]
+        broken.each { |m| m[:chunk_path] = latest_path }
+
+        session_manager.save(to_session_data(preserve_updated_at: true))
+      rescue => e
+        Clacky::Logger.warn("heal_missing_chunk_paths! failed: #{e.message}")
+      end
+
       private def persisted_card_field(key)
         card_id = @config.current_model_id
         return nil unless card_id
@@ -257,12 +283,14 @@ module Clacky
             end
 
           if is_real_user_msg
-            # Start a new round at each real user message
-            current_round = { user_msg: msg, events: [] }
+            # Start a new round at each real user message.
+            # editable: true — this message still lives in the active in-memory
+            # @history, so truncate_from_created_at can locate and truncate it.
+            current_round = { user_msg: msg, events: [], editable: true }
             rounds << current_round
           elsif current_round
             current_round[:events] << msg
-          elsif msg[:compressed_summary] && msg[:chunk_path]
+          elsif msg[:compressed_summary]
             # Compressed summary sitting before any user rounds — expand ALL chunk
             # MD files that belong to the same session (siblings of chunk_path),
             # in chunk-index ascending order.
@@ -272,15 +300,23 @@ module Clacky
             # points at the newest chunk). Older chunks (chunk-1..chunk-N-1) are
             # referenced only as basenames inside the summary text. Expanding just
             # msg[:chunk_path] would therefore lose all prior chunks on replay.
-            chunk_rounds = sibling_chunks_of(msg[:chunk_path]).flat_map { |p|
-              parse_chunk_md_to_rounds(p)
-            }
+            #
+            # chunk_path may be blank when a hot restart's SIGKILL killed the
+            # worker after the chunk file was written but before its path was
+            # persisted into session.json. Fall back to discovering the chunks
+            # on disk from session_id + created_at so the history is not lost.
+            chunk_paths = if msg[:chunk_path].to_s.empty?
+              session_manager.chunks_for_current(@session_id, @created_at).map { |c| c[:path] }
+            else
+              sibling_chunks_of(msg[:chunk_path])
+            end
+            chunk_rounds = chunk_paths.flat_map { |p| parse_chunk_md_to_rounds(p) }
             rounds.concat(chunk_rounds)
             # After expanding, treat the last chunk round as the current round so that
             # any orphaned assistant/tool messages that follow in session.json (belonging
             # to the same task whose user message was compressed into the chunk) get
             # appended here instead of being silently discarded.
-            current_round = rounds.last
+            current_round = rounds.last unless chunk_rounds.empty?
           elsif rounds.last
             # Orphaned non-user message with no current_round yet (e.g. recent_messages
             # after compression started mid-task with no leading user message).
@@ -325,7 +361,8 @@ module Clacky
               preview_path: f[:preview_path] || f["preview_path"] }
           }
           all_files = image_files + disk_files
-          ui.show_user_message(raw_text, created_at: msg[:created_at], files: all_files)
+          ui.show_user_message(raw_text, created_at: msg[:created_at], files: all_files,
+                               editable: round[:editable] != false)
 
           round[:events].each do |ev|
             # Skip system-injected messages (e.g. synthetic skill content, memory prompts)
@@ -480,7 +517,11 @@ module Clacky
                 created_at: synthetic_ts,
                 _from_chunk: true
               },
-              events: []
+              events: [],
+              # editable: false — this message was archived into a chunk MD and no
+              # longer exists in the active in-memory @history, so it cannot be
+              # truncated/edited (truncate_from_created_at would silently no-op).
+              editable: false
             }
             rounds << current_round
           elsif current_round

data/lib/clacky/agent.rb

@@ -1862,11 +1862,10 @@ module Clacky
       files = []
       content.scan(/(!?)\[([^\]]*)\]\(file:\/\/([^)]+)\)/) do
         inline = $1 == "!"
-        # URL-decode percent-encoded characters (e.g. Chinese filenames encoded by AI)
-        raw_path = CGI.unescape($3)
-        name   = File.basename(raw_path)
-        path   = File.expand_path(raw_path)
-        Clacky::Logger.info("[parse_file_links] raw=#{$3.inspect} expanded=#{path.inspect} exist=#{File.exist?(path)}")
+        # Resolve the AI-emitted path: decode, WSL drive-letter normalize, expand.
+        path   = Clacky::Utils::EnvironmentDetector.resolve_local_path($3)
+        name   = File.basename(path)
+        Clacky::Logger.info("[parse_file_links] raw=#{$3.inspect} resolved=#{path.inspect} exist=#{File.exist?(path)}")
         files << { name: name, path: path, inline: inline }
       end
       { text: content, files: files }

data/lib/clacky/brand_config.rb

@@ -622,7 +622,7 @@ module Clacky
     #
     # Returns { success: true, extension: {...} } or
     #         { success: false, error: "...", already_exists: Boolean }.
-    def upload_extension!(ext_id, zip_data, force: false, status: nil, changelog: nil, origin: 'marketplace')
+    def upload_extension!(ext_id, zip_data, force: false, status: nil, changelog: nil, readme: nil, origin: 'marketplace')
       identity = Clacky::Identity.load
       return { success: false, error: "Device not bound to a platform account" } unless identity.bound?
 
@@ -636,6 +636,7 @@ module Clacky
       fields["origin"]    = origin.to_s      if origin
       fields["status"]    = status.to_s    if status
       fields["changelog"] = changelog.to_s if changelog
+      fields["readme"]    = readme.to_s    if readme
 
       body_bytes, boundary = build_multipart(fields, "extension_zip", "#{ext_id}.zip", zip_data)
 
@@ -700,6 +701,55 @@ module Clacky
       end
     end
 
+    # Update an extension's readme text without publishing a new version.
+    # Uses PATCH /api/v1/client/extensions/:id.
+    # Returns { success:, extension:, error: }
+    def update_extension_readme!(ext_id, readme)
+      identity = Clacky::Identity.load
+      return { success: false, error: "Device not bound to a platform account" } unless identity.bound?
+
+      path    = "/api/v1/client/extensions/#{URI.encode_www_form_component(ext_id)}"
+      payload = { "device_token" => identity.device_token, "readme" => readme.to_s }
+      result  = platform_client.patch(path, payload)
+
+      if result[:success]
+        { success: true, extension: result[:data]["extension"] }
+      else
+        body = result[:data] || {}
+        { success: false, error: result[:error] || body["code"] || "Update readme failed" }
+      end
+    rescue StandardError => e
+      { success: false, error: "Network error: #{e.message}" }
+    end
+
+    # Upload any file to the platform's model-agnostic upload endpoint.
+    # Returns an orphan blob URL — no extension record required.
+    # Uses POST /api/v1/client/uploads.
+    # Parameters:
+    #   data         (bytes)  - raw file bytes
+    #   filename     (string) - filename including extension
+    #   content_type (string) - MIME type
+    # Returns { success:, url:, filename:, blob_key:, error: }
+    def upload_file!(data, filename:, content_type: "image/png")
+      identity = Clacky::Identity.load
+      return { success: false, error: "Device not bound to a platform account" } unless identity.bound?
+
+      path   = "/api/v1/client/uploads"
+      fields = { "device_token" => identity.device_token }
+      body_bytes, boundary = build_multipart(fields, "file", filename, data, content_type: content_type)
+      result = platform_client.multipart_post(path, body_bytes, boundary, read_timeout: 60)
+
+      if result[:success]
+        d = result[:data] || {}
+        { success: true, url: d["url"], filename: d["filename"], blob_key: d["blob_key"] }
+      else
+        body = result[:data] || {}
+        { success: false, error: result[:error] || body["code"] || "File upload failed" }
+      end
+    rescue StandardError => e
+      { success: false, error: "Network error: #{e.message}" }
+    end
+
     # Search the public extension marketplace. Anonymous — no license required.
     # Uses GET /api/v1/extensions. Returns { success:, extensions: [], error: }.
     def search_extensions!(query: nil, sort: nil)
@@ -732,6 +782,41 @@ module Clacky
     rescue StandardError => e
       { success: false, error: "Network error: #{e.message}" }
     end
+
+    # Fetch detail for a single brand-private extension via the license-gated
+    # POST /api/v1/licenses/extension_detail endpoint.
+    # The public /api/v1/extensions/:id intentionally omits origin=self extensions,
+    # so activated brand users must use this signed request instead.
+    # Returns { success:, extension:, error: }.
+    def brand_extension_detail!(id)
+      return { success: false, error: "License not activated" } unless activated?
+
+      user_id   = parse_user_id_from_key(@license_key)
+      ts        = Time.now.utc.to_i.to_s
+      nonce     = SecureRandom.hex(16)
+      message   = "#{user_id}:#{@device_id}:#{ts}:#{nonce}"
+
+      payload = {
+        key_hash:  Digest::SHA256.hexdigest(@license_key),
+        user_id:   user_id.to_s,
+        device_id: @device_id,
+        timestamp: ts,
+        nonce:     nonce,
+        signature: OpenSSL::HMAC.hexdigest("SHA256", @license_key, message),
+        id:        id.to_s
+      }
+
+      response = api_post("/api/v1/licenses/extension", payload)
+
+      if response[:success]
+        { success: true, extension: response[:data]["extension"] }
+      else
+        { success: false, error: response[:error] || "Extension not found" }
+      end
+    rescue StandardError => e
+      { success: false, error: "Network error: #{e.message}" }
+    end
+
     # Extensions bundled into the activated license's distribution are free and
     # unencrypted. They are fetched over the same license-HMAC scheme as brand
     # skills and installed into the ExtensionLoader `installed` layer.
@@ -1163,7 +1248,10 @@ module Clacky
     # @param on_complete [Proc, nil] Optional callback called with the sync
     #   results array once all downloads finish (useful for tests / UI feedback).
     # @return [Thread, nil] The background thread, or nil if skipped.
-    def sync_brand_skills_async!(on_complete: nil)
+    # install_new: when true, install ALL remote skills regardless of whether they
+    # were previously installed. Used on first activation so every brand skill is
+    # available immediately without the user clicking Install one-by-one.
+    def sync_brand_skills_async!(on_complete: nil, install_new: false)
       return nil unless activated?
       return nil if ENV["CLACKY_TEST"] == "1"
 
@@ -1182,13 +1270,17 @@ module Clacky
             delete_brand_skill!(local_name) unless remote_skill_names.include?(local_name)
           end
 
-          # Auto-sync is intentionally limited to skills the user has already
-          # installed and that have a newer version available.
-          # New skills are never auto-installed — the user must click Install/Update
-          # explicitly from the Brand Skills panel.
+          # When install_new is true (e.g. on first activation) install every
+          # remote skill. Otherwise limit auto-sync to skills already installed
+          # locally that have a newer version available — new skills must be
+          # installed explicitly by the user from the Brand Skills panel.
           installed = installed_brand_skills
-          skills_needing_update = result[:skills].select { |s| s["needs_update"] }
-          results = skills_needing_update.map do |skill_info|
+          skills_to_install = if install_new
+                                result[:skills].select { |s| s["needs_update"] || !installed.key?(s["name"]) }
+                              else
+                                result[:skills].select { |s| s["needs_update"] }
+                              end
+          results = skills_to_install.map do |skill_info|
             install_brand_skill!(skill_info)
           end
 
@@ -1579,7 +1671,7 @@ module Clacky
 
     # Assemble a binary multipart/form-data body: text fields + one file part.
     # Kept binary-safe so null bytes in the ZIP survive. Returns [body, boundary].
-    private def build_multipart(fields, file_field, filename, file_bytes)
+    private def build_multipart(fields, file_field, filename, file_bytes, content_type: "application/zip")
       boundary = "----ClackyMultipart#{SecureRandom.hex(8)}"
       crlf     = "\r\n"
       parts    = []
@@ -1591,7 +1683,7 @@ module Clacky
       end
       parts << "--#{boundary}#{crlf}"
       parts << "Content-Disposition: form-data; name=\"#{file_field}\"; filename=\"#{filename}\"#{crlf}"
-      parts << "Content-Type: application/zip#{crlf}#{crlf}"
+      parts << "Content-Type: #{content_type}#{crlf}#{crlf}"
       parts << file_bytes.b
       parts << "#{crlf}--#{boundary}--#{crlf}"
       [parts.map(&:b).join, boundary]

data/lib/clacky/client.rb

@@ -55,17 +55,18 @@ module Clacky
     # Test API connection by sending a minimal request.
     # Returns { success: true } or { success: false, error: "..." }.
     def test_connection(model:)
+      api_model = Providers.resolve_api_model(base_url: @base_url, api_key: @api_key, model: model)
       if bedrock?
         body = MessageFormat::Bedrock.build_request_body(
-          [{ role: :user, content: "hi" }], model, [], 16
+          [{ role: :user, content: "hi" }], api_model, [], 16
         ).to_json
-        response = bedrock_connection.post(bedrock_endpoint(model)) { |r| r.body = body }
+        response = bedrock_connection.post(bedrock_endpoint(api_model)) { |r| r.body = body }
       elsif anthropic_format?
-        minimal_body = { model: model, max_tokens: 16,
+        minimal_body = { model: api_model, max_tokens: 16,
                          messages: [{ role: "user", content: "hi" }] }.to_json
         response = anthropic_connection.post(anthropic_messages_path) { |r| r.body = minimal_body }
       else
-        minimal_body = { model: model, max_tokens: 16,
+        minimal_body = { model: api_model, max_tokens: 16,
                          messages: [{ role: "user", content: "hi" }] }.to_json
         response = openai_connection.post("chat/completions") { |r| r.body = minimal_body }
       end
@@ -87,16 +88,17 @@ module Clacky
 
     # Send a messages array and return the reply text.
     def send_messages(messages, model:, max_tokens:)
+      api_model = Providers.resolve_api_model(base_url: @base_url, api_key: @api_key, model: model)
       if bedrock?
-        body     = MessageFormat::Bedrock.build_request_body(messages, model, [], max_tokens)
-        response = bedrock_connection.post(bedrock_endpoint(model)) { |r| r.body = body.to_json }
+        body     = MessageFormat::Bedrock.build_request_body(messages, api_model, [], max_tokens)
+        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, model, [], max_tokens, false)
+        body     = MessageFormat::Anthropic.build_request_body(messages, api_model, [], max_tokens, false)
         response = anthropic_connection.post(anthropic_messages_path) { |r| r.body = body.to_json }
         parse_simple_anthropic_response(response)
       else
-        body     = { model: model, max_tokens: max_tokens, messages: messages }
+        body     = { model: api_model, max_tokens: max_tokens, messages: messages }
         response = openai_connection.post("chat/completions") { |r| r.body = body.to_json }
         parse_simple_openai_response(response)
       end
@@ -127,6 +129,7 @@ module Clacky
     #   a single synthetic invocation is fired after the response is received,
     #   so UI plumbing can be exercised end-to-end without the proxy work.
     def send_messages_with_tools(messages, model:, tools:, max_tokens:, enable_caching: false, reasoning_effort: nil, on_chunk: nil)
+      api_model = Providers.resolve_api_model(base_url: @base_url, api_key: @api_key, model: model)
       caching_enabled = enable_caching && supports_prompt_caching?(model)
       cloned = deep_clone(messages)
 
@@ -141,13 +144,13 @@ module Clacky
       response =
         if bedrock?
           streaming_used = !on_chunk.nil?
-          send_bedrock_request(cloned, model, tools, max_tokens, caching_enabled, reasoning_effort: reasoning_effort, on_chunk: wrapped_on_chunk)
+          send_bedrock_request(cloned, api_model, tools, max_tokens, caching_enabled, reasoning_effort: reasoning_effort, on_chunk: wrapped_on_chunk)
         elsif anthropic_format?
           streaming_used = !on_chunk.nil?
-          send_anthropic_request(cloned, model, tools, max_tokens, caching_enabled, reasoning_effort: reasoning_effort, on_chunk: wrapped_on_chunk)
+          send_anthropic_request(cloned, api_model, tools, max_tokens, caching_enabled, reasoning_effort: reasoning_effort, on_chunk: wrapped_on_chunk)
         else
           streaming_used = !on_chunk.nil?
-          send_openai_request(cloned, model, tools, max_tokens, caching_enabled, reasoning_effort: reasoning_effort, on_chunk: wrapped_on_chunk)
+          send_openai_request(cloned, api_model, tools, max_tokens, caching_enabled, reasoning_effort: reasoning_effort, on_chunk: wrapped_on_chunk, capability_model: model)
         end
       t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
@@ -333,17 +336,20 @@ module Clacky
 
     # ── OpenAI request / response ─────────────────────────────────────────────
 
-    def send_openai_request(messages, model, tools, max_tokens, caching_enabled, reasoning_effort: nil, on_chunk: nil)
+    def send_openai_request(messages, model, tools, max_tokens, caching_enabled, reasoning_effort: nil, on_chunk: nil, capability_model: nil)
       # Apply cache_control markers to messages when caching is enabled.
       # OpenRouter proxies Claude with the same cache_control field convention as Anthropic direct.
       messages = apply_message_caching(messages) if caching_enabled
 
-      # Vision support is resolved against the request's actual model (which may
-      # differ from @model after a runtime switch or fallback override), so the
-      # conversion layer strips image_url blocks for non-vision models.
+      # Vision support is resolved against the display model name, which is the
+      # key our capability table is declared with. `model` may be an
+      # endpoint-specific API id (e.g. Ark payg's "glm-5-2-260617") that the
+      # table can't match — so the caller passes the display name separately
+      # via capability_model to keep the vision judgement accurate.
+      cap_model = capability_model || model
       body = MessageFormat::OpenAI.build_request_body(
         messages, model, tools, max_tokens, caching_enabled,
-        vision_supported: Providers.supports?(@provider_id, :vision, model_name: model),
+        vision_supported: Providers.supports?(@provider_id, :vision, model_name: cap_model),
         reasoning_effort: reasoning_effort
       )
       return send_openai_stream_request(body, on_chunk) if on_chunk