openclacky 0.9.22 → 0.9.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 636621284dfcd7f7329f793bc80f2364f16a2777dedacd2fdf310b2a7f3be58a
-  data.tar.gz: 5f3a12e563e36445d3aa32ae050f5b759b204325323cac119b8692bea7d3657b
+  metadata.gz: 5338bcdeaf4b2aafed416365f56467a99a6107911b24df2bfe9d94d757d03528
+  data.tar.gz: 8e06f6ca6b0d5a0a9c70ab758fc13b2f84d755f7d61e30a9708fdadd4db82309
 SHA512:
-  metadata.gz: 23e59f8ae883ded129b4fee900c0ffdf6cec3ada4bd019e9a0243a3942abc70f5bbc8b9cc4830a34d7e66e22e4c663988295eed972ad1df63247c6f0bdbf1a68
-  data.tar.gz: 218bd984151af6f087c6ac44f3aa213e19ee30981a1a69484344cdbd00774611465fc3847ecfc0933243e2ae6277792116d96d0aed04b9148a9cfed14f09e14e
+  metadata.gz: 7862cd557ea5ba9e88184b314fd88fc820d1f4e0c5a9bbebbfcdee75f33301876aff7df7f13cf07eaa21c7fb47d0efa65e7f051c1641ced6c20d1142e9e52819
+  data.tar.gz: b33e3cc3331e70328d366a38b67e472c760eb6bbe4b5621532ee4ae60585303d9042c4953f29f31e4256f357765d8aafee2b3e69fa87f31c386f9310be790c46

data/CHANGELOG.md

@@ -7,6 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.24] - 2026-04-02
+
+### Added
+- **New session list & search in Web UI**: sidebar now shows full session history with real-time search — find any past conversation instantly
+- **Session type indicators**: sessions are labeled by type (chat / agent) so you can see at a glance what kind of interaction it was
+- **Image lightbox**: click any image in the chat to expand it full-screen with a clean overlay viewer
+- **Session history replay for streaming messages**: chunk-based (streaming) messages are now fully replayed when revisiting a past session
+- **Xiaomi AI provider**: added Xiaomi as a supported AI provider
+- **Chinese Bing web search**: web search now uses cn.bing.com for users in China, improving search relevance and reliability
+- **Auto-install system dependencies script**: agent can now automatically install missing system packages (Node, Python, etc.) via a bundled `install_system_deps.sh` script
+- **User message timestamps**: each user message now displays the time it was sent
+
+### Fixed
+- **Bedrock file attachments & partial cost tracking**: fixed file handling and cost accumulation for AWS Bedrock sessions
+- **Session name timestamp**: fixed incorrect timestamp display on session names
+- **New session scroll**: new sessions now correctly scroll to the latest message
+- **Feishu WebSocket client crash**: fixed a nil-reference error that caused the Feishu WS client to crash on reconnect
+
+## [0.9.23] - 2026-04-01
+
+### Improved
+- **API client model parameter propagation**: the Client class now accepts and uses an explicit model parameter, enabling better model detection and API routing across all client instantiation points (CLI, agent, subagent)
+- **Bedrock API detection**: improved detection of Bedrock Converse API usage by checking both API key prefix (ABSK) and model prefix (abs-), providing more robust handling of Bedrock models
+
+### Fixed
+- **CLI -c option model initialization**: fixed a bug where the CLI command with -c option was not passing the model name to the client, causing routing failures for certain providers
+
+### More
+- ClackyAI provider updated to use the latest model name format (abs- prefix)
+
 ## [0.9.22] - 2026-03-31
 
 ### Added

data/lib/clacky/agent/message_compressor_helper.rb

@@ -305,9 +305,11 @@ module Clacky
         return nil unless @session_id && @created_at
 
         # Messages being compressed = original minus system message minus recent messages
+        # Also exclude system-injected scaffolding (session context, memory prompts, etc.)
+        # — these are internal CLI metadata and must not appear in chunk MD or WebUI history.
         recent_set = recent_messages.to_a
         messages_to_archive = original_messages.reject do |m|
-          m[:role] == "system" || recent_set.include?(m)
+          m[:role] == "system" || m[:system_injected] || recent_set.include?(m)
         end
 
         return nil if messages_to_archive.empty?
@@ -374,9 +376,23 @@ module Clacky
             end
             lines << ""
             # Include tool calls summary if present
+            # Format: "_Tool calls: name | {args_json}_" so replay can restore args for WebUI display.
             if msg[:tool_calls]&.any?
-              tool_names = msg[:tool_calls].map { |tc| tc.dig(:function, :name) }.compact.join(", ")
-              lines << "_Tool calls: #{tool_names}_"
+              tc_parts = msg[:tool_calls].map do |tc|
+                name = tc.dig(:function, :name) || tc[:name] || ""
+                next nil if name.empty?
+
+                args_raw = tc.dig(:function, :arguments) || tc[:arguments] || {}
+                args = args_raw.is_a?(String) ? (JSON.parse(args_raw) rescue nil) : args_raw
+                if args.is_a?(Hash) && !args.empty?
+                  # Truncate large string values to keep chunk MD readable
+                  compact = args.transform_values { |v| v.is_a?(String) && v.length > 200 ? v[0..197] + "..." : v }
+                  "#{name} | #{compact.to_json}"
+                else
+                  name
+                end
+              end.compact
+              lines << "_Tool calls: #{tc_parts.join("; ")}_"
               lines << ""
             end
             lines << format_message_content(content) if content

data/lib/clacky/agent/session_serializer.rb

@@ -114,6 +114,7 @@ module Clacky
       # Replay conversation history by calling ui.show_* methods for each message.
       # Supports cursor-based pagination using created_at timestamps on user messages.
       # Each "round" starts at a user message and includes all subsequent assistant/tool messages.
+      # Compressed chunks (chunk_path on assistant messages) are transparently expanded.
       #
       # @param ui [Object] UI interface that responds to show_user_message, show_assistant_message, etc.
       # @param limit [Integer] Maximum number of rounds (user turns) to replay
@@ -147,9 +148,19 @@ module Clacky
             rounds << current_round
           elsif current_round
             current_round[:events] << msg
+          elsif msg[:compressed_summary] && msg[:chunk_path]
+            # Compressed summary sitting before any user rounds — expand it from chunk md
+            chunk_rounds = parse_chunk_md_to_rounds(msg[:chunk_path])
+            rounds.concat(chunk_rounds)
           end
         end
 
+        # Expand any compressed_summary assistant messages sitting inside a round's events.
+        # These occur when compression happened mid-round (rare) — expand them in-place.
+        rounds.each do |round|
+          round[:events].select! { |ev| !ev[:compressed_summary] }
+        end
+
         # Apply before-cursor filter: only rounds whose user message created_at < before
         if before
           rounds = rounds.select { |r| r[:user_msg][:created_at] && r[:user_msg][:created_at] < before }
@@ -193,6 +204,159 @@ module Clacky
         { has_more: has_more }
       end
 
+      # Parse a chunk MD file into an array of rounds compatible with replay_history.
+      # Each round is { user_msg: Hash, events: Array<Hash> }.
+      # Timestamps are synthesised from the chunk's archived_at, spread backwards.
+      # Recursively expands nested chunk references (compressed summary inside a chunk).
+      #
+      # @param chunk_path [String] Path to the chunk md file
+      # @return [Array<Hash>] rounds array (may be empty if file missing/unreadable)
+      private def parse_chunk_md_to_rounds(chunk_path)
+        return [] unless chunk_path && File.exist?(chunk_path.to_s)
+
+        raw = File.read(chunk_path.to_s, encoding: "utf-8")
+
+        # Parse YAML front matter to get archived_at for synthetic timestamps
+        archived_at = nil
+        if raw.start_with?("---")
+          fm_end = raw.index("\n---\n", 4)
+          if fm_end
+            fm_text = raw[4...fm_end]
+            fm_text.each_line do |line|
+              if line.start_with?("archived_at:")
+                archived_at = Time.parse(line.split(":", 2).last.strip) rescue nil
+              end
+            end
+          end
+        end
+        base_time = (archived_at || Time.now).to_f
+        chunk_dir = File.dirname(chunk_path.to_s)
+
+        # Split into sections by ## headings
+        sections = []
+        current_role       = nil
+        current_lines      = []
+        current_nested_chunk = nil  # chunk reference from a Compressed Summary heading
+
+        raw.each_line do |line|
+          stripped = line.chomp
+          if (m = stripped.match(/\A## Assistant \[Compressed Summary — original conversation at: (.+)\]/))
+            # Nested chunk reference — record it, treat as assistant section
+            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+            current_role         = "assistant"
+            current_lines        = []
+            current_nested_chunk = File.join(chunk_dir, m[1])
+          elsif stripped.match?(/\A## (User|Assistant)/)
+            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+            current_role         = stripped.match(/\A## (User|Assistant)/)[1].downcase
+            current_lines        = []
+            current_nested_chunk = nil
+          elsif stripped.match?(/\A### Tool Result:/)
+            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+            current_role         = "tool"
+            current_lines        = []
+            current_nested_chunk = nil
+          else
+            current_lines << line
+          end
+        end
+        sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+
+        # Remove front-matter / header noise sections (nil role or non-user/assistant/tool)
+        sections.select! { |s| %w[user assistant tool].include?(s[:role]) }
+
+        # Group into rounds: each user section starts a new round
+        rounds        = []
+        current_round = nil
+        round_index   = 0
+
+        sections.each do |sec|
+          text = sec[:lines].join.strip
+
+          # Nested chunk: expand it recursively, prepend before current rounds
+          if sec[:nested_chunk]
+            nested = parse_chunk_md_to_rounds(sec[:nested_chunk])
+            rounds = nested + rounds unless nested.empty?
+            # Also render its summary text as an assistant event in current round if any
+            if current_round && !text.empty?
+              current_round[:events] << { role: "assistant", content: text }
+            end
+            next
+          end
+
+          next if text.empty?
+
+          if sec[:role] == "user"
+            round_index += 1
+            # Synthetic timestamp: spread rounds backwards from archived_at
+            synthetic_ts = base_time - (sections.size - round_index) * 1.0
+            current_round = {
+              user_msg: {
+                role: "user",
+                content: text,
+                created_at: synthetic_ts,
+                _from_chunk: true
+              },
+              events: []
+            }
+            rounds << current_round
+          elsif current_round
+            if sec[:role] == "assistant"
+              # Detect "_Tool calls: ..._" lines — convert to tool_calls events
+              # so _replay_single_message renders them as tool group UI (same as live).
+              #
+              # Formats supported:
+              #   New: "_Tool calls: name | {"arg":"val"}; name2 | {"k":"v"}_"
+              #   Old: "_Tool calls: name1, name2_"  (backward compat)
+              remaining_lines = []
+              pending_tool_entries = []  # [{name:, args:}]
+
+              text.each_line do |line|
+                stripped = line.strip
+                if (m = stripped.match(/\A_Tool calls?:\s*(.+?)_?\z/i))
+                  raw = m[1]
+                  # New format uses ";" as separator between tools (each entry: "name | {json}")
+                  # Old format uses "," with no JSON part.
+                  entries = raw.include?(" | ") ? raw.split(/;\s*/) : raw.split(/,\s*/)
+                  entries.each do |entry|
+                    entry = entry.strip
+                    if (parts = entry.match(/\A(.+?)\s*\|\s*(\{.+\})\z/))
+                      tool_name = parts[1].strip
+                      args = JSON.parse(parts[2]) rescue {}
+                      pending_tool_entries << { name: tool_name, args: args }
+                    else
+                      pending_tool_entries << { name: entry, args: {} }
+                    end
+                  end
+                else
+                  remaining_lines << line
+                end
+              end
+
+              # Flush any plain text
+              plain_text = remaining_lines.join.strip
+              current_round[:events] << { role: "assistant", content: plain_text } unless plain_text.empty?
+
+              # Emit one synthetic tool_calls message per detected tool
+              pending_tool_entries.each do |entry|
+                current_round[:events] << {
+                  role: "assistant",
+                  content: "",
+                  tool_calls: [{ name: entry[:name], arguments: entry[:args] }]
+                }
+              end
+            else
+              current_round[:events] << { role: "tool", content: text }
+            end
+          end
+        end
+
+        rounds
+      rescue => e
+        Clacky::Logger.warn("parse_chunk_md_to_rounds failed for #{chunk_path}: #{e.message}")
+        []
+      end
+
 
       # Render a single non-user message into the UI.
       # Used by both the normal round-based replay and the compressed-session fallback.
@@ -328,12 +492,14 @@ module Clacky
           next unless block[:type] == "image_url"
 
           url = block.dig(:image_url, :url)
-          next unless url && url.start_with?("data:")
+          # image_path is stored at send-time so replay can reconstruct the image from tmp
+          path = block[:image_path]
+
+          next unless url&.start_with?("data:") || path
 
-          # Derive mime_type from the data URL prefix (e.g. "data:image/jpeg;base64,...")
-          mime_type = url[/\Adata:([^;]+);/, 1] || "image/jpeg"
+          mime_type = (url || "")[/\Adata:([^;]+);/, 1] || "image/jpeg"
           ext       = mime_type.split("/").last
-          { name: "image_#{idx + 1}.#{ext}", mime_type: mime_type, data_url: url }
+          { name: "image_#{idx + 1}.#{ext}", mime_type: mime_type, data_url: url, path: path }
         end
       end
     end

data/lib/clacky/agent.rb

@@ -131,6 +131,7 @@ module Clacky
         @client = Clacky::Client.new(
           @config.api_key,
           base_url: @config.base_url,
+          model: @config.model_name,
           anthropic_format: @config.anthropic_format?
         )
         # Update message compressor with new client and model
@@ -217,7 +218,9 @@ module Clacky
       all_disk_files = disk_files + downgraded
 
       # Format user message — text + inline vision images
-      user_content = format_user_content(user_input, vision_images.map { |v| v[:url] })
+      # Store the tmp path alongside the data_url so the history replay can
+      # reconstruct the image if the base64 was stripped (e.g. after compression).
+      user_content = format_user_content(user_input, vision_images.map { |v| { url: v[:url], path: v[:path] } })
 
       # Parse disk files — agent's responsibility, not the upload layer.
       # process_path runs the parser script and returns a FileRef with preview_path or parse_error.
@@ -923,6 +926,7 @@ module Clacky
       subagent_client = Clacky::Client.new(
         subagent_config.api_key,
         base_url: subagent_config.base_url,
+        model: subagent_config.model_name,
         anthropic_format: subagent_config.anthropic_format?
       )
 
@@ -1109,15 +1113,25 @@ module Clacky
 
     # Build user message content for LLM.
     # Returns plain String when no vision images; Array of content parts otherwise.
-    private def format_user_content(text, vision_urls)
-      vision_urls ||= []
+    # Build user message content for LLM.
+    # vision_images: Array of String (plain url) OR Hash { url:, path: }
+    # path is stored in the block so history replay can reconstruct the image
+    # from the tmp file when the base64 data_url is no longer available.
+    private def format_user_content(text, vision_images)
+      vision_images ||= []
 
-      return text if vision_urls.empty?
+      return text if vision_images.empty?
 
       content = []
       content << { type: "text", text: text } unless text.nil? || text.empty?
-      vision_urls.each do |url|
-        content << { type: "image_url", image_url: { url: url } }
+      vision_images.each do |img|
+        if img.is_a?(Hash)
+          block = { type: "image_url", image_url: { url: img[:url] } }
+          block[:image_path] = img[:path] if img[:path]
+          content << block
+        else
+          content << { type: "image_url", image_url: { url: img } }
+        end
       end
       content
     end
@@ -1154,7 +1168,8 @@ module Clacky
         "Today is #{Time.now.strftime('%Y-%m-%d, %A')}",
         "Current model: #{current_model}",
         os != :unknown ? "OS: #{Clacky::Utils::EnvironmentDetector.os_label}" : nil,
-        desktop ? "Desktop: #{desktop}" : nil
+        desktop ? "Desktop: #{desktop}" : nil,
+        "Working directory: #{@working_dir}"
       ].compact.join(". ")
 
       content = "[Session context: #{parts}]"

data/lib/clacky/agent_config.rb

@@ -325,9 +325,9 @@ module Clacky
       current_model&.dig("anthropic_format") || false
     end
 
-    # Check if current model uses AWS Bedrock API key (ABSK prefix)
+    # Check if current model uses Bedrock Converse API (ABSK key prefix or abs- model prefix)
     def bedrock?
-      Clacky::MessageFormat::Bedrock.bedrock_api_key?(api_key.to_s)
+      Clacky::MessageFormat::Bedrock.bedrock_api_key?(api_key.to_s, model_name.to_s)
     end
 
     # Add a new model configuration
@@ -434,6 +434,8 @@ module Clacky
       if data.is_a?(Array)
         # New format: top-level array of model configurations
         models = data.map do |m|
+          # Deep copy to avoid shared references between models
+          m = m.dup.transform_values { |v| v.is_a?(String) ? v.dup : v }
           # Convert old name-based format to new model-based format if needed
           if m["name"] && !m["model"]
             m["model"] = m["name"]

data/lib/clacky/cli.rb

@@ -84,7 +84,7 @@ module Clacky
       agent_config.verbose = options[:verbose] if options[:verbose]
 
       # Create client for current model
-      client = Clacky::Client.new(agent_config.api_key, base_url: agent_config.base_url, anthropic_format: agent_config.anthropic_format?)
+      client = Clacky::Client.new(agent_config.api_key, base_url: agent_config.base_url, model: agent_config.model_name, anthropic_format: agent_config.anthropic_format?)
 
       # Resolve agent profile name from --agent option
       agent_profile = options[:agent] || "coding"
@@ -137,6 +137,7 @@ module Clacky
           test_client = Clacky::Client.new(
             test_config.api_key,
             base_url: test_config.base_url,
+            model: test_config.model_name,
             anthropic_format: test_config.anthropic_format?
           )
 
@@ -162,6 +163,7 @@ module Clacky
         agent.instance_variable_set(:@client, Clacky::Client.new(
           config.api_key,
           base_url: config.base_url,
+          model: config.model_name,
           anthropic_format: config.anthropic_format?
         ))
 
@@ -829,6 +831,7 @@ module Clacky
           Clacky::Client.new(
             agent_config.api_key,
             base_url: agent_config.base_url,
+            model: agent_config.model_name,
             anthropic_format: agent_config.anthropic_format?
           )
         end

data/lib/clacky/client.rb

@@ -8,13 +8,13 @@ module Clacky
     MAX_RETRIES = 10
     RETRY_DELAY = 5 # seconds
 
-    def initialize(api_key, base_url:, model: nil, anthropic_format: false)
+    def initialize(api_key, base_url:, model:, anthropic_format: false)
       @api_key = api_key
       @base_url = base_url
       @model = model
       @use_anthropic_format = anthropic_format
-      # Detect Bedrock API key by ABSK prefix — overrides anthropic_format routing
-      @use_bedrock = MessageFormat::Bedrock.bedrock_api_key?(api_key)
+      # Detect Bedrock: ABSK key prefix (native AWS) or abs- model prefix (Clacky AI proxy)
+      @use_bedrock = MessageFormat::Bedrock.bedrock_api_key?(api_key, model)
     end
 
     # Returns true when the client is using the AWS Bedrock Converse API.

data/lib/clacky/message_format/anthropic.rb

@@ -168,6 +168,8 @@ module Clacky
         #      user message as a cache breakpoint, which invalidates the intended cache boundary
         #      and results in cache misses (cache_read=0) every turn.
         blocks = content_to_blocks(content)
+        # Anthropic rejects messages with an empty content array — use a placeholder text block.
+        blocks = [{ type: "text", text: "..." }] if blocks.empty?
         { role: role, content: blocks }
       end
 
@@ -176,11 +178,17 @@ module Clacky
       private_class_method def self.content_to_blocks(content)
         case content
         when String
+          # Anthropic rejects blank text blocks — skip empty strings
+          return [] if content.empty?
+
           [{ type: "text", text: content }]
         when Array
           content.map { |b| normalize_block(b) }.compact
         else
-          [{ type: "text", text: content.to_s }]
+          str = content.to_s
+          return [] if str.empty?
+
+          [{ type: "text", text: str }]
         end
       end
 
@@ -190,8 +198,12 @@ module Clacky
 
         case block[:type]
         when "text"
+          # Anthropic rejects blank text blocks — drop them instead of sending { type:"text", text:"" }
+          text = block[:text]
+          return nil if text.nil? || text.empty?
+
           # Preserve cache_control if present (placed by Client#apply_message_caching)
-          result = { type: "text", text: block[:text] }
+          result = { type: "text", text: text }
           result[:cache_control] = block[:cache_control] if block[:cache_control]
           result
         when "image_url"

data/lib/clacky/message_format/bedrock.rb

@@ -16,9 +16,12 @@ module Clacky
     #
     # This module converts canonical format ↔ Bedrock Converse API format.
     module Bedrock
-      # Detect if the API key is an AWS Bedrock API key (ABSK prefix)
-      def self.bedrock_api_key?(api_key)
-        api_key.to_s.start_with?("ABSK")
+      # Detect if the request should use the Bedrock Converse API.
+      # Matches either:
+      #   - API key with "ABSK" prefix (native AWS Bedrock)
+      #   - Model ID with "abs-" prefix (Clacky AI proxy that speaks Bedrock Converse)
+      def self.bedrock_api_key?(api_key, model)
+        api_key.to_s.start_with?("ABSK") || model.to_s.start_with?("abs-")
       end
 
       module_function
@@ -177,6 +180,8 @@ module Clacky
 
         # regular user/assistant message
         blocks = content_to_blocks(content)
+        # Bedrock rejects messages with an empty content array — use a placeholder text block.
+        blocks = [{ text: "..." }] if blocks.empty?
         { role: role, content: blocks }
       end
 
@@ -184,11 +189,17 @@ module Clacky
       private_class_method def self.content_to_blocks(content)
         case content
         when String
+          # Bedrock rejects blank text blocks — skip empty strings
+          return [] if content.empty?
+
           [{ text: content }]
         when Array
           content.map { |b| normalize_block(b) }.compact
         else
-          [{ text: content.to_s }]
+          str = content.to_s
+          return [] if str.empty?
+
+          [{ text: str }]
         end
       end
 
@@ -198,7 +209,11 @@ module Clacky
 
         case block[:type]
         when "text"
-          { text: block[:text].to_s }
+          # Bedrock rejects blank text blocks — drop them
+          text = block[:text].to_s
+          return nil if text.empty?
+
+          { text: text }
         when "image_url"
           # Bedrock image format — base64 only
           url = block.dig(:image_url, :url) || block[:url]

data/lib/clacky/providers.rb

@@ -49,15 +49,25 @@ module Clacky
       }.freeze,
 
       "clackyai" => {
-        "name" => "Clacky AI",
+        "name" => "ClackyAI",
         "base_url" => "https://api.clacky.ai",
         "api" => "bedrock",
-        "default_model" => "jp.anthropic.claude-sonnet-4-6",
+        "default_model" => "abs-claude-sonnet-4-6",
         "models" => [
-          "jp.anthropic.claude-sonnet-4-6",
-          "jp.anthropic.claude-haiku-4-6"
+          "abs-claude-opus-4-6",
+          "abs-claude-sonnet-4-6",
+          "abs-claude-haiku-4-5"
         ],
         "website_url" => "https://clacky.ai"
+      }.freeze,
+
+      "mimo" => {
+        "name" => "MiMo (Xiaomi)",
+        "base_url" => "https://api.xiaomimimo.com/v1",
+        "api" => "openai-completions",
+        "default_model" => "mimo-v2-pro",
+        "models" => ["mimo-v2-pro", "mimo-v2-omni"],
+        "website_url" => "https://platform.xiaomimimo.com/"
       }.freeze
 
     }.freeze

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

@@ -160,6 +160,12 @@ module Clacky
             @ping_interval = (client_config["PingInterval"] || 90).to_i
 
             url = data.dig("data", "URL")
+            if url.nil? || url.strip.empty?
+              Clacky::Logger.error("[feishu-ws] WebSocket endpoint URL is missing from response. " \
+                                   "Please verify your Feishu App ID and App Secret are correct.")
+              raise "Failed to get WebSocket endpoint: URL is missing (check your Feishu App ID / App Secret)"
+            end
+
             if url =~ /service_id=(\d+)/
               @service_id = $1.to_i
             end