openclacky 1.2.10 → 1.2.13

data/lib/clacky/default_skills/channel-manager/feishu_setup.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module FeishuSetup
+  ENDPOINT            = "/oauth/v1/app/registration"
+  DEFAULT_DOMAIN      = "https://accounts.feishu.cn"
+  DEFAULT_LARK_DOMAIN = "https://accounts.larksuite.com"
+  SDK_NAME            = "ruby-sdk"
+
+  class SetupError < StandardError
+    attr_reader :code, :description
+    def initialize(code, description)
+      @code = code
+      @description = description
+      super("#{code}: #{description}")
+    end
+  end
+
+  class AppAccessDeniedError < SetupError; end
+  class AppExpiredError      < SetupError; end
+
+  def self.run(app_name: nil, app_desc: nil, on_qr_code:, on_status_change: nil,
+               domain: DEFAULT_DOMAIN, lark_domain: DEFAULT_LARK_DOMAIN)
+    base_url        = domain
+    domain_switched = false
+
+    init_res = post(base_url, action: "init")
+    methods  = init_res["supported_auth_methods"] || []
+    unless methods.include?("client_secret")
+      raise SetupError.new("unsupported_auth_method", "client_secret not supported")
+    end
+
+    begin_res = post(base_url,
+      action:            "begin",
+      archetype:         "PersonalAgent",
+      auth_method:       "client_secret",
+      request_user_info: "open_id"
+    )
+
+    device_code = begin_res["device_code"]
+    interval    = (begin_res["interval"] || 5).to_i
+    expire_in   = (begin_res["expires_in"] || 600).to_i
+    qr_url      = build_qr_url(begin_res["verification_uri_complete"], app_name: app_name, app_desc: app_desc)
+
+    on_qr_code.call(qr_url, expire_in)
+
+    deadline = Time.now + expire_in
+
+    loop do
+      raise AppExpiredError.new("expired_token", "polling timed out") if Time.now >= deadline
+
+      poll_res = post(base_url, action: "poll", device_code: device_code)
+
+      if poll_res["client_id"] && poll_res["client_secret"]
+        return { client_id: poll_res["client_id"], client_secret: poll_res["client_secret"] }
+      end
+
+      user_info = poll_res["user_info"] || {}
+      if user_info["tenant_brand"] == "lark" && !domain_switched
+        base_url        = lark_domain
+        domain_switched = true
+        on_status_change&.call("domain_switched")
+        next
+      end
+
+      case poll_res["error"]
+      when "authorization_pending"
+        on_status_change&.call("polling")
+        sleep interval
+      when "slow_down"
+        interval += 5
+        on_status_change&.call("slow_down")
+        sleep interval
+      when "access_denied"
+        raise AppAccessDeniedError.new("access_denied", poll_res["error_description"].to_s)
+      when "expired_token"
+        raise AppExpiredError.new("expired_token", poll_res["error_description"].to_s)
+      else
+        err = poll_res["error"].to_s
+        raise SetupError.new(err, poll_res["error_description"].to_s) unless err.empty?
+        sleep interval
+      end
+    end
+  end
+
+  private_class_method def self.post(base_url, params)
+    uri               = URI("#{base_url}#{ENDPOINT}")
+    http              = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl      = uri.scheme == "https"
+    http.open_timeout = 10
+    http.read_timeout = 30
+    req               = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/x-www-form-urlencoded")
+    req.body          = URI.encode_www_form(params)
+    JSON.parse(http.request(req).body)
+  end
+
+  private_class_method def self.build_qr_url(uri_complete, app_name: nil, app_desc: nil)
+    uri              = URI.parse(uri_complete)
+    params           = URI.decode_www_form(uri.query.to_s).to_h
+    params["from"]   = "sdk"
+    params["tp"]     = "sdk"
+    params["source"] = SDK_NAME
+    params["name"]   = app_name if app_name
+    params["desc"]   = app_desc if app_desc
+    uri.query        = URI.encode_www_form(params)
+    uri.to_s
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  product_name = ENV.fetch("CLACKY_PRODUCT_NAME", "OpenClacky")
+  date_suffix  = Time.now.strftime("%Y%m%d")
+  app_desc     = "Your personal assistant powered by #{product_name}"
+
+  result = FeishuSetup.run(
+    app_name: "#{product_name} #{date_suffix}",
+    app_desc: app_desc,
+    on_qr_code: lambda { |url, expire_in|
+      puts "SCAN_URL:#{url}"
+      puts "EXPIRE_IN:#{expire_in}"
+      $stdout.flush
+    },
+    on_status_change: lambda { |status|
+      $stderr.puts "[feishu-setup] status=#{status}"
+    }
+  )
+
+  puts "APP_ID:#{result[:client_id]}"
+  puts "APP_SECRET:#{result[:client_secret]}"
+  $stdout.flush
+end

data/lib/clacky/default_skills/media-gen/SKILL.md

@@ -32,6 +32,11 @@ Do NOT try to fall back to `terminal` + a hand-written `curl https://api.openai.
 
 ## Step 2 — Generate the image
 
+### ⚠️  Important: generation speed & concurrency
+
+- **Image generation can be slow — up to 2 minutes per image depending on the model.** Before calling the API, warn the user that it may take a minute or two. The curl request blocks until the image is ready; do NOT run it in the background.
+- **One at a time only.** Never generate multiple images concurrently (e.g. by running several `curl` commands simultaneously or in a script loop). Each call consumes significant server-side resources, and parallel requests will almost certainly cause timeouts. If the user wants several images, generate them **sequentially**, one after another.
+
 ```bash
 curl -s -X POST http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/media/image \
   -H "Content-Type: application/json" \

data/lib/clacky/default_skills/persist-memory/SKILL.md

@@ -48,10 +48,11 @@ Scan the list above:
 
 Use the `write` tool. Always include the YAML frontmatter shown above.
 
-## Hard constraints (CRITICAL)
+## Guidelines
 
-- Each file MUST stay under **4000 characters of content** (after the frontmatter).
-- If merging would exceed this limit, remove the least important information — do NOT split into multiple files for the same topic.
+- Aim for around 4000 characters of content (after the frontmatter). This is a soft target — moderate overshoot is fine, do NOT iterate writes just to shave characters.
+- If a file grows much larger than that (say, well past 8000), trim the least important information rather than splitting one topic across multiple files.
+- Prefer merging into an existing file over creating a new one. Only create a new file when no existing topic genuinely covers the area.
 - Write concise, factual Markdown — no fluff, no redundant headings.
 - One topic per file. Don't bundle unrelated facts together.
 - Do NOT use `terminal` or `file_reader` to list the memories directory — the list above is authoritative.

data/lib/clacky/default_skills/search-skills/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: search-skills
+description: 'Search ALL installed skills (including ones not shown in AVAILABLE SKILLS) by keyword. Use this whenever you suspect a fitting skill might exist but is not listed in your system prompt — for example before building a new skill, when the user mentions a domain not covered by visible skills, or after seeing the (N more skills installed) hint. Triggers on phrases like search skills, find a skill for, is there a skill that, 查找skill, 有没有skill做.'
+disable-model-invocation: false
+user-invocable: true
+fork_agent: true
+auto_summarize: true
+forbidden_tools:
+  - write
+  - edit
+  - terminal
+  - web_search
+  - web_fetch
+  - browser
+---
+
+# Search Skills Subagent
+
+You are a Skill Search Subagent. Given a keyword or topic from the parent agent, scan the complete list of installed skills below and return the best matches.
+
+The AVAILABLE SKILLS section in the parent agent system prompt is capped (~30 entries). The list below is the FULL list — pre-loaded for you, no scanning required. Your job is to look beyond that cap so the parent does not redundantly create a new skill when one already exists.
+
+## Complete Skill Inventory
+
+This list was pre-loaded — do NOT re-scan the filesystem or call any tools.
+
+<%= all_skills_meta %>
+
+## Workflow
+
+### Step 1 — Extract keywords
+
+Pull 2-4 keywords from the input task. Both English and Chinese terms are valid (skill descriptions are bilingual).
+
+### Step 2 — Match against the inventory above
+
+For each skill in the inventory, judge relevance against the keywords:
+- Strong match: keyword appears in the skill `name` or clearly in the `description`'s purpose statement
+- Weak match: keyword appears only in the trigger examples or peripheral mentions
+
+### Step 3 — Return a ranked summary
+
+Return at most 5 results, strongest matches first:
+
+```
+Found N matching skill(s) for: <keywords>
+
+1. <name>  (<source>)
+   <description trimmed to ~200 chars>
+
+2. ...
+```
+
+If nothing genuinely matches, return exactly: `No installed skill matches: <task>`
+
+## Rules
+
+- Do NOT invoke any tool. The inventory above is authoritative; just match and return.
+- Do NOT recommend creating a new skill — that is the parent agent's call.
+- If the task is vague, return what genuinely matched, do not invent relevance.
+- Default skills (built-in) are part of the inventory but typically also visible to the parent — flagging them is still useful as a reminder.

data/lib/clacky/idle_compression_timer.rb

@@ -17,7 +17,7 @@ module Clacky
     # Seconds of inactivity before idle compression is triggered.
     # Kept under the 5-minute prompt cache TTL so the compression call itself
     # still hits the existing prefix cache.
-    IDLE_DELAY = 314
+    IDLE_DELAY = 266
 
     # @param agent [Clacky::Agent] the agent whose messages will be compressed
     # @param session_manager [Clacky::SessionManager, nil] used to persist session after compression

data/lib/clacky/message_format/open_ai.rb

@@ -206,7 +206,13 @@ module Clacky
           # Skip malformed tool calls where name or arguments is nil (broken API response)
           next if name.nil? || arguments.nil?
 
-          { id: call["id"], type: call["type"], name: name, arguments: arguments }
+          tc = { id: call["id"], type: call["type"], name: name, arguments: arguments }
+          # Vertex Gemini's OpenAI shim returns thought_signature inside
+          # tool_calls[i].extra_content.google and requires it echoed back on
+          # replay, otherwise the next turn 400s with "Function call is missing
+          # a thought_signature". Preserve it through the canonical layer.
+          tc[:extra_content] = call["extra_content"] if call["extra_content"]
+          tc
         end
       end
 

data/lib/clacky/message_history.rb

@@ -193,6 +193,7 @@ module Clacky
     #   this bypass lets us recover on the retry without a server restart.
     def to_api(force_reasoning_content_pad: false)
       msgs = @messages.map { |m| strip_for_api(m) }
+      msgs = repair_tool_call_pairing(msgs)
       ensure_reasoning_content_consistency(msgs, force: force_reasoning_content_pad)
     end
 
@@ -276,6 +277,62 @@ module Clacky
       message.reject { |k, _| INTERNAL_FIELDS.include?(k) }
     end
 
+    # Defensive integrity pass before sending history to the LLM.
+    # OpenAI-compat protocols (incl. DeepSeek) require every assistant.tool_calls
+    # to be followed by a tool message for each tool_call_id. If a previous turn
+    # was interrupted mid-act() — e.g. a channel user sent a second message
+    # before the first finished — the tool segment may be missing entries,
+    # producing HTTP 400 "insufficient tool messages following tool_calls".
+    # This pass scans the whole history and inserts placeholder tool messages
+    # for any unmatched ids. It is deterministic (same input → same output)
+    # so prompt caching is not disturbed.
+    private def repair_tool_call_pairing(msgs)
+      result = []
+      i = 0
+      while i < msgs.size
+        msg = msgs[i]
+        result << msg
+
+        if msg[:role] == "assistant" && msg[:tool_calls].is_a?(Array) && !msg[:tool_calls].empty?
+          expected_ids = msg[:tool_calls].map { |tc| tc[:id] }.compact
+          seen_ids = []
+
+          j = i + 1
+          while j < msgs.size && tool_result_message?(msgs[j])
+            result << msgs[j]
+            seen_ids.concat(tool_result_ids(msgs[j]))
+            j += 1
+          end
+
+          (expected_ids - seen_ids).each do |id|
+            result << {
+              role: "tool",
+              tool_call_id: id,
+              content: '{"error":"Tool result missing (interrupted)"}'
+            }
+          end
+
+          i = j
+        else
+          i += 1
+        end
+      end
+      result
+    end
+
+    private def tool_result_message?(msg)
+      MessageFormat::OpenAI.tool_result_message?(msg) ||
+        MessageFormat::Anthropic.tool_result_message?(msg)
+    end
+
+    private def tool_result_ids(msg)
+      if MessageFormat::OpenAI.tool_result_message?(msg)
+        MessageFormat::OpenAI.tool_call_ids(msg)
+      else
+        MessageFormat::Anthropic.tool_use_ids(msg)
+      end
+    end
+
     # Detect thinking-mode providers purely from history content and pad
     # synthetic assistant messages with an empty reasoning_content when needed.
     #

data/lib/clacky/openai_stream_aggregator.rb

@@ -28,10 +28,25 @@ module Clacky
       @usage = nil
       @last_input_tokens = 0
       @last_output_tokens = 0
+      @parse_failures = 0
+      @frames_seen = 0
+      @bytes_seen = 0
+      @saw_done = false
+    end
+
+    attr_reader :parse_failures, :frames_seen, :bytes_seen
+
+    def saw_done?
+      @saw_done
     end
 
     def handle(data_str)
-      return if data_str == "[DONE]"
+      @bytes_seen += data_str.bytesize
+      if data_str == "[DONE]"
+        @saw_done = true
+        return
+      end
+      @frames_seen += 1
       data = parse_or_nil(data_str)
       return unless data
 
@@ -57,7 +72,7 @@ module Clacky
     def to_h
       tool_calls = @tool_calls.keys.sort.map do |idx|
         tc = @tool_calls[idx]
-        {
+        out = {
           "id"       => tc[:id],
           "type"     => tc[:type] || "function",
           "function" => {
@@ -65,6 +80,8 @@ module Clacky
             "arguments" => tc[:arguments].to_s
           }
         }
+        out["extra_content"] = tc[:extra_content] if tc[:extra_content]
+        out
       end
 
       message = {
@@ -89,11 +106,21 @@ module Clacky
         slot[:name] ||= fn["name"] if fn["name"]
         slot[:arguments] << fn["arguments"].to_s if fn["arguments"]
       end
+      slot[:extra_content] = tc["extra_content"] if tc["extra_content"]
     end
 
     private def parse_or_nil(s)
       JSON.parse(s)
-    rescue JSON::ParserError
+    rescue JSON::ParserError => e
+      @parse_failures += 1
+      if @parse_failures == 1
+        Clacky::Logger.warn("stream.parse_failure",
+          provider: "openai",
+          error: "#{e.class}: #{e.message}",
+          frame_head: s.to_s[0, 200],
+          frame_bytes: s.to_s.bytesize
+        )
+      end
       nil
     end
 

data/lib/clacky/providers.rb

@@ -39,18 +39,25 @@ module Clacky
           "abs-claude-haiku-4-5",
           "dsk-deepseek-v4-pro",
           "dsk-deepseek-v4-flash",
-          "or-gemini-3-1-pro"
+          "or-gemini-3-1-pro",
+          "or-gemini-3-5-flash"
         ],
         # Image generation models served by the openclacky platform
         # gateway. The gateway exposes a standard OpenAI-compatible
         # /v1/images/generations endpoint, so the same OpenAICompat
-        # provider class handles them. `or-` prefix mirrors the chat
-        # model naming — these are routed through the OpenRouter
-        # backend by the platform.
+        # provider class handles them. `or-` prefix is a routing alias
+        # only — the platform may dispatch to OpenRouter or Vertex AI
+        # (Gemini Nano Banana family) depending on the model.
         "image_models" => [
           "or-gemini-3-pro-image",
+          "or-gemini-3-1-flash-image",
           "or-gpt-image-2"
         ],
+        "image_model_aliases" => {
+          "or-gemini-3-pro-image"      => "Nano Banana Pro",
+          "or-gemini-3-1-flash-image"  => "Nano Banana 2",
+          "or-gpt-image-2"             => "GPT Image 2"
+        },
         "default_image_model" => "or-gpt-image-2",
         # Provider-level default: the Claude family served here is vision-capable.
         "capabilities" => { "vision" => true }.freeze,
@@ -65,20 +72,17 @@ module Clacky
         # Per-primary lite pairing: keys are "strong" primary models, values
         # are the lite sidekick to auto-inject when that primary is the
         # default. Lite is consumed by some subagents for cheap/fast work;
-        # weak models (haiku / v4-flash) ARE the lite tier themselves, so
-        # they're intentionally not listed here — no injection happens when
-        # the default model is already lite-class.
-        #
-        # or-gemini-3-1-pro is intentionally absent: Gemini has no lite
-        # sibling wired up (yet) on this provider; subagents using the
-        # Gemini default will just reuse it for lite work until we add one.
+        # weak models (haiku / v4-flash / 3-5-flash) ARE the lite tier
+        # themselves, so they're intentionally not listed here as keys —
+        # no injection happens when the default model is already lite-class.
         "lite_models" => {
           "abs-claude-opus-4-8"   => "abs-claude-haiku-4-5",
           "abs-claude-opus-4-7"   => "abs-claude-haiku-4-5",
           "abs-claude-opus-4-6"   => "abs-claude-haiku-4-5",
           "abs-claude-sonnet-4-6" => "abs-claude-haiku-4-5",
           "abs-claude-sonnet-4-5" => "abs-claude-haiku-4-5",
-          "dsk-deepseek-v4-pro"   => "dsk-deepseek-v4-flash"
+          "dsk-deepseek-v4-pro"   => "dsk-deepseek-v4-flash",
+          "or-gemini-3-1-pro"     => "or-gemini-3-5-flash"
         },
         # Fallback chain: if a model is unavailable, try the next one in order.
         # Keys are primary model names; values are the fallback model to use instead.
@@ -487,6 +491,30 @@ module Clacky
         preset&.dig("image_models") || []
       end
 
+      def image_model_aliases(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("image_model_aliases") || {}
+      end
+
+      def video_model_aliases(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("video_model_aliases") || {}
+      end
+
+      def audio_model_aliases(provider_id)
+        preset = PRESETS[provider_id]
+        preset&.dig("audio_model_aliases") || {}
+      end
+
+      def media_model_aliases(provider_id, kind)
+        case kind.to_s
+        when "image" then image_model_aliases(provider_id)
+        when "video" then video_model_aliases(provider_id)
+        when "audio" then audio_model_aliases(provider_id)
+        else {}
+        end
+      end
+
       # Video generation models — placeholder. No provider supports video
       # via Clacky yet; once they do, declare "video_models" alongside
       # "image_models" in the relevant PRESETS entry and this returns it.

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

@@ -181,6 +181,10 @@ module Clacky
               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?("@")
+                observe_text = content.strip
+                unless observe_text.empty?
+                  @on_message&.call({ platform: :dingtalk, chat_id: chat_id, user_id: sender_id, text: observe_text, observe_only: true })
+                end
                 return
               end
             end
@@ -188,7 +192,11 @@ module Clacky
             allowed = @config[:allowed_users]
             return if allowed && !allowed.empty? && !allowed.include?(sender_id)
 
-            text, files = extract_payload(data, robot_code)
+            text, files, unsupported = extract_payload(data, robot_code)
+            if unsupported
+              @on_message&.call({ platform: :dingtalk, chat_id: chat_id, unsupported: true })
+              return
+            end
             return if text.strip.empty? && files.empty?
 
             event = {
@@ -242,6 +250,7 @@ module Clacky
               end
             else
               Clacky::Logger.info("[dingtalk] unsupported msgtype=#{msgtype}, ignoring")
+              return ["", [], true]
             end
 
             [text, files]

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

@@ -142,7 +142,10 @@ module Clacky
                 Clacky::Logger.warn("[DiscordAdapter] bot_user_id unavailable; dropping group message")
                 return
               end
-              return unless mentioned_ids.include?(@bot_user_id)
+              unless mentioned_ids.include?(@bot_user_id)
+                @on_message&.call(event.merge(observe_only: true))
+                return
+              end
             end
 
             allowed_users = @config[:allowed_users]
@@ -153,7 +156,10 @@ module Clacky
             text  = strip_bot_mention(msg["content"].to_s, @bot_user_id)
             files = process_attachments(Array(msg["attachments"]), chat_id)
 
-            return if text.strip.empty? && files.empty?
+            if text.strip.empty? && files.empty?
+              @on_message&.call({ type: :message, platform: :discord, chat_id: chat_id, unsupported: true })
+              return
+            end
 
             event = {
               type: :message,

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

@@ -177,7 +177,11 @@ module Clacky
                 Clacky::Logger.warn("[feishu] bot_open_id unavailable; dropping group message to avoid spam")
                 return
               end
-              return unless Array(event[:mentioned_open_ids]).include?(bot_id)
+              unless Array(event[:mentioned_open_ids]).include?(bot_id)
+                user_name = @bot.fetch_user_name(event[:user_id])
+                @on_message&.call(event.merge(observe_only: true, user_name: user_name))
+                return
+              end
             end
 
             allowed_users = @config[:allowed_users]
@@ -185,6 +189,11 @@ module Clacky
               return unless allowed_users.include?(event[:user_id])
             end
 
+            if event[:unsupported]
+              @on_message&.call(event)
+              return
+            end
+
             # Download images and attach as file hashes
             image_files = []
             if event[:image_keys] && !event[:image_keys].empty?

data/lib/clacky/server/channel/adapters/feishu/bot.rb

@@ -42,6 +42,7 @@ module Clacky
             @domain = domain
             @token_cache = nil
             @token_expires_at = nil
+            @user_name_cache = {}
           end
 
           # Send plain text message
@@ -236,6 +237,17 @@ module Clacky
             nil
           end
 
+          def fetch_user_name(open_id)
+            return @user_name_cache[open_id] if @user_name_cache.key?(open_id)
+
+            name = get("/open-apis/contact/v3/users/#{open_id}", params: { user_id_type: "open_id" })
+                     .dig("data", "user", "name")
+            @user_name_cache[open_id] = name.to_s.strip.then { |n| n.empty? ? open_id : n }
+          rescue => e
+            Clacky::Logger.warn("[feishu] Failed to fetch user name for #{open_id}: #{e.message}")
+            @user_name_cache[open_id] = open_id
+          end
+
           # Get tenant access token (cached)
           # @return [String] Access token
           def tenant_access_token

data/lib/clacky/server/channel/adapters/feishu/message_parser.rb

@@ -56,8 +56,16 @@ module Clacky
             msg_type = message["message_type"]
             Clacky::Logger.info("[feishu] msg_type=#{msg_type} content=#{message["content"].to_s[0..300]}")
             unless %w[text image file post].include?(msg_type)
-              Clacky::Logger.info("[feishu] dropping unsupported msg_type=#{msg_type}")
-              return nil
+              Clacky::Logger.info("[feishu] unsupported msg_type=#{msg_type}")
+              chat_type = message["chat_type"] == "p2p" ? :direct : :group
+              return {
+                type:               :message,
+                platform:           :feishu,
+                chat_id:            message["chat_id"],
+                chat_type:          chat_type,
+                mentioned_open_ids: Array(message["mentions"]).filter_map { |m| m.dig("id", "open_id") },
+                unsupported:        true
+              }
             end
 
             content_raw = message["content"]
@@ -70,7 +78,7 @@ module Clacky
 
             case msg_type
             when "text"
-              text = strip_mentions(content["text"].to_s.strip)
+              text = resolve_mentions(content["text"].to_s.strip, message["mentions"])
               return nil if text.empty?
             when "image"
               image_keys = [content["image_key"]].compact
@@ -131,6 +139,18 @@ module Clacky
             text.gsub(/<at[^>]*>.*?<\/at>/, "").strip
           end
 
+          # Replace @_user_N placeholders in text with real display names from mentions array.
+          # Falls back to stripping unresolved placeholders via strip_mentions.
+          def resolve_mentions(text, mentions)
+            mapping = Array(mentions).each_with_object({}) do |m, h|
+              key  = m["key"].to_s
+              name = m.dig("name").to_s
+              h[key] = name unless key.empty? || name.empty?
+            end
+            result = text.gsub(/@_user_\d+/) { |k| mapping[k] ? "@#{mapping[k]}" : k }
+            strip_mentions(result).strip
+          end
+
           # Parse a Feishu post content body into text and image_keys.
           # post content structure from event payloads:
           #   {"title": "", "content": [[{tag, text, ...}, ...], ...]}

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

@@ -243,7 +243,13 @@ module Clacky
             text      = msg["text"].to_s
 
             if is_group
-              return unless group_mention?(msg, text)
+              unless group_mention?(msg, text)
+                observe_text = text.strip
+                unless observe_text.empty?
+                  @on_message&.call({ type: :message, platform: :telegram, chat_id: chat_id.to_s, user_id: user_id.to_s, text: observe_text, observe_only: true })
+                end
+                return
+              end
               text = strip_bot_mention(text)
             end
 
@@ -255,7 +261,11 @@ module Clacky
             files = collect_files(msg)
             caption = msg["caption"].to_s
             text = caption if text.empty? && !caption.empty?
-            return if text.strip.empty? && files.empty?
+
+            if text.strip.empty? && files.empty?
+              @on_message&.call({ type: :message, platform: :telegram, chat_id: chat_id.to_s, unsupported: true })
+              return
+            end
 
             event = {
               type:       :message,