kward 0.68.0 → 0.69.0

data/lib/kward/model/stream_parser.rb

@@ -191,6 +191,7 @@ module Kward
       when "Edit" then "edit_file"
       when "Bash" then "run_shell_command"
       when "WebSearch" then "web_search"
+      when "WebFetch" then "fetch_content"
       when "AskUserQuestion" then "ask_user_question"
       else name.to_s
       end
@@ -218,7 +219,18 @@ module Kward
     end
 
     def codex_sse_state
-      { content: +"", reasoning_summary: +"", tool_calls: [], final_output: [], usage: nil }
+      {
+        content: +"",
+        raw_content: +"",
+        emitted_message_keys: [],
+        reasoning_summary: +"",
+        tool_calls: [],
+        response_item_keys: [],
+        items_by_id: {},
+        active_item_id: nil,
+        current_text_content_part: nil,
+        usage: nil
+      }
     end
 
     def process_codex_sse_block(block, state, on_reasoning_delta: nil, on_assistant_delta: nil, usage_normalizer: nil, request_error_class: nil)
@@ -227,30 +239,33 @@ module Kward
 
       event = JSON.parse(data)
       case event["type"]
-      when "response.output_text.delta"
-        delta = event["delta"].to_s
-        state[:content] << delta
-        on_assistant_delta&.call(delta)
+      when "response.output_item.added"
+        codex_output_item_added(state, event["item"])
+      when "response.content_part.added"
+        codex_content_part_added(state, event["part"])
+      when "response.output_text.delta", "response.refusal.delta"
+        codex_output_text_delta(state, event["delta"], on_assistant_delta: on_assistant_delta)
+      when "response.reasoning_summary_part.added"
+        codex_reasoning_summary_part_added(state, event["part"])
       when "response.reasoning_summary_text.delta"
-        delta = event["delta"].to_s
-        state[:reasoning_summary] << delta
-        on_reasoning_delta&.call(delta)
+        codex_reasoning_delta(state, event["delta"], on_reasoning_delta: on_reasoning_delta)
+      when "response.reasoning_summary_part.done"
+        codex_reasoning_part_done(state, on_reasoning_delta: on_reasoning_delta)
+      when "response.reasoning_text.delta"
+        codex_reasoning_delta(state, event["delta"], on_reasoning_delta: on_reasoning_delta)
+      when "response.function_call_arguments.delta", "response.custom_tool_call_input.delta"
+        codex_tool_arguments_delta(state, event["delta"])
+      when "response.function_call_arguments.done"
+        codex_tool_arguments_done(state, event["arguments"])
       when "response.output_item.done"
-        item = event["item"]
-        state[:final_output] << item if item.is_a?(Hash)
-        tool_call = codex_tool_call(item)
-        state[:tool_calls] << tool_call if tool_call
+        codex_output_item_done(state, event["item"], on_assistant_delta: on_assistant_delta, on_reasoning_delta: on_reasoning_delta)
       when "response.completed"
         response = event["response"]
         state[:usage] ||= usage_normalizer&.call(response["usage"]) if response.is_a?(Hash)
         state[:usage] ||= usage_normalizer&.call(event["usage"])
-        if state[:content].empty? && response.is_a?(Hash) && response["output"].is_a?(Array)
-          state[:final_output] = response["output"]
-          text = text_from_codex_items(state[:final_output])
-          state[:content] << text
-          on_assistant_delta&.call(text) unless text.empty?
-          if state[:reasoning_summary].empty?
-            state[:reasoning_summary] << reasoning_summary_from_codex_items(state[:final_output])
+        if response.is_a?(Hash) && response["output"].is_a?(Array) && state[:response_item_keys].empty?
+          response["output"].each do |item|
+            codex_output_item_done(state, item, on_assistant_delta: on_assistant_delta, on_reasoning_delta: on_reasoning_delta)
           end
         end
       when "response.failed", "response.incomplete"
@@ -275,21 +290,239 @@ module Kward
       end
     end
 
-    def codex_sse_message(state)
-      if state[:tool_calls].empty?
-        state[:final_output].each do |item|
-          tool_call = codex_tool_call(item)
-          state[:tool_calls] << tool_call if tool_call
+    def codex_output_item_added(state, item)
+      return unless item.is_a?(Hash)
+
+      item = deep_dup_hash(item)
+      item["content"] = [] if item["type"] == "message" && !item["content"].is_a?(Array)
+      item["summary"] = [] if item["type"] == "reasoning" && !item["summary"].is_a?(Array)
+      remember_codex_item(state, item)
+      state[:active_item_id] = codex_item_key(item)
+      state[:current_text_content_part] = nil
+    end
+
+    def codex_content_part_added(state, part)
+      item = active_codex_item(state)
+      return unless item&.fetch("type", nil) == "message" && part.is_a?(Hash)
+      return unless ["output_text", "text", "refusal"].include?(part["type"])
+
+      item["content"] ||= []
+      item["content"] << deep_dup_hash(part)
+      state[:current_text_content_part] = item["content"].last
+    end
+
+    def codex_output_text_delta(state, delta, on_assistant_delta: nil)
+      text = delta.to_s
+      return if text.empty?
+
+      item = active_codex_item(state)
+      if item&.fetch("type", nil) == "message"
+        item["content"] ||= [{ "type" => "output_text", "text" => +"" }]
+        part = state[:current_text_content_part] || item["content"].last
+        part = item["content"].last unless part.is_a?(Hash)
+        part["type"] ||= "output_text"
+        text_key = part["type"] == "refusal" ? "refusal" : "text"
+        part[text_key] = part[text_key].to_s + text
+      end
+      state[:raw_content] << text
+    end
+
+    def codex_reasoning_summary_part_added(state, part)
+      item = active_codex_item(state)
+      return unless item&.fetch("type", nil) == "reasoning" && part.is_a?(Hash)
+
+      item["summary"] ||= []
+      item["summary"] << deep_dup_hash(part)
+    end
+
+    def codex_reasoning_delta(state, delta, on_reasoning_delta: nil)
+      text = delta.to_s
+      return if text.empty?
+
+      item = active_codex_item(state)
+      if item&.fetch("type", nil) == "reasoning"
+        item["summary"] ||= []
+        item["summary"] << { "type" => "summary_text", "text" => +"" } if item["summary"].empty?
+        item["summary"].last["text"] = item["summary"].last["text"].to_s + text
+      end
+      state[:reasoning_summary] << text
+      on_reasoning_delta&.call(text)
+    end
+
+    def codex_reasoning_part_done(state, on_reasoning_delta: nil)
+      item = active_codex_item(state)
+      return unless item&.fetch("type", nil) == "reasoning"
+      return if item["summary"].to_a.empty?
+
+      text = "\n\n"
+      item["summary"].last["text"] = item["summary"].last["text"].to_s + text
+      state[:reasoning_summary] << text
+      on_reasoning_delta&.call(text)
+    end
+
+    def codex_tool_arguments_delta(state, delta)
+      item = active_codex_item(state)
+      return unless item && ["function_call", "custom_tool_call"].include?(item["type"])
+
+      key = item["type"] == "custom_tool_call" ? "input" : "arguments"
+      item[key] = item[key].to_s + delta.to_s
+    end
+
+    def codex_tool_arguments_done(state, arguments)
+      item = active_codex_item(state)
+      return unless item&.fetch("type", nil) == "function_call"
+
+      item["arguments"] = arguments.to_s
+    end
+
+    def codex_output_item_done(state, item, on_assistant_delta: nil, on_reasoning_delta: nil)
+      return unless item.is_a?(Hash)
+
+      item = merge_codex_item(active_or_known_codex_item(state, item), item)
+      remember_codex_item(state, item)
+      collect_codex_item_output(state, item, on_assistant_delta: on_assistant_delta, on_reasoning_delta: on_reasoning_delta)
+      state[:active_item_id] = nil if state[:active_item_id] == codex_item_key(item)
+      state[:current_text_content_part] = nil
+    end
+
+    def collect_codex_item_output(state, item, on_assistant_delta: nil, on_reasoning_delta: nil)
+      case item["type"]
+      when "message"
+        text = text_from_codex_items([item])
+        return if text.empty? || !codex_streamable_message_item?(item)
+
+        state[:content] << text
+        key = codex_item_key(item)
+        unless state[:emitted_message_keys].include?(key)
+          on_assistant_delta&.call(text)
+          state[:emitted_message_keys] << key
         end
+      when "reasoning"
+        text = reasoning_summary_from_codex_items([item])
+        if state[:reasoning_summary].empty? && !text.empty?
+          state[:reasoning_summary] << text
+          on_reasoning_delta&.call(text)
+        end
+      when "function_call", "custom_tool_call"
+        tool_call = codex_tool_call(item)
+        state[:tool_calls] << tool_call if tool_call && !state[:tool_calls].any? { |call| call["id"] == tool_call["id"] }
       end
+    end
 
-      message = { "role" => "assistant", "content" => state[:content] }
+    def active_or_known_codex_item(state, item)
+      key = codex_item_key(item)
+      known = state[:items_by_id][key]
+      return known if known
+
+      active = active_codex_item(state)
+      return active if active && (!codex_item_has_stable_key?(item) || codex_item_key(active) == key)
+
+      nil
+    end
+
+    def codex_item_has_stable_key?(item)
+      item.key?("id") || item.key?("call_id")
+    end
+
+    def active_codex_item(state)
+      key = state[:active_item_id]
+      key ? state[:items_by_id][key] : nil
+    end
+
+    def remember_codex_item(state, item)
+      key = codex_item_key(item)
+      if state[:items_by_id].key?(key)
+        stored = state[:items_by_id][key]
+        stored.replace(merge_codex_item(stored, item))
+      else
+        state[:items_by_id][key] = item
+        state[:response_item_keys] << key
+      end
+    end
+
+    def codex_item_key(item)
+      item["id"] || item["call_id"] || "item_#{item.object_id}"
+    end
+
+    def merge_codex_item(existing, update)
+      return deep_dup_hash(update) unless existing.is_a?(Hash)
+
+      merged = deep_dup_hash(existing)
+      update.each do |key, value|
+        next if value.nil?
+
+        merged[key] = if key == "content" && merged[key].is_a?(Array) && value.is_a?(Array)
+                        value.empty? ? merged[key] : value
+                      elsif key == "summary" && merged[key].is_a?(Array) && value.is_a?(Array)
+                        value.empty? ? merged[key] : value
+                      elsif key == "arguments" && value.to_s.empty? && !merged[key].to_s.empty?
+                        merged[key]
+                      else
+                        deep_dup(value)
+                      end
+      end
+      merged
+    end
+
+    def deep_dup_hash(hash)
+      deep_dup(hash)
+    end
+
+    def deep_dup(value)
+      case value
+      when Hash
+        value.each_with_object({}) { |(key, entry), result| result[key] = deep_dup(entry) }
+      when Array
+        value.map { |entry| deep_dup(entry) }
+      when String
+        value.dup
+      else
+        value
+      end
+    end
+
+    def codex_sse_message(state)
+      message = { "role" => "assistant", "content" => codex_visible_content(state) }
       message["reasoning_summary"] = state[:reasoning_summary] unless state[:reasoning_summary].empty?
       message["tool_calls"] = state[:tool_calls] unless state[:tool_calls].empty?
+      response_items = codex_response_items(state)
+      message["response_items"] = response_items unless response_items.empty?
       message["usage"] = state[:usage] if state[:usage]
       message
     end
 
+    def codex_visible_content(state)
+      return state[:content] unless state[:content].empty?
+
+      response_items = codex_response_items(state)
+      visible_text = text_from_codex_items(visible_codex_message_items(response_items, tool_calls: state[:tool_calls]))
+      return visible_text unless visible_text.empty?
+      return "" unless state[:tool_calls].empty?
+
+      state[:raw_content]
+    end
+
+    def visible_codex_message_items(items, tool_calls: [])
+      messages = Array(items).select { |item| item.is_a?(Hash) && item["type"] == "message" }
+      final_messages = messages.select { |item| codex_message_phase(item) == "final_answer" }
+      return final_messages unless final_messages.empty?
+      return [] unless tool_calls.empty?
+
+      messages.reject { |item| codex_message_phase(item) == "commentary" }
+    end
+
+    def codex_streamable_message_item?(item)
+      codex_message_phase(item) == "final_answer"
+    end
+
+    def codex_message_phase(item)
+      item["phase"].to_s
+    end
+
+    def codex_response_items(state)
+      state[:response_item_keys].filter_map { |key| state[:items_by_id][key] }
+    end
+
     def codex_tool_call(item)
       return nil unless item.is_a?(Hash) && ["function_call", "custom_tool_call"].include?(item["type"])
 

data/lib/kward/prompt_interface/question_prompt.rb

@@ -320,7 +320,7 @@ module Kward
       end
 
       def display_question_input(value)
-        value.to_s.gsub(/\s+/, " ").strip
+        value.to_s.gsub(/\s+/, " ")
       end
 
     end

data/lib/kward/prompt_interface/transcript_renderer.rb

@@ -11,7 +11,7 @@ module Kward
           prepare_transcript_output_locked unless @restoring_transcript
           if label && @stream_state.block != label
             ensure_transcript_block_separator_locked
-            write_transcript_text_locked("#{colored("#{transcript_label(label)}>", label_color(label), :bold)}\n")
+            write_transcript_text_locked("#{colored("#{transcript_label(label)}>", *label_styles(label))}\n")
             @stream_state.start_block(label)
           end
           write_transcript_text_locked(delta) unless delta.empty?
@@ -119,21 +119,30 @@ module Kward
       end
 
       def transcript_label(label)
-        label == "Assistant" ? @assistant_label : label
+        case label
+        when "Assistant"
+          @assistant_label
+        when "Tool failed"
+          "Tool"
+        else
+          label
+        end
       end
 
-      def label_color(label)
+      def label_styles(label)
         case label
-        when "Reasoning"
-          :yellow
+        when "Reasoning", "Compaction summary"
+          [:gray, :bold]
         when "Assistant", "Kward"
-          :green
-        when "Tool"
-          :magenta
-        when "Tool output"
-          :cyan
+          [:green, :bold]
+        when "Tool", "Tool output"
+          [:cyan, :bold]
+        when "Tool failed"
+          [:red, :bold]
+        when "Retry"
+          [:yellow, :bold]
         else
-          :blue
+          [:gray, :bold]
         end
       end
 

data/lib/kward/prompts.rb

@@ -14,18 +14,27 @@ module Kward
     end
 
     def prompt_parts(workspace_root: Dir.pwd, include_workspace_personality: true, model: nil, reasoning_effort: nil, now: Time.now, memory_context: nil, plugin_context: nil)
-      parts = [base_prompt, config_agents_prompt]
-      parts << memory_context unless memory_context.to_s.empty?
-      parts << persona_prompt(workspace_root, model: model, reasoning_effort: reasoning_effort, now: now) if include_workspace_personality
-      parts << plugin_context unless plugin_context.to_s.empty? || !include_workspace_personality
-      parts << skills_prompt
-      parts << workspace_agents_prompt(workspace_root)
-      parts
+      prompt_sections(workspace_root: workspace_root, include_workspace_personality: include_workspace_personality, model: model, reasoning_effort: reasoning_effort, now: now, memory_context: memory_context, plugin_context: plugin_context).map { |section| section[:content] }
+    end
+
+    def prompt_sections(workspace_root: Dir.pwd, include_workspace_personality: true, model: nil, reasoning_effort: nil, now: Time.now, memory_context: nil, plugin_context: nil)
+      sections = [prompt_section("Built-in system prompt", base_prompt)]
+      sections << prompt_section(config_agents_prompt_label, config_agents_prompt, source: config_agents_prompt_source)
+      sections << prompt_section("Memory context", memory_context) unless memory_context.to_s.empty?
+      if include_workspace_personality
+        sections << prompt_section("Persona", persona_prompt(workspace_root, model: model, reasoning_effort: reasoning_effort, now: now))
+        sections << prompt_section("Plugin context", plugin_context) unless plugin_context.to_s.empty?
+      end
+      sections << prompt_section("Configured skills", skills_prompt, source: ConfigFiles.skills.empty? ? nil : File.join(ConfigFiles.config_dir, "skills"))
+      sections << prompt_section(workspace_agents_context_label(workspace_root), workspace_agents_context(workspace_root), source: ConfigFiles.workspace_agents_file?(workspace_root) ? ConfigFiles.workspace_agents_path(workspace_root) : nil)
+      sections.compact
     end
 
     def base_prompt
       <<~PROMPT.strip
         You are Kward, a concise practical CLI coding agent. You are allowed to use the tools. Help users understand and modify software projects. Inspect files before changing them, make the smallest correct change, preserve existing style, and summarize what changed. Be honest about limitations.
+
+        For web research, use web_search to discover sources, then fetch_content for important human-readable pages before relying on them. Use fetch_raw for machine-readable resources such as JSON, YAML, XML, RSS, OpenAPI specs, and plain text. Prefer official or primary sources when practical, and cite or mention the URLs you relied on.
       PROMPT
     end
 
@@ -33,14 +42,59 @@ module Kward
       ConfigFiles.agents_prompt
     end
 
+    def config_agents_prompt_label
+      return "Config principles" if File.exist?(ConfigFiles.config_principles_path)
+      return "Config AGENTS.md alias" if File.exist?(ConfigFiles.config_agents_path)
+
+      "Config principles"
+    end
+
+    def config_agents_prompt_source
+      return ConfigFiles.config_principles_path if File.exist?(ConfigFiles.config_principles_path)
+      return ConfigFiles.config_agents_path if File.exist?(ConfigFiles.config_agents_path)
+
+      nil
+    end
+
     def persona_prompt(workspace_root = Dir.pwd, model: nil, reasoning_effort: nil, now: Time.now)
       ConfigFiles.persona_prompt(workspace_root, model: model, reasoning_effort: reasoning_effort, now: now)
     end
 
+    def workspace_agents_context(workspace_root = Dir.pwd)
+      if ConfigFiles.enforce_workspace_agents_file?
+        ConfigFiles.workspace_agents_prompt(workspace_root)
+      else
+        workspace_agents_hint(workspace_root)
+      end
+    end
+
     def workspace_agents_prompt(workspace_root = Dir.pwd)
       ConfigFiles.workspace_agents_prompt(workspace_root)
     end
 
+    def workspace_agents_hint(workspace_root = Dir.pwd)
+      return nil unless ConfigFiles.workspace_agents_file?(workspace_root)
+
+      path = ConfigFiles.workspace_agents_path(workspace_root)
+      <<~PROMPT.strip
+        Workspace guidance is available in AGENTS.md at the workspace root: #{path}
+        For tasks involving this repository, read it before analyzing or modifying project files, and follow it when it does not conflict with higher-priority instructions or the user's request.
+      PROMPT
+    end
+
+    def workspace_agents_context_label(workspace_root = Dir.pwd)
+      return "Workspace AGENTS.md" unless ConfigFiles.workspace_agents_file?(workspace_root)
+      return "Workspace AGENTS.md" if ConfigFiles.enforce_workspace_agents_file?
+
+      "Workspace AGENTS.md hint"
+    end
+
+    def prompt_section(label, content, source: nil)
+      return nil if content.to_s.empty?
+
+      { label: label, content: content, source: source }
+    end
+
     def skills_prompt
       skills = ConfigFiles.skills
       return nil if skills.empty?

data/lib/kward/rpc/server.rb

@@ -560,8 +560,13 @@ module Kward
       def startup_resources(params)
         @session_manager.runtime_state(session_id: params.fetch("sessionId"))
         sections = []
-        agents_path = File.join(ConfigFiles.config_dir, "AGENTS.md")
-        sections << { name: "Context", items: ["AGENTS.md"] } if File.exist?(agents_path)
+        context_items = []
+        if File.exist?(ConfigFiles.config_principles_path)
+          context_items << "PRINCIPLES.md"
+        elsif File.exist?(ConfigFiles.config_agents_path)
+          context_items << "AGENTS.md"
+        end
+        sections << { name: "Context", items: context_items } unless context_items.empty?
         skills = ConfigFiles.skills.map(&:name)
         prompts = ConfigFiles.prompt_templates(reserved_commands: BUILTIN_SLASH_COMMAND_NAMES).map { |template| "/#{template.command}" }
         plugins = @session_manager.plugin_commands.map { |command| "/#{command.name}" }

data/lib/kward/rpc/session_manager.rb

@@ -576,7 +576,13 @@ module Kward
         sessions.each do |rpc_session|
           rpc_session.conversation.plugin_registry = registry if rpc_session.conversation.respond_to?(:plugin_registry=)
           rpc_session.conversation.refresh_system_message! if rpc_session.conversation.respond_to?(:refresh_system_message!)
-          emit_footer_update(rpc_session)
+          if registry.footer_renderer
+            start_footer_worker(rpc_session)
+            emit_footer_update(rpc_session)
+          else
+            stop_footer_worker(rpc_session)
+            clear_footer_update(rpc_session)
+          end
         end
       end
 
@@ -1140,7 +1146,7 @@ module Kward
 
       def emit_footer_update(rpc_session)
         renderer = plugin_registry.footer_renderer
-        return unless renderer
+        return clear_footer_update(rpc_session) unless renderer
 
         text = begin
           context = PluginRegistry::Context.new(
@@ -1160,6 +1166,13 @@ module Kward
         @server.notify("ui/footer", { sessionId: rpc_session.id, text: text })
       end
 
+      def clear_footer_update(rpc_session)
+        return if rpc_session.last_footer_text.to_s.empty?
+
+        rpc_session.last_footer_text = ""
+        @server.notify("ui/footer", { sessionId: rpc_session.id, text: "" })
+      end
+
       def emit_turn_event(turn, type, payload)
         event = {
           sequence: turn.next_sequence,
@@ -1210,6 +1223,9 @@ module Kward
           name: info.name,
           firstMessage: info.first_message.to_s,
           messageCount: info.message_count.to_i,
+          provider: info.provider,
+          model: info.model,
+          reasoningEffort: info.reasoning_effort,
           parentId: info.parent_id,
           parentPath: info.parent_path,
           depth: info.depth.to_i,

data/lib/kward/rpc/session_metrics.rb

@@ -34,12 +34,12 @@ module Kward
 
       def context_usage(rpc_session, model, client:)
         context_parts = if client.respond_to?(:current_context_parts)
-                          client.current_context_parts(rpc_session.conversation.messages, rpc_session.tool_registry.schemas)
+                          client.current_context_parts(rpc_session.conversation.context_messages, rpc_session.tool_registry.schemas)
                         else
                           {
                             provider: model[:provider],
                             model: model[:id],
-                            messages: rpc_session.conversation.messages,
+                            messages: rpc_session.conversation.context_messages,
                             tools: rpc_session.tool_registry.schemas
                           }
                         end

data/lib/kward/rpc/transcript_normalizer.rb

@@ -61,6 +61,7 @@ module Kward
 
       def normalize_assistant_message(message)
         content = reasoning_first_content(normalize_content(ToolCall.value(message, :content), preserve_thinking: true))
+        content = response_item_content(message) if text_content_empty?(content)
         reasoning = normalize_reasoning_summary(message)
         content.unshift(reasoning) if reasoning && !thinking_content?(content)
         tool_calls(message).each do |tool_call|
@@ -154,6 +155,52 @@ module Kward
         summary.to_s.empty? ? nil : { type: "thinking", thinking: summary.to_s }
       end
 
+      def response_item_content(message)
+        response_items(message).filter_map do |item|
+          next unless item.is_a?(Hash)
+
+          case ToolCall.value(item, :type).to_s
+          when "reasoning"
+            thinking = reasoning_item_text(item)
+            { type: "thinking", thinking: thinking } unless thinking.empty?
+          when "message"
+            next if ToolCall.value(item, :phase).to_s == "commentary"
+
+            text = response_message_item_text(item)
+            { type: "text", text: text } unless text.empty?
+          end
+        end
+      end
+
+      def response_items(message)
+        items = ToolCall.value(message, :response_items) || ToolCall.value(message, :responseItems)
+        items.is_a?(Array) ? items : []
+      end
+
+      def reasoning_item_text(item)
+        summary = ToolCall.value(item, :summary)
+        content = ToolCall.value(item, :content)
+        response_text_parts(summary).empty? ? response_text_parts(content).join("\n\n") : response_text_parts(summary).join("\n\n")
+      end
+
+      def response_message_item_text(item)
+        response_text_parts(ToolCall.value(item, :content)).join
+      end
+
+      def response_text_parts(parts)
+        Array(parts).filter_map do |part|
+          next unless part.is_a?(Hash)
+
+          ToolCall.value(part, :text) || ToolCall.value(part, :refusal)
+        end.map(&:to_s)
+      end
+
+      def text_content_empty?(content)
+        Array(content).all? do |part|
+          !part.is_a?(Hash) || !["text", "thinking"].include?(ToolCall.value(part, :type).to_s) || ToolCall.value(part, :text).to_s.empty? && ToolCall.value(part, :thinking).to_s.empty?
+        end
+      end
+
       def thinking_content?(content)
         content.any? { |part| thinking_content_part?(part) }
       end