rubik 0.3.4 → 0.4.0

data/lib/rubik/orchestrator/step_executor.rb

@@ -19,20 +19,9 @@ module Rubik
       include MaestroGate
 
       ERROR_PREFIXES = [
-        "-- ",
-        "Error:",
-        "Error ",
-        "Usage:",
-        "Pre-flight verification failed",
-        "Bilinmeyen komut",
-        "Failed",
-        "Security blocked",
-        "Command error",
-        "[EXIT ",
-        "Test run [FAILED]",
-        "Lint [FAILED]",
-        "[CONFLICT]",
-        "[CONFLICT "
+        "-- ", "Error:", "Error ", "Usage:", "Pre-flight verification failed",
+        "Bilinmeyen komut", "Failed", "Security blocked", "Command error",
+        "[EXIT ", "Test run [FAILED]", "Lint [FAILED]", "[CONFLICT]", "[CONFLICT "
       ].freeze
 
       # Plan 87 E-1: state is reached through the ShellDeps façade. Accepts a
@@ -98,7 +87,6 @@ module Rubik
 
       def execute_registered_tool(tool_instance, tool_name, tool_args, call_id, auto_apply_mode = nil)
         @deps.on_step&.call(type: :tool_call, tool: tool_name, args: tool_args, step: @deps.step_count, max_steps: @deps.max_steps, call_id: call_id)
-        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
         # Opt-in circuit breaker (G19): when enabled and the circuit for this
         # tool is open, raise into the normal error-result plumbing below so
@@ -107,111 +95,13 @@ module Rubik
         breaker = circuit_breaker_for
         blocked_by_circuit = breaker && !breaker.allow?(tool_instance.name)
 
-        tool_result = begin
-          if blocked_by_circuit
-            raise ToolCircuitBreaker::CircuitOpenError,
-                  "circuit open for '#{tool_instance.name}' — repeated failures; waiting out the cooldown before retrying"
-          end
+        raw_output, tool_result = invoke_tool_and_normalize(tool_instance, tool_name, tool_args, call_id, blocked_by_circuit: blocked_by_circuit)
 
-          raw_output = tool_instance.execute(tool_args)
-          t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          dur = ((t1 - t0) * 1000).round(1)
-
-          max_chars = @deps.shell&.config&.fetch("tools.max_output_chars", 12_000) || 12_000
-          max_lines = @deps.shell&.config&.fetch("tools.max_output_lines", 300) || 300
-          trunc_strat = @deps.shell&.config&.fetch("tools.truncation_strategy", "head_tail") || "head_tail"
-
-          if raw_output.is_a?(Rubik::Tools::Result)
-            trunc_res = Rubik::Tools::Truncator.truncate(raw_output.output, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)
-            effective_dur = raw_output.duration_ms.positive? ? raw_output.duration_ms : dur
-            first_line = raw_output.output.lines.first.to_s.strip
-            first_line = nil if first_line.empty?
-            Rubik::Tools::Result.new(
-              tool_name: raw_output.tool_name.to_s.empty? ? tool_name : raw_output.tool_name,
-              call_id: raw_output.call_id.to_s.empty? ? call_id : raw_output.call_id,
-              status: raw_output.status,
-              error: raw_output.error || (raw_output.error? ? first_line : nil),
-              exit_code: raw_output.exit_code,
-              output: trunc_res[:text],
-              duration_ms: effective_dur,
-              truncated: raw_output.truncated || trunc_res[:truncated],
-              metadata: raw_output.metadata
-            )
-          elsif raw_output.respond_to?(:status) && raw_output.respond_to?(:output)
-            out_str = raw_output.output.to_s
-            trunc_res = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)
-            st = raw_output.status.to_sym
-            first_line = out_str.lines.first.to_s.strip
-            first_line = nil if first_line.empty?
-            err = (raw_output.respond_to?(:error) && raw_output.error) || (st == :error ? first_line : nil)
-            Rubik::Tools::Result.new(
-              tool_name: tool_name,
-              call_id: call_id,
-              status: st,
-              error: err,
-              output: trunc_res[:text],
-              duration_ms: dur,
-              truncated: trunc_res[:truncated],
-              # Structured fields ride along when the tool provides them
-              # (issue #127): the same Result contract for every carrier.
-              exit_code: raw_output.respond_to?(:exit_code) ? raw_output.exit_code : nil,
-              metadata: raw_output.respond_to?(:metadata) ? raw_output.metadata : {}
-            )
-          else
-            out_str = raw_output.to_s
-            trunc_res = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)
-
-            is_err = if raw_output.respond_to?(:error?)
-                       raw_output.error?
-                     elsif raw_output.respond_to?(:failed?)
-                       raw_output.failed?
-                     elsif raw_output.is_a?(String)
-                       ERROR_PREFIXES.any? { |pfx| raw_output.start_with?(pfx) }
-                     else
-                       false
-                     end
-
-            first_line = out_str.lines.first.to_s.strip
-            first_line = nil if first_line.empty?
-
-            Rubik::Tools::Result.new(
-              tool_name: tool_name,
-              call_id: call_id,
-              status: is_err ? :error : :ok,
-              error: is_err ? first_line : nil,
-              output: trunc_res[:text],
-              duration_ms: dur,
-              truncated: trunc_res[:truncated]
-            )
-          end
-        rescue StandardError => e
-          t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          dur = ((t1 - t0) * 1000).round(1)
-          err_msg = "Error executing tool '#{tool_name}': #{e.class} - #{e.message}"
-          Rubik::Tools::Result.new(
-            tool_name: tool_name,
-            call_id: call_id,
-            status: :error,
-            error: e.message,
-            output: err_msg,
-            duration_ms: dur
-          )
-        end
+        record_circuit_breaker_result(breaker, tool_instance.name, tool_result.status) if breaker && !blocked_by_circuit
 
         # always-mode flush after every tool — was historically silent; the
         # post_tool event makes the disk write visible like every other apply
-        if breaker && !blocked_by_circuit
-          if tool_result.status == :ok
-            breaker.record_success(tool_instance.name)
-          else
-            breaker.record_failure(tool_instance.name)
-          end
-        end
-
-        if AutoApply.apply?(@deps.config, trigger: :post_tool, mode: auto_apply_mode) && @deps.buffer_manager&.dirty?
-          applied = AutoApply.apply_and_sync(@deps.buffer_manager, @deps.shell)
-          @deps.on_step&.call(type: :auto_apply, reason: "post_tool", files: applied, step: @deps.step_count, max_steps: @deps.max_steps)
-        end
+        perform_post_tool_auto_apply(auto_apply_mode)
 
         # Real-time LSP In-Buffer Diagnostics feedback loop (Plan 56 D-5,
         # extracted to LspFeedback for the line budget).
@@ -222,39 +112,9 @@ module Rubik
         # çıktısı tam içerikle kullanıcıya :user_output olarak akar; model,
         # history ve :tool_result özeti yalnız stub görür. Event birincil
         # teslimat olduğu için onsuz stub yalan olur — kaynak yoksa warn.
-        if raw_output.respond_to?(:user_display?) && raw_output.user_display? && tool_result.status == :ok
-          sink = @deps.respond_to?(:on_step) ? @deps.on_step : nil
-          if sink
-            sink.call(type: :user_output, content: raw_output.to_s, label: raw_output.display_stub,
-                      step: @deps.step_count, max_steps: @deps.max_steps)
-          else
-            warn("[show_file] no :user_output sink wired — display content dropped: #{raw_output.display_stub}")
-          end
-          tool_result = Rubik::Tools::Result.new(tool_name: tool_name, call_id: call_id, status: :ok,
-                                                 output: raw_output.display_stub, duration_ms: tool_result.duration_ms)
-        end
+        tool_result = handle_user_display_output(raw_output, tool_result, tool_name, call_id)
 
-        @deps.on_step&.call(
-          type: :tool_result,
-          tool: tool_name,
-          output: tool_result.output,
-          status: tool_result.status,
-          duration_ms: tool_result.duration_ms,
-          step: @deps.step_count,
-          max_steps: @deps.max_steps,
-          call_id: call_id,
-          exit_code: tool_result.exit_code,
-          metadata: tool_result.metadata,
-          line_count: tool_result.output.to_s.lines.size,
-          byte_size: tool_result.output.to_s.bytesize,
-          tokens: @deps.total_tokens
-        )
-
-        Rubik::Orchestrator::ToolHistory.write(@deps.history, tool_call_id: call_id, tool_name: tool_name,
-                                                              status: tool_result.status, duration_ms: tool_result.duration_ms,
-                                                              content: tool_result.to_xml, exit_code: tool_result.exit_code,
-                                                              metadata: tool_result.metadata)
-        @deps.activity.record(tool_name, tool_args, tool_result.status) if @deps.respond_to?(:activity)
+        record_tool_execution_results(tool_name, tool_args, call_id, tool_result)
         @deps.reset_invalid_tools!
         tool_result
       end
@@ -280,12 +140,8 @@ module Rubik
         diagnostic_msg = Rubik::Tools::DiagnosticReporter.render_unknown_tool(tool_name, candidate_tools: candidate_tools, all_tools: all_tool_names)
 
         err_result = Rubik::Tools::Result.new(
-          tool_name: tool_name,
-          call_id: call_id,
-          status: :error,
-          error: "Tool '#{tool_name}' does not exist.",
-          output: diagnostic_msg,
-          duration_ms: 0.0
+          tool_name: tool_name, call_id: call_id, status: :error,
+          error: "Tool '#{tool_name}' does not exist.", output: diagnostic_msg, duration_ms: 0.0
         )
         Rubik::Orchestrator::ToolHistory.write(@deps.history, tool_call_id: call_id, tool_name: tool_name,
                                                               status: :error, duration_ms: 0.0, content: err_result.to_xml)
@@ -294,6 +150,134 @@ module Rubik
 
       private
 
+      def invoke_tool_and_normalize(tool_instance, tool_name, tool_args, call_id, blocked_by_circuit:)
+        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        raw_output = nil
+
+        tool_result = begin
+          if blocked_by_circuit
+            raise ToolCircuitBreaker::CircuitOpenError,
+                  "circuit open for '#{tool_instance.name}' — repeated failures; waiting out the cooldown before retrying"
+          end
+
+          raw_output = tool_instance.execute(tool_args)
+          t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          dur = ((t1 - t0) * 1000).round(1)
+
+          normalize_raw_output(raw_output, tool_name, call_id, dur)
+        rescue StandardError => e
+          t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          dur = ((t1 - t0) * 1000).round(1)
+          err_msg = "Error executing tool '#{tool_name}': #{e.class} - #{e.message}"
+          Rubik::Tools::Result.new(tool_name: tool_name, call_id: call_id, status: :error, error: e.message, output: err_msg, duration_ms: dur)
+        end
+
+        [raw_output, tool_result]
+      end
+
+      def normalize_raw_output(raw_output, tool_name, call_id, dur)
+        max_chars = @deps.shell&.config&.fetch("tools.max_output_chars", 12_000) || 12_000
+        max_lines = @deps.shell&.config&.fetch("tools.max_output_lines", 300) || 300
+        trunc_strat = @deps.shell&.config&.fetch("tools.truncation_strategy", "head_tail") || "head_tail"
+
+        if raw_output.is_a?(Rubik::Tools::Result)
+          trunc_res = Rubik::Tools::Truncator.truncate(raw_output.output, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)
+          effective_dur = raw_output.duration_ms.positive? ? raw_output.duration_ms : dur
+          first_line = raw_output.output.lines.first.to_s.strip
+          first_line = nil if first_line.empty?
+          Rubik::Tools::Result.new(
+            tool_name: raw_output.tool_name.to_s.empty? ? tool_name : raw_output.tool_name,
+            call_id: raw_output.call_id.to_s.empty? ? call_id : raw_output.call_id,
+            status: raw_output.status, error: raw_output.error || (raw_output.error? ? first_line : nil),
+            # Structured fields ride along when the tool provides them
+            # (issue #127): the same Result contract for every carrier.
+            exit_code: raw_output.exit_code, output: trunc_res[:text], duration_ms: effective_dur,
+            truncated: raw_output.truncated || trunc_res[:truncated], metadata: raw_output.metadata
+          )
+        elsif raw_output.respond_to?(:status) && raw_output.respond_to?(:output)
+          out_str = raw_output.output.to_s
+          trunc_res = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)
+          st = raw_output.status.to_sym
+          first_line = out_str.lines.first.to_s.strip
+          first_line = nil if first_line.empty?
+          err = (raw_output.respond_to?(:error) && raw_output.error) || (st == :error ? first_line : nil)
+          Rubik::Tools::Result.new(
+            tool_name: tool_name, call_id: call_id, status: st, error: err, output: trunc_res[:text],
+            duration_ms: dur, truncated: trunc_res[:truncated],
+            exit_code: raw_output.respond_to?(:exit_code) ? raw_output.exit_code : nil,
+            metadata: raw_output.respond_to?(:metadata) ? raw_output.metadata : {}
+          )
+        else
+          out_str = raw_output.to_s
+          trunc_res = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)
+
+          is_err = if raw_output.respond_to?(:error?)
+                     raw_output.error?
+                   elsif raw_output.respond_to?(:failed?)
+                     raw_output.failed?
+                   elsif raw_output.is_a?(String)
+                     ERROR_PREFIXES.any? { |pfx| raw_output.start_with?(pfx) }
+                   else
+                     false
+                   end
+
+          first_line = out_str.lines.first.to_s.strip
+          first_line = nil if first_line.empty?
+
+          Rubik::Tools::Result.new(
+            tool_name: tool_name, call_id: call_id, status: is_err ? :error : :ok,
+            error: is_err ? first_line : nil, output: trunc_res[:text], duration_ms: dur, truncated: trunc_res[:truncated]
+          )
+        end
+      end
+
+      def record_circuit_breaker_result(breaker, tool_name, status)
+        if status == :ok
+          breaker.record_success(tool_name)
+        else
+          breaker.record_failure(tool_name)
+        end
+      end
+
+      def perform_post_tool_auto_apply(auto_apply_mode)
+        return unless AutoApply.apply?(@deps.config, trigger: :post_tool, mode: auto_apply_mode) && @deps.buffer_manager&.dirty?
+
+        applied = AutoApply.apply_and_sync(@deps.buffer_manager, @deps.shell)
+        @deps.on_step&.call(type: :auto_apply, reason: "post_tool", files: applied, step: @deps.step_count, max_steps: @deps.max_steps)
+      end
+
+      def handle_user_display_output(raw_output, tool_result, tool_name, call_id)
+        return tool_result unless raw_output.respond_to?(:user_display?) && raw_output.user_display? && tool_result.status == :ok
+
+        sink = @deps.respond_to?(:on_step) ? @deps.on_step : nil
+        if sink
+          sink.call(type: :user_output, content: raw_output.to_s, label: raw_output.display_stub,
+                    step: @deps.step_count, max_steps: @deps.max_steps)
+        else
+          warn("[show_file] no :user_output sink wired — display content dropped: #{raw_output.display_stub}")
+        end
+
+        Rubik::Tools::Result.new(
+          tool_name: tool_name, call_id: call_id, status: :ok, output: raw_output.display_stub, duration_ms: tool_result.duration_ms
+        )
+      end
+
+      def record_tool_execution_results(tool_name, tool_args, call_id, tool_result)
+        @deps.on_step&.call(
+          type: :tool_result, tool: tool_name, output: tool_result.output, status: tool_result.status,
+          duration_ms: tool_result.duration_ms, step: @deps.step_count, max_steps: @deps.max_steps,
+          call_id: call_id, exit_code: tool_result.exit_code, metadata: tool_result.metadata,
+          line_count: tool_result.output.to_s.lines.size, byte_size: tool_result.output.to_s.bytesize, tokens: @deps.total_tokens
+        )
+
+        Rubik::Orchestrator::ToolHistory.write(
+          @deps.history, tool_call_id: call_id, tool_name: tool_name, status: tool_result.status,
+                         duration_ms: tool_result.duration_ms, content: tool_result.to_xml, exit_code: tool_result.exit_code, metadata: tool_result.metadata
+        )
+
+        @deps.activity.record(tool_name, tool_args, tool_result.status) if @deps.respond_to?(:activity)
+      end
+
       # G19: one breaker per executor, built from the first enabled config
       # sighting. Threshold/cooldown changes via live !config set are picked
       # up on the next executor instantiation — acceptable for an opt-in

data/lib/rubik/orchestrator/subagent/spawn_transaction.rb

@@ -20,10 +20,7 @@ module Rubik
         def spawn(role:, prompt:, type_name: "research", system_prompt: nil,
                   parent_id: ConversationId::ROOT_ID, workspace: "inherit", model: "inherit",
                   max_steps: nil, provider: nil, depends_on: nil, reserved_id: nil, owner: nil)
-          role_str = role.to_s.strip
-          prompt_str = prompt.to_s.strip
-          raise ArgumentError, "Subagent role cannot be empty" if role_str.empty?
-          raise ArgumentError, "Subagent prompt cannot be empty" if prompt_str.empty?
+          role_str, prompt_str = validate_spawn_args!(role, prompt)
 
           # Issue #125: the owner's task was cancelled — refuse before any
           # reservation, slot or context work happens.
@@ -44,7 +41,6 @@ module Rubik
 
             profile_snapshot = resolve_profile_snapshot(type_name: type_name, role: role_str,
                                                         system_prompt: system_prompt)
-            effective_sys_prompt = profile_snapshot.effective_system_prompt
             # A profile update must not redirect rollback to a newly provided
             # init supervisor after this spawn registered its unit.
             activation_init = init_for_activation
@@ -52,40 +48,23 @@ module Rubik
             # unchanged built-in prompt can be reconstructed from its type.
             prompt_reconstructible = system_prompt.to_s.strip.empty? && !profile_snapshot.custom_prompt
 
-            # Queued specs already reserved this id; fresh spawns reserve the
-            # next sequence number here and return it if activation rolls back.
-            generated_id = reserved_id.nil?
-            subagent_id = generated_id ? "subagent-#{@counter + 1}" : reserved_id.to_s
-            id_in_use = @instances.key?(subagent_id) || (@finished || {}).key?(subagent_id)
-            raise ArgumentError, "Subagent id '#{subagent_id}' is already in use." if id_in_use
-
-            @counter += 1 if generated_id
+            subagent_id, generated_id = reserve_subagent_id!(reserved_id)
 
             child_ctx = nil
             inst = nil
             begin
               child_ctx = extend_root_context!(:spawn)
-              effective_buffer = branch_or_inherit_buffer(workspace)
-              scoped_registry = build_scoped_registry(profile_snapshot, child_ctx, effective_buffer)
-              prov, effective_model = resolve_provider_and_model(model)
-              prov = provider if provider
-
-              inst = Instance.new(
-                id: subagent_id, parent_id: parent_id, role: role_str, type_name: profile_snapshot.name,
-                prompt: prompt_str, system_prompt: effective_sys_prompt, workspace: workspace,
-                model: effective_model, context: child_ctx, tool_registry: scoped_registry,
-                provider: prov, buffer_manager: effective_buffer, max_steps: (max_steps || @default_max_steps).to_i,
-                provider_gate: @provider_gate, root_dir: @root_dir, config: @config,
-                context_limit: (@config.respond_to?(:fetch) ? @config.fetch("context.max_tokens", 32_768) : 32_768),
-                event_bus: @event_bus, transcript_storage: absorb_storage, owner_task: owner,
-                prompt_reconstructible: prompt_reconstructible, profile_snapshot: profile_snapshot
+              inst = build_subagent_instance(
+                subagent_id: subagent_id, parent_id: parent_id, role_str: role_str, prompt_str: prompt_str,
+                profile_snapshot: profile_snapshot, workspace: workspace, model: model, max_steps: max_steps,
+                provider: provider, owner: owner, prompt_reconstructible: prompt_reconstructible,
+                child_ctx: child_ctx
               )
-
               @instances[subagent_id] = inst
-              activate_instance!(inst, child_ctx: child_ctx, owner_token: owner,
-                                       init_supervisor: activation_init, defer_start: true)
-              raise "Subagent worker start gate could not be released." unless inst.release_start!
 
+              activate_and_release_subagent!(
+                inst: inst, child_ctx: child_ctx, owner: owner, activation_init: activation_init
+              )
               inst
             rescue StandardError
               rollback_spawn!(subagent_id: subagent_id, inst: inst, child_ctx: child_ctx,
@@ -93,6 +72,7 @@ module Rubik
               raise
             end
           end
+
           # SS bırakma kancası: yeni başlayan instance, onu bekleyen kuyruk
           # spesifikasyonlarını serbest bırakır (kilit DIŞINDA — emit kuralı).
           begin
@@ -105,6 +85,55 @@ module Rubik
 
         private
 
+        def validate_spawn_args!(role, prompt)
+          role_str = role.to_s.strip
+          prompt_str = prompt.to_s.strip
+          raise ArgumentError, "Subagent role cannot be empty" if role_str.empty?
+          raise ArgumentError, "Subagent prompt cannot be empty" if prompt_str.empty?
+
+          [role_str, prompt_str]
+        end
+
+        def reserve_subagent_id!(reserved_id)
+          # Queued specs already reserved this id; fresh spawns reserve the
+          # next sequence number here and return it if activation rolls back.
+          generated_id = reserved_id.nil?
+          subagent_id = generated_id ? "subagent-#{@counter + 1}" : reserved_id.to_s
+          id_in_use = @instances.key?(subagent_id) || (@finished || {}).key?(subagent_id)
+          raise ArgumentError, "Subagent id '#{subagent_id}' is already in use." if id_in_use
+
+          @counter += 1 if generated_id
+          [subagent_id, generated_id]
+        end
+
+        def build_subagent_instance(subagent_id:, parent_id:, role_str:, prompt_str:,
+                                    profile_snapshot:, workspace:, model:, max_steps:,
+                                    provider:, owner:, prompt_reconstructible:, child_ctx:)
+          effective_buffer = branch_or_inherit_buffer(workspace)
+          scoped_registry = build_scoped_registry(profile_snapshot, child_ctx, effective_buffer)
+          prov, effective_model = resolve_provider_and_model(model)
+          prov = provider if provider
+
+          context_limit = @config.respond_to?(:fetch) ? @config.fetch("context.max_tokens", 32_768) : 32_768
+
+          Instance.new(
+            id: subagent_id, parent_id: parent_id, role: role_str, type_name: profile_snapshot.name,
+            prompt: prompt_str, system_prompt: profile_snapshot.effective_system_prompt, workspace: workspace,
+            model: effective_model, context: child_ctx, tool_registry: scoped_registry,
+            provider: prov, buffer_manager: effective_buffer, max_steps: (max_steps || @default_max_steps).to_i,
+            provider_gate: @provider_gate, root_dir: @root_dir, config: @config,
+            context_limit: context_limit, event_bus: @event_bus,
+            transcript_storage: absorb_storage, owner_task: owner,
+            prompt_reconstructible: prompt_reconstructible, profile_snapshot: profile_snapshot
+          )
+        end
+
+        def activate_and_release_subagent!(inst:, child_ctx:, owner:, activation_init:)
+          activate_instance!(inst, child_ctx: child_ctx, owner_token: owner,
+                                   init_supervisor: activation_init, defer_start: true)
+          raise "Subagent worker start gate could not be released." unless inst.release_start!
+        end
+
         def resolve_profile_snapshot(type_name:, role:, system_prompt:)
           reserved_name = RESERVED_ROLE_PROFILES[role.to_s.downcase.strip]
           if reserved_name

data/lib/rubik/prompt/token_estimator.rb

@@ -22,27 +22,31 @@ module Rubik
         ((len * 10) + 37) / 38
       end
 
+      # PERF: Fast-path message token estimator respecting ConversationRows abstraction.
       def estimate_message(msg)
         return 0 unless ConversationRows.row?(msg)
 
         tokens = 4 # Base message overhead (role delimiter, headers)
-        role = ConversationRows.value_of(msg, :role)
-        tokens += estimate_text(role) if role
 
-        content = ConversationRows.value_of(msg, :content)
-        tokens += estimate_text(content) if content
+        if (role = ConversationRows.value_of(msg, :role))
+          tokens += estimate_text(role)
+        end
 
-        tool_calls = msg[:tool_calls] || msg["tool_calls"]
-        if tool_calls && !tool_calls.empty?
-          tool_calls_str = serialize_for_estimation(tool_calls)
-          tokens += estimate_text(tool_calls_str)
+        if (content = ConversationRows.value_of(msg, :content))
+          tokens += estimate_text(content)
         end
 
-        tool_call_id = msg[:tool_call_id] || msg["tool_call_id"]
-        tokens += estimate_text(tool_call_id) if tool_call_id
+        if (tool_calls = ConversationRows.value_of(msg, :tool_calls)) && !tool_calls.empty?
+          tokens += estimate_text(serialize_for_estimation(tool_calls))
+        end
 
-        tool_name = msg[:tool_name] || msg["tool_name"]
-        tokens += estimate_text(tool_name) if tool_name
+        if (tool_call_id = ConversationRows.value_of(msg, :tool_call_id))
+          tokens += estimate_text(tool_call_id)
+        end
+
+        if (tool_name = ConversationRows.value_of(msg, :tool_name))
+          tokens += estimate_text(tool_name)
+        end
 
         tokens
       end