openclacky 1.2.8 → 1.2.10

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

@@ -300,12 +300,31 @@ module Clacky
               return { message_id: nil }
             end
 
+            text = sanitize_for_weixin(text)
             return { message_id: nil } if text.strip.empty?
 
             @send_queue.enqueue(chat_id, text, ctoken)
             { message_id: nil }
           end
 
+          private def sanitize_for_weixin(text)
+            s = text.to_s
+            s = s.gsub(/^[ \t]{0,3}>[ \t]?/, "")
+            s = s.gsub(/\*\*([^\n*][^*]*?)\*\*/m) { Regexp.last_match(1) }
+            s = s.gsub(/`([^`\n]+)`/) { Regexp.last_match(1) }
+            s = s.gsub(/^[ \t]{0,3}\#{1,6}[ \t]+/, "")
+            s
+          end
+
+          private def sanitize_file_name_for_weixin(name)
+            ext = File.extname(name.to_s)
+            stem = File.basename(name.to_s, ext)
+            stem = stem.tr("&<>\"'\/", "_")
+            stem = stem.gsub(/[\x00-\x1f]/, "_").strip
+            stem = "file" if stem.empty?
+            "#{stem}#{ext}"
+          end
+
           # Force-flush pending text for a chat_id. Called before sending files or on task completion.
           def flush_pending(chat_id)
             @send_queue.flush(chat_id)
@@ -321,17 +340,20 @@ module Clacky
               return { message_id: nil }
             end
 
+            display_name = name || File.basename(file_path)
+            safe_name = sanitize_file_name_for_weixin(display_name)
+
             @send_queue.flush(chat_id)
 
             @api_client.send_file(
               to_user_id:    chat_id,
               file_path:     file_path,
-              file_name:     name || File.basename(file_path),
+              file_name:     safe_name,
               context_token: ctoken
             )
             { message_id: nil }
           rescue => e
-            Clacky::Logger.error("[WeixinAdapter] send_file failed for #{chat_id}: #{e.message}")
+            Clacky::Logger.error("[WeixinAdapter] send_file failed for #{chat_id}: #{e.class}: #{e.message}")
             { message_id: nil }
           end
 

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

@@ -58,6 +58,9 @@ module Clacky
 
         Clacky::Logger.info("[ChannelManager] Starting channels: #{enabled_platforms.join(", ")}")
         @running = true
+
+        restore_channel_bindings
+
         enabled_platforms.each { |platform| start_adapter(platform) }
       end
 
@@ -240,7 +243,11 @@ module Clacky
         end
 
         session_id = resolve_session(event)
-        session_id = auto_create_session(adapter, event) unless session_id
+        if session_id
+          bind_key_to_session(channel_key(event), session_id)
+        else
+          session_id = auto_create_session(adapter, event)
+        end
 
         session = @registry.get(session_id)
         unless session
@@ -263,8 +270,13 @@ module Clacky
         agent  = session[:agent]
         web_ui = session[:ui]
 
+        # Set channel info on the agent so session context includes platform/sender.
+        agent.channel_info = extract_channel_info(event) if agent.respond_to?(:channel_info=)
+
+        # Re-attach channel UI if it was dropped (session was evicted from memory and rebuilt by ensure).
+        ensure_channel_ui_subscribed(session_id, event)
+
         # Update reply context so responses thread under the current message.
-        # channel_ui is bound to the session for its full lifetime (created in auto_create_session).
         channel_ui_for_session(session_id)&.update_message_context(event)
 
         # Sync the inbound message to WebUI so it shows up in the browser session.
@@ -499,6 +511,16 @@ module Clacky
           found = nil
           @registry.with_session(summary[:id]) { |s| found = s[:channel_keys]&.include?(key) }
           return summary[:id] if found
+
+          # Check evicted channel sessions via persisted channel_info
+          next unless summary[:source] == "channel"
+          next unless @registry.ensure(summary[:id])
+          agent = nil
+          @registry.with_session(summary[:id]) { |s| agent = s[:agent] }
+          next unless agent&.channel_info
+          next unless channel_key_from_info(agent.channel_info) == key
+          bind_key_to_session(key, summary[:id])
+          return summary[:id]
         end
         nil
       rescue StandardError => e
@@ -534,6 +556,24 @@ module Clacky
         result
       end
 
+      # Make sure session has a ChannelUIController subscribed to its WebUIController.
+      # Needed both at startup (for restored sessions) and after a session is evicted
+      # from memory and rebuilt by SessionRegistry#ensure (which drops :ui/:channel_ui).
+      def ensure_channel_ui_subscribed(session_id, event)
+        needs_attach = false
+        @registry.with_session(session_id) do |s|
+          needs_attach = s[:ui] && s[:channel_ui].nil?
+        end
+        return unless needs_attach
+
+        channel_ui = ChannelUIController.new(event, -> { adapter_for(event[:platform]) })
+        @registry.with_session(session_id) do |s|
+          next unless s[:ui] && s[:channel_ui].nil?
+          s[:ui].subscribe_channel(channel_ui)
+          s[:channel_ui] = channel_ui
+        end
+      end
+
       def web_ui_for_session_diag(session_id)
         result = nil
         @registry.with_session(session_id) do |s|
@@ -581,6 +621,27 @@ module Clacky
         end
       end
 
+      def channel_key_from_info(channel_info)
+        platform = channel_info[:platform].to_s
+        chat_id  = channel_info[:chat_id].to_s
+        user_id  = channel_info[:user_id].to_s
+        case @binding_mode
+        when :chat      then "#{platform}:chat:#{chat_id}"
+        when :user      then "#{platform}:user:#{user_id}"
+        else # :chat_user (default)
+          "#{platform}:chat:#{chat_id}:user:#{user_id}"
+        end
+      end
+
+      private def extract_channel_info(event)
+        {
+          platform:  event[:platform],
+          user_id:   event[:user_id],
+          user_name: event[:user_name],
+          chat_id:   event[:chat_id]
+        }
+      end
+
       # Extract the chat_id from the remainder of a channel_key (after removing "platform:" prefix).
       #
       # Possible formats:
@@ -604,6 +665,32 @@ module Clacky
         end
       end
 
+      def restore_channel_bindings
+        bound_keys = Set.new
+        restored_count = 0
+        @registry.list(limit: nil).each do |summary|
+          @registry.ensure(summary[:id])
+          agent = nil
+          @registry.with_session(summary[:id]) { |s| agent = s[:agent] }
+          next unless agent&.channel_info
+
+          info = agent.channel_info
+          next unless info[:platform] && info[:user_id] && info[:chat_id]
+
+          key = channel_key_from_info(info)
+
+          event = { platform: info[:platform], chat_id: info[:chat_id] }
+          ensure_channel_ui_subscribed(summary[:id], event)
+
+          next unless bound_keys.add?(key)
+          bind_key_to_session(key, summary[:id])
+
+          Clacky::Logger.info("[ChannelManager] Restored channel binding #{key} -> session #{summary[:id][0, 8]}")
+          restored_count += 1
+        end
+        Clacky::Logger.info("[ChannelManager] Restored #{restored_count} channel binding(s)") if restored_count > 0
+      end
+
       def safe_stop_adapter(adapter)
         adapter.stop
       rescue StandardError => e

data/lib/clacky/server/http_server.rb

@@ -4,6 +4,7 @@ require "webrick"
 require "websocket"
 require "socket"
 require "json"
+require "net/http"
 require "thread"
 require "fileutils"
 require "tmpdir"
@@ -107,6 +108,8 @@ module Clacky
     #   GET  /**                     → static files served from lib/clacky/web/ directory
     class HttpServer
       WEB_ROOT = File.expand_path("../web", __dir__)
+      EXCHANGE_RATE_PRIMARY_BASE_URL = "https://open.er-api.com/v6/latest"
+      EXCHANGE_RATE_FALLBACK_URL = "https://api.frankfurter.app/latest"
 
       # Default SOUL.md written when the user skips the onboard conversation.
       # A richer version is created by the Agent during the soul_setup phase.
@@ -368,8 +371,15 @@ module Clacky
           90
         elsif path == "/api/tool/browser"
           30
+        elsif path == "/api/exchange-rate"
+          20
         elsif path.end_with?("/benchmark")
           20
+        elsif path == "/api/media/image"
+          # Image generation routes through OpenRouter (chat completions
+          # with modalities:["image"]); end-to-end latency is commonly
+          # 20-60s and can exceed 2 minutes for or-gpt-image-2 under load.
+          300
         else
           10
         end
@@ -396,9 +406,11 @@ module Clacky
         when ["GET",    "/api/skills"]         then api_list_skills(res)
         when ["GET",    "/api/config"]        then api_get_config(res)
         when ["GET",    "/api/config/settings"]  then api_get_settings(res)
+        when ["GET",    "/api/exchange-rate"]    then api_exchange_rate(req, res)
         when ["PATCH",  "/api/config/settings"]  then api_update_settings(req, res)
         when ["POST",   "/api/config/models"] then api_add_model(req, res)
         when ["POST",   "/api/config/test"]   then api_test_config(req, res)
+        when ["GET",    "/api/config/media"]  then api_get_media_config(res)
         when ["GET",    "/api/providers"]     then api_list_providers(res)
         when ["GET",    "/api/onboard/status"]    then api_onboard_status(res)
         when ["GET",    "/api/browser/status"]    then api_browser_status(res)
@@ -430,6 +442,8 @@ module Clacky
         when ["POST",   "/api/upload"]            then api_upload_file(req, res)
         when ["POST",   "/api/file-action"]       then api_file_action(req, res)
         when ["GET",    "/api/local-image"]       then api_serve_local_image(req, res)
+        when ["POST",   "/api/media/image"]       then api_media_image(req, res)
+        when ["GET",    "/api/media/types"]       then api_media_types(res)
         when ["GET",    "/api/version"]           then api_get_version(res)
         when ["POST",   "/api/version/upgrade"]   then api_upgrade_version(req, res)
         when ["POST",   "/api/restart"]           then api_restart(req, res)
@@ -523,6 +537,9 @@ module Clacky
           elsif method == "DELETE" && path.match?(%r{^/api/config/models/[^/]+$})
             id = path.sub("/api/config/models/", "")
             api_delete_model(id, res)
+          elsif method == "PATCH" && path.match?(%r{^/api/config/media/(image|video|audio)$})
+            kind = path.sub("/api/config/media/", "")
+            api_update_media_config(kind, req, res)
           elsif method == "POST" && path.match?(%r{^/api/cron-tasks/[^/]+/run$})
             name = URI.decode_www_form_component(path.sub("/api/cron-tasks/", "").sub("/run", ""))
             api_run_cron_task(name, res)
@@ -645,6 +662,103 @@ module Clacky
         end
       end
 
+      # GET /api/exchange-rate?from=USD&to=CNY
+      # Fetches the latest exchange rate on demand. The browser still owns the
+      # saved preference in localStorage; this API is only a lightweight proxy
+      # that avoids CORS issues and normalizes provider responses.
+      def api_exchange_rate(req, res)
+        query = URI.decode_www_form(req.query_string.to_s).to_h
+        from  = normalize_currency_code(query["from"], fallback: "USD")
+        to    = normalize_currency_code(query["to"], fallback: "CNY")
+
+        unless from && to
+          return json_response(res, 400, { error: "from and to must be 3-letter currency codes" })
+        end
+
+        data = fetch_exchange_rate(from, to)
+        json_response(res, 200, data)
+      rescue StandardError => e
+        Clacky::Logger.warn("[ExchangeRate] failed: #{e.class}: #{e.message}")
+        json_response(res, 502, { error: "Failed to fetch exchange rate" })
+      end
+
+      def normalize_currency_code(value, fallback:)
+        code = value.to_s.strip.upcase
+        code = fallback if code.empty?
+        code.match?(/\A[A-Z]{3}\z/) ? code : nil
+      end
+
+      def fetch_exchange_rate(from, to)
+        fetch_open_exchange_rate(from, to)
+      rescue StandardError => primary_error
+        Clacky::Logger.warn("[ExchangeRate] primary source failed: #{primary_error.message}")
+        fetch_frankfurter_exchange_rate(from, to)
+      end
+
+      def fetch_open_exchange_rate(from, to)
+        data = fetch_exchange_rate_json("#{EXCHANGE_RATE_PRIMARY_BASE_URL}/#{URI.encode_www_form_component(from)}")
+        raise "open.er-api.com returned #{data["result"] || "unknown"}" unless data["result"] == "success"
+
+        rate = positive_float(data.dig("rates", to))
+        raise "open.er-api.com missing #{to} rate" unless rate
+
+        updated_at = data["time_last_update_utc"].to_s
+        {
+          from: from,
+          to: to,
+          rate: rate,
+          date: parse_exchange_rate_date(updated_at),
+          updated_at: updated_at,
+          source: "open.er-api.com"
+        }
+      end
+
+      def fetch_frankfurter_exchange_rate(from, to)
+        query = URI.encode_www_form("from" => from, "to" => to)
+        data  = fetch_exchange_rate_json("#{EXCHANGE_RATE_FALLBACK_URL}?#{query}")
+
+        rate = positive_float(data.dig("rates", to))
+        raise "frankfurter.app missing #{to} rate" unless rate
+
+        {
+          from: from,
+          to: to,
+          rate: rate,
+          date: data["date"].to_s,
+          updated_at: data["date"].to_s,
+          source: "frankfurter.app"
+        }
+      end
+
+      def fetch_exchange_rate_json(url)
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 5
+        http.read_timeout = 8
+
+        req = Net::HTTP::Get.new(uri.request_uri, "Accept" => "application/json")
+        response = http.request(req)
+        raise "HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body.to_s)
+      end
+
+      def positive_float(value)
+        rate = Float(value)
+        rate.positive? ? rate : nil
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def parse_exchange_rate_date(value)
+        return "" if value.to_s.strip.empty?
+
+        Date.parse(value.to_s).iso8601
+      rescue ArgumentError
+        ""
+      end
+
       # ── Onboard API ───────────────────────────────────────────────────────────
 
       # GET /api/onboard/status
@@ -697,6 +811,158 @@ module Clacky
         json_response(res, 500, { ok: false, error: e.message })
       end
 
+      # POST /api/media/image
+      # Body: { "prompt": "...", "aspect_ratio": "landscape|square|portrait",
+      #         "output_dir": "<absolute path, optional>" }
+      # Routes to the model configured with type=image in agent_config.
+      def api_media_image(req, res)
+        body = parse_json_body(req)
+        return json_response(res, 400, { error: "Invalid JSON" }) unless body
+
+        prompt = body["prompt"].to_s
+        if prompt.strip.empty?
+          return json_response(res, 422, { error: "prompt is required" })
+        end
+
+        aspect_ratio = body["aspect_ratio"].to_s
+        aspect_ratio = "landscape" if aspect_ratio.empty?
+        output_dir   = body["output_dir"].to_s
+        output_dir   = @agent_config.default_working_dir || Dir.pwd if output_dir.empty?
+
+        result = Clacky::Media::Generator.new(@agent_config).generate_image(
+          prompt: prompt,
+          aspect_ratio: aspect_ratio,
+          output_dir: output_dir
+        )
+        if result["success"]
+          log_media_usage(result, prompt: prompt)
+        end
+        status = result["success"] ? 200 : 422
+        json_response(res, status, result)
+      rescue StandardError => e
+        json_response(res, 500, { error: e.message })
+      end
+
+      private def log_media_usage(result, prompt:)
+        usage = result["usage"]
+        cost  = result["cost_usd"]
+        return if usage.nil? && cost.nil?
+
+        parts = []
+        parts << "model=#{result["model"]}"
+        parts << "provider=#{result["provider"]}"
+        if usage.is_a?(Hash)
+          parts << "prompt_tokens=#{usage["prompt_tokens"]}"
+          parts << "completion_tokens=#{usage["completion_tokens"]}"
+          parts << "cache_read=#{usage["cache_read_tokens"]}" if usage["cache_read_tokens"].to_i > 0
+          parts << "cache_write=#{usage["cache_write_tokens"]}" if usage["cache_write_tokens"].to_i > 0
+        end
+        parts << format("cost_usd=%.6f", cost.to_f) if cost
+        parts << "prompt=#{prompt[0, 60].inspect}"
+        Clacky::Logger.info("[Media] image generated #{parts.join(" ")}")
+      end
+
+      # GET /api/media/types
+      # Returns which media types are configured in agent_config.models.
+      # Used by the media-gen skill to decide whether to surface generation
+      # capabilities to the user.
+      def api_media_types(res)
+        out = {}
+        Clacky::Providers::MEDIA_KINDS.each do |t|
+          state = @agent_config.media_state(t)
+          out[t] =
+            if state["configured"]
+              {
+                configured: true,
+                model:      state["model"],
+                base_url:   state["base_url"],
+                source:     state["source"]
+              }
+            else
+              { configured: false, source: "off" }
+            end
+        end
+        json_response(res, 200, out)
+      end
+
+      # GET /api/config/media
+      # Used by the Settings UI to render the tri-state media controls.
+      # Per-kind payload mirrors AgentConfig#media_state.
+      def api_get_media_config(res)
+        out = {}
+        Clacky::Providers::MEDIA_KINDS.each do |t|
+          state = @agent_config.media_state(t)
+          entry = @agent_config.find_model_by_type(t)
+          out[t] = {
+            source:     state["source"],
+            model:      state["model"],
+            base_url:   state["base_url"],
+            api_key_masked: entry ? mask_api_key(entry["api_key"]) : nil,
+            provider:   state["provider"],
+            available:  state["available"],
+            configured: state["configured"]
+          }
+        end
+
+        # Surface what the current default model can offer, even when the
+        # user is currently in "off" — the UI uses this to render the
+        # auto-mode preview ("Auto would use X").
+        default = @agent_config.find_model_by_type("default")
+        provider_id = default && Clacky::Providers.resolve_provider(
+          base_url: default["base_url"],
+          api_key:  default["api_key"]
+        )
+        defaults = {}
+        Clacky::Providers::MEDIA_KINDS.each do |t|
+          defaults[t] = {
+            provider:  provider_id,
+            model:     provider_id ? Clacky::Providers.default_media_model(provider_id, t) : nil,
+            available: provider_id ? Clacky::Providers.media_models(provider_id, t) : []
+          }
+        end
+
+        json_response(res, 200, { media: out, default_provider: defaults })
+      end
+
+      # PATCH /api/config/media/:kind
+      # Body: { source: "off"|"auto"|"custom", model?, base_url?, api_key?,
+      #         anthropic_format? }
+      # off / auto — remove any custom entry; "auto" lets the virtual
+      # derivation in AgentConfig#find_model_by_type take over.
+      # custom — replace any existing custom entry with the supplied fields.
+      def api_update_media_config(kind, req, res)
+        body = parse_json_body(req) || {}
+        source = body["source"].to_s
+        unless %w[off auto custom].include?(source)
+          return json_response(res, 422, { error: "invalid source" })
+        end
+
+        @agent_config.models.reject! { |m| m["type"] == kind }
+
+        if source == "custom"
+          model    = body["model"].to_s.strip
+          base_url = body["base_url"].to_s.strip
+          api_key  = body["api_key"].to_s
+          if model.empty? || base_url.empty? || api_key.empty? || api_key.include?("****")
+            return json_response(res, 422, { error: "model, base_url, api_key are required" })
+          end
+
+          @agent_config.models << {
+            "id"               => SecureRandom.uuid,
+            "model"            => model,
+            "base_url"         => base_url,
+            "api_key"          => api_key,
+            "anthropic_format" => body["anthropic_format"] || false,
+            "type"             => kind
+          }
+        end
+
+        @agent_config.save
+        json_response(res, 200, { ok: true, state: @agent_config.media_state(kind) })
+      rescue => e
+        json_response(res, 422, { error: e.message })
+      end
+
       # POST /api/onboard/complete
       # Called after key setup is done (soul_setup is optional/skipped).
       # Creates the default session if none exists yet, returns it.
@@ -1614,7 +1880,7 @@ module Clacky
       # Returns current config and running status for all supported platforms.
       # POST /api/tool/browser
       # Executes a browser tool action via the shared BrowserManager daemon.
-      # Used by skill scripts (e.g. feishu_setup.rb) to reuse the server's
+      # Used by skill scripts to reuse the server's
       # existing Chrome connection without spawning a second MCP daemon.
       #
       # Request body: JSON with same params as the browser tool
@@ -2486,16 +2752,28 @@ module Clacky
         root = File.expand_path(agent.working_dir.to_s)
         return json_response(res, 404, { error: "Working directory not found" }) unless Dir.exist?(root)
 
-        rel = URI.decode_www_form(req.query_string.to_s).to_h["path"].to_s
-        rel = rel.sub(%r{\A/+}, "").strip
-        target = File.expand_path(File.join(root, rel))
+        query = URI.decode_www_form(req.query_string.to_s).to_h
+        rel = query["path"].to_s
+        absolute_mode = query["absolute"] == "true"
+
+        # Absolute mode: allow browsing outside working directory (e.g., root "/")
+        if absolute_mode
+          target = File.expand_path(rel.empty? ? "/" : rel)
+          display_root = target
+          # Normalize rel for API response
+          rel = target
+        else
+          rel = rel.sub(%r{\A/+}, "").strip
+          target = File.expand_path(File.join(root, rel))
+          display_root = root
 
-        # Reject traversal outside the working directory.
-        unless target == root || target.start_with?("#{root}/")
-          return json_response(res, 403, { error: "Path outside working directory" })
+          # Reject traversal outside the working directory.
+          unless target == root || target.start_with?("#{root}/")
+            return json_response(res, 403, { error: "Path outside working directory" })
+          end
         end
-        return json_response(res, 404, { error: "Directory not found" }) unless Dir.exist?(target)
 
+        return json_response(res, 404, { error: "Directory not found" }) unless Dir.exist?(target)
         entries = Dir.children(target).reject { |name| IGNORED_FILE_ENTRIES.include?(name) }
 
         items = entries.filter_map do |name|
@@ -2505,7 +2783,7 @@ module Clacky
           next unless File.exist?(full)
           {
             name:  name,
-            path:  rel.empty? ? name : "#{rel}/#{name}",
+            path:  "#{rel}/#{name}".gsub(%r{/+}, "/"),
             type:  is_dir ? "dir" : "file",
             size:  is_dir ? nil : (File.size(full) rescue nil)
           }
@@ -2516,7 +2794,7 @@ module Clacky
         # Directories first, then files; both case-insensitive alphabetical.
         items.sort_by! { |it| [it[:type] == "dir" ? 0 : 1, it[:name].downcase] }
 
-        json_response(res, 200, { root: root, path: rel, entries: items })
+        json_response(res, 200, { root: display_root, path: rel, entries: items })
       rescue StandardError => e
         json_response(res, 500, { error: e.message })
       end
@@ -3285,8 +3563,13 @@ module Clacky
             type:             m["type"]
           }
         end
-        # Filter out auto-injected models (like lite) from UI display
-        models.reject! { |m| @agent_config.models[m[:index]]["auto_injected"] }
+        # Filter out auto-injected models (lite, derived media) AND media
+        # entries (image/video/audio) — those are managed via the dedicated
+        # media-config UI, not the chat-model card list.
+        models.reject! do |m|
+          raw = @agent_config.models[m[:index]]
+          raw["auto_injected"] || Clacky::Providers::MEDIA_KINDS.include?(raw["type"].to_s)
+        end
         json_response(res, 200, {
           models: models,
           current_index: @agent_config.current_model_index,
@@ -3506,29 +3789,51 @@ module Clacky
         return json_response(res, 400, { error: "Invalid JSON" }) unless body
 
         api_key = body["api_key"].to_s
-        # If masked, use the stored key from the matching model (by index or current)
         if api_key.include?("****")
           idx = body["index"]&.to_i || @agent_config.current_model_index
           api_key = @agent_config.models.dig(idx, "api_key").to_s
         end
 
-        begin
-          model = body["model"].to_s
-          test_client = Clacky::Client.new(
-            api_key,
-            base_url:         body["base_url"].to_s,
-            model:            model,
-            anthropic_format: body["anthropic_format"] || false
-          )
-          result = test_client.test_connection(model: model)
-          if result[:success]
-            json_response(res, 200, { ok: true, message: "Connected successfully" })
-          else
-            json_response(res, 200, { ok: false, message: result[:error].to_s })
-          end
-        rescue => e
-          json_response(res, 200, { ok: false, message: e.message })
+        model            = body["model"].to_s
+        base_url         = body["base_url"].to_s
+        anthropic_format = body["anthropic_format"] || false
+
+        result, used_base_url = try_test_with_base_url(api_key, base_url, model, anthropic_format)
+
+        if result[:success] && used_base_url != base_url
+          json_response(res, 200, {
+            ok:                  true,
+            message:             "Connected (auto-corrected base_url to add /v1)",
+            effective_base_url:  used_base_url
+          })
+        elsif result[:success]
+          json_response(res, 200, { ok: true, message: "Connected successfully" })
+        else
+          json_response(res, 200, { ok: false, message: result[:error].to_s })
         end
+      rescue => e
+        json_response(res, 200, { ok: false, message: e.message })
+      end
+
+      private def try_test_with_base_url(api_key, base_url, model, anthropic_format)
+        result = run_test_connection(api_key, base_url, model, anthropic_format)
+        return [result, base_url] if result[:success]
+        return [result, base_url] unless result[:status] == 404
+        return [result, base_url] if base_url.match?(%r{/v\d+/?\z})
+
+        candidate = "#{base_url.chomp("/")}/v1"
+        retried   = run_test_connection(api_key, candidate, model, anthropic_format)
+        retried[:success] ? [retried, candidate] : [result, base_url]
+      end
+
+      private def run_test_connection(api_key, base_url, model, anthropic_format)
+        client = Clacky::Client.new(
+          api_key,
+          base_url:         base_url,
+          model:            model,
+          anthropic_format: anthropic_format
+        )
+        client.test_connection(model: model)
       end
 
       # GET /api/providers — return built-in provider presets for quick setup