openclacky 1.1.2 → 1.1.4

data/lib/clacky/message_format/anthropic.rb

@@ -48,7 +48,7 @@ module Clacky
       # @param max_tokens [Integer]
       # @param caching_enabled [Boolean]
       # @return [Hash] ready to serialize as JSON body
-      def build_request_body(messages, model, tools, max_tokens, caching_enabled)
+      def build_request_body(messages, model, tools, max_tokens, caching_enabled, reasoning_effort: nil)
         system_messages = messages.select { |m| m[:role] == "system" }
         regular_messages = messages.reject { |m| m[:role] == "system" }
 
@@ -64,9 +64,21 @@ module Clacky
         body = { model: model, max_tokens: max_tokens, messages: api_messages }
         body[:system] = system_text unless system_text.empty?
         body[:tools]  = api_tools   if api_tools&.any?
+
+        if (effort = normalized_effort(reasoning_effort))
+          body[:thinking] = { type: "adaptive" }
+          body[:output_config] = { effort: effort }
+        end
+
         body
       end
 
+      private_class_method def self.normalized_effort(effort)
+        return nil if effort.nil? || effort.to_s.empty?
+        s = effort.to_s
+        %w[low medium high].include?(s) ? s : nil
+      end
+
       # ── Response parsing ──────────────────────────────────────────────────────
 
       # Parse Anthropic API response into canonical internal format.
@@ -182,7 +194,23 @@ module Clacky
             func  = tc[:function] || tc
             name  = func[:name]  || tc[:name]
             raw_args = func[:arguments] || tc[:arguments]
-            input = raw_args.is_a?(String) ? JSON.parse(raw_args) : raw_args
+            input =
+              if raw_args.is_a?(String)
+                begin
+                  JSON.parse(raw_args)
+                rescue JSON::ParserError => e
+                  Clacky::Logger.warn("message_format.anthropic.tool_args_parse_failed",
+                    tool_name: name.to_s,
+                    tool_call_id: tc[:id].to_s,
+                    args_len: raw_args.length,
+                    args_head: raw_args[0, 120],
+                    error: e.message
+                  ) if defined?(Clacky::Logger)
+                  {}
+                end
+              else
+                raw_args
+              end
             blocks << { type: "tool_use", id: tc[:id], name: name, input: input || {} }
           end
 

data/lib/clacky/message_format/bedrock.rb

@@ -52,7 +52,7 @@ module Clacky
       # @param max_tokens [Integer]
       # @param caching_enabled [Boolean] (currently unused for Bedrock)
       # @return [Hash] ready to serialize as JSON body
-      def build_request_body(messages, model, tools, max_tokens, caching_enabled = false)
+      def build_request_body(messages, model, tools, max_tokens, caching_enabled = false, reasoning_effort: nil)
         system_messages = messages.select { |m| m[:role] == "system" }
         regular_messages = messages.reject { |m| m[:role] == "system" }
 
@@ -83,9 +83,21 @@ module Clacky
           body[:toolConfig] = { tools: tools.map { |t| to_api_tool(t) } }
         end
 
+        extra = additional_fields_for_effort(reasoning_effort)
+        body[:additionalModelRequestFields] = extra if extra
+
         body
       end
 
+      private_class_method def self.additional_fields_for_effort(effort)
+        return nil if effort.nil? || effort.to_s.empty?
+        return nil unless %w[low medium high].include?(effort.to_s)
+        {
+          thinking: { type: "adaptive" },
+          output_config: { effort: effort.to_s }
+        }
+      end
+
       # ── Response parsing ──────────────────────────────────────────────────────
 
       # Parse Bedrock Converse API response into canonical internal format.

data/lib/clacky/message_format/open_ai.rb

@@ -44,7 +44,7 @@ module Clacky
       # @param vision_supported [Boolean] whether the target model accepts
       #   image_url content blocks (default true, conservative)
       # @return [Hash]
-      def build_request_body(messages, model, tools, max_tokens, caching_enabled, vision_supported: true)
+      def build_request_body(messages, model, tools, max_tokens, caching_enabled, vision_supported: true, reasoning_effort: nil)
         api_messages = messages.map { |msg| normalize_message_content(msg, vision_supported: vision_supported) }
 
         body = { model: model, max_tokens: max_tokens, messages: api_messages }
@@ -59,6 +59,10 @@ module Clacky
           end
         end
 
+        if reasoning_effort && !reasoning_effort.to_s.empty?
+          body[:reasoning_effort] = reasoning_effort.to_s
+        end
+
         body
       end
 

data/lib/clacky/providers.rb

@@ -329,6 +329,40 @@ module Clacky
           "gpt-5.4" => "gpt-5.4-mini"
         },
         "website_url" => "https://platform.openai.com/api-keys"
+      }.freeze,
+
+      "qwen" => {
+        "name" => "Qwen (Alibaba)",
+        "base_url" => "https://dashscope.aliyuncs.com/compatible-mode/v1",
+        "api" => "openai-completions",
+        "default_model" => "qwen3.6-plus",
+        "models" => [
+          "qwen3.6-plus",
+          "qwen3.6-max",
+          "qwen3.6-27b",
+          "qwen3.6-flash",
+          "qwen-plus-latest",
+          "qwen-vl-plus",
+          "qwen-vl-max"
+        ],
+        "endpoint_variants" => [
+          { "label" => "Mainland China",  "label_key" => "settings.models.baseurl.variant.mainland_cn",   "base_url" => "https://dashscope.aliyuncs.com/compatible-mode/v1",     "region" => "cn"   }.freeze,
+          { "label" => "Singapore",       "label_key" => "settings.models.baseurl.variant.international", "base_url" => "https://dashscope-intl.aliyuncs.com/compatible-mode/v1", "region" => "intl" }.freeze,
+          { "label" => "US (Virginia)",   "label_key" => "settings.models.baseurl.variant.us",            "base_url" => "https://dashscope-us.aliyuncs.com/compatible-mode/v1",   "region" => "us"   }.freeze
+        ].freeze,
+        "capabilities" => { "vision" => false }.freeze,
+        "model_capabilities" => {
+          "qwen3.6-27b"  => { "vision" => true }.freeze,
+          "qwen-vl-plus" => { "vision" => true }.freeze,
+          "qwen-vl-max"  => { "vision" => true }.freeze
+        }.freeze,
+        "lite_models" => {
+          "qwen3.6-plus"     => "qwen3.6-flash",
+          "qwen3.6-max"      => "qwen3.6-flash",
+          "qwen3.6-27b"      => "qwen3.6-flash",
+          "qwen-plus-latest" => "qwen3.6-flash"
+        },
+        "website_url" => "https://bailian.console.aliyun.com/?apiKey=1"
       }.freeze
 
     }.freeze

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

@@ -53,6 +53,10 @@ module Clacky
             # and expires (~2h). We cache it from inbound events and validate on send.
             @webhook_urls  = {}
             @webhook_mutex = Mutex.new
+            # chat_id => { robot_code:, conv_id:, user_id:, conv_type: } — needed
+            # to route OAPI calls (e.g. send_file) which can't go through webhook.
+            @routes        = {}
+            @routes_mutex  = Mutex.new
           end
 
           WEBHOOK_SAFETY_MARGIN_MS = 5 * 60 * 1000
@@ -74,13 +78,69 @@ module Clacky
           end
 
           # @param chat_id [String] — for DingTalk Stream Mode, chat_id == webhook URL
+          # Always sent as markdown so AI replies render rich text (headings,
+          # bold, lists, links). DingTalk's markdown msgtype renders plain text
+          # unchanged, so no detection branch is needed.
           def send_text(chat_id, text, reply_to: nil)
             webhook_url = resolve_webhook(chat_id)
             unless webhook_url
               Clacky::Logger.warn("[dingtalk] no valid sessionWebhook for chat #{chat_id} (expired or never received)")
               return { ok: false, error: "session_webhook_expired" }
             end
-            @api_client.send_via_webhook(webhook_url, text)
+            @api_client.send_via_webhook(webhook_url, text, msg_type: :markdown)
+          end
+
+          # Send a local file (image or generic file) as a native attachment.
+          # Webhook can't deliver attachments — use OAPI sendMessage with mediaId.
+          # @param chat_id [String]
+          # @param path [String] local file path
+          # @param name [String, nil] display filename (not used by image msg)
+          def send_file(chat_id, path, name: nil, reply_to: nil)
+            unless File.exist?(path)
+              Clacky::Logger.warn("[dingtalk] send_file: file not found #{path}")
+              return { ok: false, error: "file_not_found" }
+            end
+
+            route = resolve_route(chat_id)
+            unless route
+              Clacky::Logger.warn("[dingtalk] send_file: no routing info for chat #{chat_id}")
+              return { ok: false, error: "no_route" }
+            end
+
+            kind = image_file?(path) ? :image : :file
+
+            # Non-image files outside DingTalk's accepted extension list
+            # (sampleFile rejects anything not in SUPPORTED_FILE_EXTS).
+            # Surface the failure directly to the user in the chat,
+            # disguised as a DingTalk system message so it's clear the
+            # restriction comes from the IM platform, not us.
+            if kind == :file && !supported_file?(path)
+              ext = File.extname(path).delete_prefix(".").downcase
+              display_name = name || File.basename(path)
+              Clacky::Logger.info("[dingtalk] send_file: unsupported extension .#{ext} (#{display_name})")
+              supported_list = ApiClient::SUPPORTED_FILE_EXTS.map { |e| ".#{e}" }.join(", ")
+              send_text(
+                chat_id,
+                %([DingTalk System] ⚠️ Failed to deliver file "#{display_name}": file type ".#{ext}" is not supported. Supported types: #{supported_list}.)
+              )
+              return { ok: false, error: :unsupported_extension }
+            end
+
+            media_id = @api_client.upload_media(path, kind: kind)
+            unless media_id
+              Clacky::Logger.warn("[dingtalk] send_file: upload failed for #{path}")
+              return { ok: false, error: "upload_failed" }
+            end
+
+            @api_client.send_media(
+              robot_code: route[:robot_code],
+              conv_type:  route[:conv_type],
+              conv_id:    route[:conv_id],
+              user_id:    route[:user_id],
+              media_id:   media_id,
+              kind:       kind,
+              file_name:  name || File.basename(path)
+            )
           end
 
           def validate_config(config)
@@ -106,16 +166,18 @@ module Clacky
             chat_id      = data.dig("conversationId") || sender_id
             webhook_url  = data.dig("sessionWebhook") || ""
             expired_ms   = (data.dig("sessionWebhookExpiredTime") || 0).to_i
-            text         = extract_text(data)
             conv_type    = data.dig("conversationType").to_s  # "1"=DM, "2"=group
+            robot_code   = data["robotCode"].to_s
 
             cache_webhook(chat_id, webhook_url, expired_ms) unless webhook_url.empty?
+            cache_route(chat_id, robot_code: robot_code, conv_id: data["conversationId"].to_s,
+                        user_id: sender_id, conv_type: conv_type)
 
             return if sender_id.empty?
 
             # Group chats: only respond when @-mentioned
             if conv_type == "2"
-              content = data.dig("text", "content").to_s
+              content  = data.dig("text", "content").to_s
               at_users = Array(data.dig("atUsers")).map { |u| u.dig("dingtalkId") || u.dig("staffId") || "" }
               bot_id   = data.dig("chatbotUserId").to_s
               unless at_users.include?(bot_id) || content.include?("@")
@@ -126,22 +188,72 @@ module Clacky
             allowed = @config[:allowed_users]
             return if allowed && !allowed.empty? && !allowed.include?(sender_id)
 
+            text, files = extract_payload(data, robot_code)
+            return if text.strip.empty? && files.empty?
+
             event = {
               platform:   :dingtalk,
               user_id:    sender_id,
               chat_id:    chat_id,
               message_id: data.dig("msgId") || "",
               text:       text,
-              files:      [],
+              files:      files,
               chat_type:  conv_type == "2" ? :group : :direct
             }
 
-            Clacky::Logger.info("[dingtalk] message from #{sender_id}: #{text.to_s[0, 80]}")
+            log_parts = []
+            log_parts << text.slice(0, 80) unless text.strip.empty?
+            log_parts << "#{files.size} file(s)" unless files.empty?
+            Clacky::Logger.info("[dingtalk] message from #{sender_id}: #{log_parts.join(' | ')}")
             @on_message&.call(event)
           rescue => e
             Clacky::Logger.warn("[dingtalk] handle_frame error: #{e.message}")
           end
 
+          # Parse text + attachments from inbound event by msgtype.
+          # Returns [text, files] where files is an array of { path:, mime:, name: }.
+          private def extract_payload(data, robot_code)
+            msgtype = data["msgtype"].to_s
+            text    = ""
+            files   = []
+
+            case msgtype
+            when "text"
+              text = extract_text(data)
+            when "picture"
+              code = data.dig("content", "downloadCode")
+              file = download_one(code, robot_code)
+              files << file if file
+            when "file"
+              # Inbound file message — DingTalk's downloadCode → downloadUrl path
+              # works for any file type (no whitelist on the inbound side).
+              code = data.dig("content", "downloadCode")
+              name = data.dig("content", "fileName")
+              file = download_one(code, robot_code, prefer_name: name)
+              files << file if file
+            when "richText"
+              Array(data.dig("content", "richText")).each do |part|
+                if part["text"]
+                  text += part["text"].to_s
+                elsif part["downloadCode"] && part["type"] == "picture"
+                  file = download_one(part["downloadCode"], robot_code)
+                  files << file if file
+                end
+              end
+            else
+              Clacky::Logger.info("[dingtalk] unsupported msgtype=#{msgtype}, ignoring")
+            end
+
+            [text, files]
+          end
+
+          private def download_one(download_code, robot_code, prefer_name: nil)
+            res = @api_client.download_message_file(download_code, robot_code, prefer_name: prefer_name)
+            return nil unless res
+            name = (prefer_name && !prefer_name.to_s.empty?) ? prefer_name.to_s : File.basename(res[:path])
+            { path: res[:path], mime: res[:mime], name: name }
+          end
+
           private def extract_text(data)
             content = data.dig("text", "content").to_s.strip
             # Strip leading @bot mention if present
@@ -168,6 +280,31 @@ module Clacky
             end
             entry[:url]
           end
+
+          private def cache_route(chat_id, robot_code:, conv_id:, user_id:, conv_type:)
+            return if robot_code.empty?
+            @routes_mutex.synchronize do
+              @routes[chat_id] = {
+                robot_code: robot_code,
+                conv_id:    conv_id,
+                user_id:    user_id,
+                conv_type:  conv_type
+              }
+            end
+          end
+
+          private def resolve_route(chat_id)
+            @routes_mutex.synchronize { @routes[chat_id] }
+          end
+
+          private def image_file?(path)
+            %w[.jpg .jpeg .png .gif .webp].include?(File.extname(path).downcase)
+          end
+
+          private def supported_file?(path)
+            ext = File.extname(path).delete_prefix(".").downcase
+            ApiClient::SUPPORTED_FILE_EXTS.include?(ext)
+          end
         end
 
         Adapters.register(:dingtalk, Adapter)