kward 0.74.0 → 0.75.0

data/lib/kward/rpc/session_manager.rb

@@ -11,6 +11,7 @@ require_relative "../conversation"
 require_relative "../events"
 require_relative "../export_path"
 require_relative "../memory/manager"
+require_relative "../memory/turn_context"
 require_relative "../message_access"
 require_relative "../message_text"
 require_relative "../session_tree_tool_display"
@@ -35,6 +36,7 @@ require_relative "session_tree"
 require_relative "session_tree_rows"
 require_relative "tool_event_normalizer"
 require_relative "transcript_normalizer"
+require_relative "turn_context"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -63,7 +65,7 @@ module Kward
       WORKER_STOP = Object.new.freeze
 
       RpcSession = Struct.new(:id, :workspace_root, :store, :session, :conversation, :agent, :tool_registry, :prompt, :plugin_output, :queue, :worker, :running_turn_id, :footer_worker, :last_footer_text, keyword_init: true)
-      Turn = Struct.new(:id, :session_id, :input, :display_input, :status, :cancel_requested, :cancellation, :created_at, :started_at, :finished_at, :events, :next_sequence, :error, :streaming_behavior, :plugin_command_name, :plugin_arguments, :steering, keyword_init: true)
+      Turn = Struct.new(:id, :session_id, :input, :display_input, :status, :cancel_requested, :cancellation, :created_at, :started_at, :finished_at, :events, :next_sequence, :error, :streaming_behavior, :plugin_command_name, :plugin_arguments, :steering, :options, :tool_registry, keyword_init: true)
 
       # Creates an object for RPC session lifecycle and turn coordination.
       def initialize(
@@ -142,6 +144,19 @@ module Kward
              .map { |info| session_info_payload(info, workspace_root: root) }
       end
 
+      def active_sessions
+        { sessions: @mutex.synchronize { @sessions.values.map { |rpc_session| session_payload(rpc_session) } } }
+      end
+
+      def tool_schemas(session_id: nil)
+        registry = if session_id
+                     fetch_session(session_id).tool_registry
+                   else
+                     build_tool_registry(Dir.pwd, nil)
+                   end
+        { tools: registry.schemas }
+      end
+
       # Renames the persisted session attached to an RPC session id.
       def rename_session(session_id:, name:)
         rpc_session = fetch_session(session_id)
@@ -326,12 +341,14 @@ module Kward
       # queue a follow-up, or steer the running turn when the active provider
       # supports native steering. The returned turn id is used for status,
       # cancellation, and event replay.
-      def start_turn(session_id:, input:, streaming_behavior: nil, attachments: [])
+      def start_turn(session_id:, input:, streaming_behavior: nil, attachments: [], options: {}, context: nil)
         rpc_session = fetch_session(session_id)
+        normalized_options = normalize_turn_options(options)
+        normalized_context = TurnContext.normalize(context)
         normalized_attachments = normalize_attachments(attachments)
         plugin_command, plugin_arguments = plugin_command_turn(input, normalized_attachments)
         display_input = input.to_s if input.is_a?(String)
-        content = plugin_command ? input.to_s : user_turn_content(expand_prompt_input(input), normalized_attachments)
+        content = plugin_command ? input.to_s : user_turn_content(turn_input_with_context(expand_prompt_input(input), normalized_context), normalized_attachments)
         streaming_behavior = validate_streaming_behavior(default_streaming_behavior(rpc_session, streaming_behavior), rpc_session: rpc_session)
         if streaming_behavior == "steer"
           return steer_running_turn(rpc_session, content)
@@ -349,7 +366,9 @@ module Kward
           next_sequence: 1,
           streaming_behavior: streaming_behavior,
           plugin_command_name: plugin_command&.name,
-          plugin_arguments: plugin_arguments
+          plugin_arguments: plugin_arguments,
+          options: normalized_options,
+          tool_registry: scoped_tool_registry(rpc_session, normalized_options)
         )
         @mutex.synchronize { @turns[turn.id] = turn }
         rpc_session.queue << turn.id
@@ -382,19 +401,52 @@ module Kward
         }
       end
 
+      def list_turns(session_id: nil, active: false)
+        turns = @mutex.synchronize { @turns.values.dup }
+        turns.select! { |turn| turn.session_id == session_id.to_s } if session_id
+        turns.select! { |turn| ["queued", "running"].include?(turn.status) } if active
+        { turns: turns.map { |turn| turn_payload(turn) } }
+      end
+
       def answer_question(session_id:, question_request_id:, answers:)
         rpc_session = fetch_session(session_id)
         rpc_session.prompt.answer(question_request_id, answers)
         { ok: true }
       end
 
+      def answer_tool_approval(session_id:, approval_request_id:, approved:)
+        rpc_session = fetch_session(session_id)
+        rpc_session.prompt.answer_tool_approval(approval_request_id, approved: approved)
+        { ok: true }
+      end
+
       def run_command(session_id:, command:, arguments: "")
         name = command.to_s.delete_prefix("/")
         return { ok: false, error: "unsupported", reason: "clientClipboardOwnedByUi" } if name == "copy"
+        return run_skill_command(session_id: session_id, name: name.delete_prefix("skill:")) if name.start_with?("skill:")
+        return run_skill_command(session_id: session_id, name: arguments) if name == "skill"
 
         run_plugin_command(session_id: session_id, command: name, arguments: arguments)
       end
 
+      def run_skill_command(session_id:, name:)
+        skill_name = name.to_s.strip
+        raise ArgumentError, "Missing skill name" if skill_name.empty?
+
+        rpc_session = fetch_session(session_id)
+        tool_call = {
+          "id" => "skill_#{skill_name.gsub(/[^a-zA-Z0-9_-]/, "_")}",
+          "type" => "function",
+          "function" => {
+            "name" => "read_skill",
+            "arguments" => JSON.dump({ name: skill_name })
+          }
+        }
+        rpc_session.conversation.append_assistant("role" => "assistant", "content" => nil, "tool_calls" => [tool_call])
+        result = rpc_session.tool_registry.dispatch(tool_call, rpc_session.conversation)
+        { command: "skill:#{skill_name}", output: [result.start_with?("Error:") ? result : "Activated skill: #{skill_name}"], result: result }
+      end
+
       def run_plugin_command(session_id:, command:, arguments: "")
         rpc_session = fetch_session(session_id)
         command = plugin_registry.command_for(command.to_s.delete_prefix("/")) || raise(ArgumentError, "Unknown plugin command: #{command}")
@@ -420,8 +472,9 @@ module Kward
       def current_model
         provider = @client.respond_to?(:current_provider) ? @client.current_provider : nil
         model = @client.respond_to?(:current_model) ? @client.current_model : nil
+        reasoning_effort = @client.respond_to?(:current_reasoning_effort) ? @client.current_reasoning_effort : nil
         context_window = @client.respond_to?(:current_context_window) ? @client.current_context_window : nil
-        normalize_model(provider: provider, id: model, model: model, contextWindow: context_window, current: true)
+        ModelInfo.current_payload(provider: provider, model: model, reasoning_effort: reasoning_effort, context_window: context_window)
       end
 
       def session_model(rpc_session)
@@ -431,13 +484,11 @@ module Kward
         reasoning_effort = rpc_session.conversation.reasoning_effort || current_reasoning_effort
         reasoning_effort = nil unless ModelInfo.reasoning_supported?(provider, model)
         context_window = context_window_for(provider, model)
-        normalize_model(
+        ModelInfo.current_payload(
           provider: provider,
-          id: model,
           model: model,
-          reasoningEffort: reasoning_effort,
-          contextWindow: context_window,
-          current: true
+          reasoning_effort: reasoning_effort,
+          context_window: context_window
         )
       end
 
@@ -503,6 +554,7 @@ 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!)
+          rebuild_session_tools(rpc_session)
           if registry.footer_renderer
             start_footer_worker(rpc_session)
             emit_footer_update(rpc_session)
@@ -563,12 +615,25 @@ module Kward
       end
 
       def rebuild_session_tools(rpc_session)
-        tool_registry = build_tool_registry(rpc_session.workspace_root, rpc_session.prompt)
+        hook_context = lifecycle_hook_context(
+          conversation: rpc_session.conversation,
+          session: rpc_session.session,
+          workspace_root: rpc_session.workspace_root
+        )
+        hook_manager = lifecycle_hook_manager(rpc_session.workspace_root)
+        tool_registry = build_tool_registry(
+          rpc_session.workspace_root,
+          rpc_session.prompt,
+          hook_manager: hook_manager,
+          hook_context: hook_context
+        )
         rpc_session.tool_registry = tool_registry
         rpc_session.agent = Agent.new(
           client: @client,
           tool_registry: tool_registry,
-          conversation: rpc_session.conversation
+          conversation: rpc_session.conversation,
+          hook_manager: hook_manager,
+          hook_context: hook_context
         )
       end
 
@@ -602,12 +667,12 @@ module Kward
           id = model[:id] || model["id"] || model[:model] || model["model"]
           model = model.merge(contextWindow: context_window_for(provider, id))
         end
-        ModelInfo.normalize(
-          model,
+        ModelInfo.normalize_available(
+          [model],
           current_provider: (@client.current_provider if @client.respond_to?(:current_provider)),
           current_model: (@client.current_model if @client.respond_to?(:current_model)),
           current_reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort))
-        )
+        ).first
       end
 
       def context_window_for(provider, model)
@@ -702,12 +767,7 @@ module Kward
       end
 
       def display_message_text(message)
-        truncate_tree_text(full_message_text(message))
-      end
-
-      def truncate_tree_text(text)
-        normalized = text.to_s.gsub(/\s+/, " ").strip
-        normalized.length > 120 ? "#{normalized.slice(0, 117)}..." : normalized
+        MessageText.preview(message)
       end
 
       def full_message_text(message)
@@ -761,6 +821,93 @@ module Kward
         AttachmentNormalizer.new(max_bytes: RPC_ATTACHMENT_MAX_BYTES, mime_types: RPC_IMAGE_MIME_TYPES).normalize(attachments)
       end
 
+      def turn_input_with_context(input, context)
+        return input unless context
+
+        [input.to_s, TurnContext.prompt(context)].reject(&:empty?).join("\n\n")
+      end
+
+      def normalize_turn_options(options)
+        options = {} if options.nil?
+        raise ArgumentError, "turn options must be an object" unless options.is_a?(Hash)
+
+        provider = option_value(options, "provider")
+        model = option_value(options, "model")
+        model = option_value(model, "id") || option_value(model, "model") if model.is_a?(Hash)
+        reasoning = option_value(options, "reasoningEffort") || option_value(options, "reasoning")
+        approval_mode = blank_to_nil(option_value(options, "approvalMode"))
+        raise ArgumentError, "Unsupported approvalMode: #{approval_mode}" if approval_mode && !%w[none ask].include?(approval_mode)
+        allowed_tools = option_array(options, "allowedTools")
+        disabled_tools = option_array(options, "disabledTools")
+        raise ArgumentError, "allowedTools and disabledTools cannot both be set" if allowed_tools && disabled_tools
+
+        {
+          provider: blank_to_nil(provider),
+          model: blank_to_nil(model),
+          reasoning: blank_to_nil(reasoning),
+          approval_mode: approval_mode,
+          allowed_tools: allowed_tools,
+          disabled_tools: disabled_tools
+        }.compact
+      end
+
+      def option_value(hash, key)
+        hash[key] || hash[key.to_sym]
+      end
+
+      def option_array(hash, key)
+        value = option_value(hash, key)
+        return nil if value.nil?
+        raise ArgumentError, "#{key} must be an array" unless value.is_a?(Array)
+
+        value.map(&:to_s).reject(&:empty?)
+      end
+
+      def blank_to_nil(value)
+        value = value.to_s if value.is_a?(Symbol)
+        value.to_s.empty? ? nil : value
+      end
+
+      def scoped_tool_registry(rpc_session, options)
+        names = scoped_tool_names(rpc_session, options)
+        approval = tool_approval_callback(rpc_session, options)
+        return nil unless names || approval
+
+        build_tool_registry(
+          rpc_session.workspace_root,
+          rpc_session.prompt,
+          allowed_tool_names: names,
+          tool_approval: approval,
+          hook_manager: lifecycle_hook_manager(rpc_session.workspace_root),
+          hook_context: plugin_context(rpc_session, say_callback: lambda { |message| rpc_session.plugin_output << message.to_s })
+        )
+      end
+
+      def tool_approval_callback(rpc_session, options)
+        return nil unless options[:approval_mode] == "ask"
+
+        lambda do |tool_call:, name:, args:, cancellation:|
+          fields = ToolMetadata.normalized_tool_fields(tool_call)
+          rpc_session.prompt.request_tool_approval(
+            tool_call_id: fields[:toolCallId] || ToolCall.id(tool_call),
+            tool_name: fields[:toolName] || name,
+            args: fields[:args] || ToolCall.camelize_args(args),
+            cancellation: cancellation
+          )
+        end
+      end
+
+      def scoped_tool_names(rpc_session, options)
+        return options[:allowed_tools] if options[:allowed_tools]
+        return nil unless options[:disabled_tools]
+
+        disabled = options[:disabled_tools].to_h { |name| [name, true] }
+        rpc_session.tool_registry.schemas.filter_map do |schema|
+          name = schema.dig(:function, :name) || schema.dig("function", "name")
+          name unless disabled[name]
+        end
+      end
+
       def plugin_registry
         @plugin_registry ||= PluginRegistry.load(reserved_commands: reserved_plugin_command_names)
       end
@@ -778,11 +925,15 @@ module Kward
         conversation.plugin_registry ||= plugin_registry if conversation.respond_to?(:plugin_registry)
         id = SecureRandom.uuid
         prompt = PromptBridge.new(server: @server, session_id: id)
-        tool_registry = build_tool_registry(workspace_root, prompt)
+        hook_context = lifecycle_hook_context(conversation: conversation, session: session, workspace_root: workspace_root)
+        hook_manager = lifecycle_hook_manager(workspace_root)
+        tool_registry = build_tool_registry(workspace_root, prompt, hook_manager: hook_manager, hook_context: hook_context)
         agent = Agent.new(
           client: @client,
           tool_registry: tool_registry,
-          conversation: conversation
+          conversation: conversation,
+          hook_manager: hook_manager,
+          hook_context: hook_context
         )
         RpcSession.new(
           id: id,
@@ -800,8 +951,59 @@ module Kward
         )
       end
 
-      def build_tool_registry(workspace_root, prompt)
-        ToolRegistry.new(workspace: configured_workspace(workspace_root), prompt: prompt)
+      def build_tool_registry(workspace_root, prompt, allowed_tool_names: nil, tool_approval: nil, hook_manager: nil, hook_context: nil)
+        ToolRegistry.new(
+          workspace: configured_workspace(workspace_root),
+          prompt: prompt,
+          allowed_tool_names: allowed_tool_names,
+          tool_approval: tool_approval,
+          hook_manager: hook_manager,
+          hook_context: hook_context
+        )
+      end
+
+      def lifecycle_hook_manager(workspace_root)
+        manager = Hooks::ConfigLoader.new(ConfigFiles.lifecycle_hooks_config(workspace_root)).manager
+        manager.on_result = method(:emit_lifecycle_hook_event)
+        plugin_registry.hook_handlers.each do |hook|
+          manager.register(hook.event, id: hook.id, source: hook.path, order: hook.order, match: hook.match, failure_policy: hook.failure_policy) do |event, context|
+            hook.handler.call(event, context)
+          end
+        end
+        manager
+      end
+
+      def emit_lifecycle_hook_event(event, result)
+        @server.notify("hook/event", {
+          event: {
+            id: event.id,
+            name: event.name,
+            phase: event.phase,
+            timestamp: event.timestamp.iso8601,
+            session: event.session,
+            turn: event.turn,
+            workspace: event.workspace,
+            frontend: event.frontend,
+            agent: event.agent,
+            payloadKeys: event.payload.keys.map(&:to_s).sort
+          },
+          result: {
+            decision: result.decision.decision,
+            warnings: result.warnings,
+            messages: result.messages,
+            decisionCount: result.decisions.length
+          }
+        })
+      end
+
+      def lifecycle_hook_context(conversation:, session:, workspace_root:)
+        PluginRegistry::Context.new(
+          conversation: conversation,
+          args: "",
+          session: session,
+          workspace_root: workspace_root,
+          say_callback: lambda { |message| @server.notify("hook/message", { message: message.to_s }) }
+        )
       end
 
       def configured_workspace(root)
@@ -924,6 +1126,8 @@ module Kward
       # turns. Keep event translation near this boundary so CLI rendering and RPC
       # protocol details do not leak into `Agent`.
       def run_turn(rpc_session, turn)
+        previous_turn_id = Thread.current[:kward_rpc_turn_id]
+        Thread.current[:kward_rpc_turn_id] = turn.id
         rpc_session.running_turn_id = turn.id
         turn.steering = build_steering(turn) if supports_in_flight_steer? && !turn.plugin_command_name
         turn.status = "running"
@@ -940,13 +1144,14 @@ module Kward
         else
           auto_name_session(rpc_session, turn.display_input || turn.input)
           prepare_memory_context(rpc_session.conversation, turn.input)
-          rpc_session.agent.ask(turn.input, display_input: turn_display_input(turn), cancellation: turn.cancellation, steering: turn.steering) do |event|
+          rpc_session.agent.ask(turn.input, display_input: turn_display_input(turn), cancellation: turn.cancellation, steering: turn.steering, options: turn.options || {}, tool_registry: turn.tool_registry) do |event|
             next if turn.cancel_requested
 
             notify_plugin_transcript_event(rpc_session, event)
             handle_agent_event(turn, event)
           end
           persist_memory_state(rpc_session)
+          auto_summarize_memory(rpc_session) unless turn.cancel_requested
           finish_turn(turn, turn.cancel_requested ? "canceled" : "completed")
         end
       rescue Cancellation::CancelledError
@@ -956,6 +1161,7 @@ module Kward
         emit_turn_event(turn, "error", turn.error)
         finish_turn(turn, "failed")
       ensure
+        Thread.current[:kward_rpc_turn_id] = previous_turn_id
         turn.steering = nil
         rpc_session.running_turn_id = nil
       end
@@ -983,11 +1189,7 @@ module Kward
       end
 
       def prepare_memory_context(conversation, input)
-        manager = memory_manager
-        retrieval = manager.retrieve_relevant(input: input, workspace_root: conversation.workspace_root)
-        conversation.last_memory_retrieval = retrieval
-        conversation.memory_context = manager.memory_block(retrieval)
-        conversation.refresh_system_message!
+        Memory::TurnContext.apply(conversation: conversation, input: input, manager: memory_manager)
       rescue StandardError => e
         @server.log_error(e)
         nil
@@ -999,6 +1201,17 @@ module Kward
         nil
       end
 
+      def auto_summarize_memory(rpc_session)
+        manager = memory_manager
+        return unless manager.enabled? && manager.auto_summary_enabled?
+
+        manager.summarize_conversation(rpc_session.conversation, client: @client)
+        persist_memory_state(rpc_session)
+      rescue StandardError => e
+        @server.log_error(e)
+        nil
+      end
+
       def steer_running_turn(rpc_session, input)
         turn_id = rpc_session.running_turn_id
         turn = turn_id && fetch_turn(turn_id)
@@ -1055,6 +1268,8 @@ module Kward
           emit_turn_event(turn, "steeringApplied", { count: event.count })
         when Events::ToolCall
           emit_turn_event(turn, "toolCall", normalized_tool_event_payload(event.tool_call))
+        when Events::ToolUpdate
+          emit_turn_event(turn, "toolUpdate", normalized_tool_update_event_payload(event.tool_call, event.content, elapsed_ms: event.elapsed_ms))
         when Events::ToolResult
           emit_turn_event(turn, "toolResult", normalized_tool_result_event_payload(event.tool_call, event.content))
         when Events::Answer
@@ -1184,11 +1399,21 @@ module Kward
       end
 
       def normalized_tool_event_payload(tool_call)
-        ToolEventNormalizer.new(tool_call).call_payload
+        ToolEventNormalizer.new(tool_call, tool_registry: current_turn_tool_registry).call_payload
+      end
+
+      def normalized_tool_update_event_payload(tool_call, content, elapsed_ms: nil)
+        ToolEventNormalizer.new(tool_call, content: content, tool_registry: current_turn_tool_registry).update_payload(elapsed_ms: elapsed_ms)
       end
 
       def normalized_tool_result_event_payload(tool_call, content)
-        ToolEventNormalizer.new(tool_call, content: content).result_payload
+        ToolEventNormalizer.new(tool_call, content: content, tool_registry: current_turn_tool_registry).result_payload
+      end
+
+      def current_turn_tool_registry
+        return unless Thread.current[:kward_rpc_turn_id]
+
+        @mutex.synchronize { @turns[Thread.current[:kward_rpc_turn_id]]&.tool_registry }
       end
 
       def turn_error_payload(error)

data/lib/kward/rpc/session_metrics.rb

@@ -34,7 +34,7 @@ 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.context_messages, rpc_session.tool_registry.schemas)
+                          client.current_context_parts(rpc_session.conversation.context_messages, rpc_session.tool_registry.schemas, provider: model[:provider], model: model[:id])
                         else
                           {
                             provider: model[:provider],

data/lib/kward/rpc/session_tree_rows.rb

@@ -13,7 +13,7 @@ module Kward
     # this class owns only the mechanics of flattening tree nodes into the row
     # fields sent over JSON-RPC. Keeping row presentation here prevents the RPC
     # session coordinator from accumulating rendering details while preserving the
-    # exact Tauren-compatible payload shape.
+    # exact RPC payload shape.
     class SessionTreeRows
       # @param roots [Array<Hash>] tree roots returned by `SessionStore#session_tree`
       # @param current_leaf [String, nil] active persisted tree leaf id
@@ -29,54 +29,28 @@ module Kward
       # @return [Array<Hash>] rows for the `session/tree` RPC method
       def rows
         tree_nodes = SessionTreeNodes.new(roots: @roots, current_leaf: @current_leaf)
-        active_path = tree_nodes.active_path
         tool_calls_by_id = tree_nodes.tool_calls
-        visible_roots = tree_nodes.visible_roots
-        multiple_roots = visible_roots.length > 1
-        result = []
 
-        stack = visible_roots.sort_by { |root| tree_nodes.contains_active_path?(root, active_path) ? 0 : 1 }.each_with_index.map do |root, index|
-          [root, multiple_roots ? 1 : 0, multiple_roots, multiple_roots, index == visible_roots.length - 1, [], multiple_roots]
-        end.reverse
-
-        until stack.empty?
-          node, indent, just_branched, show_connector, is_last, gutters, virtual_root_child = stack.pop
-          entry = node[:source]["entry"] || {}
+        tree_nodes.layout_rows.map do |row|
+          entry = row[:entry]
           entry_id = entry["id"].to_s
           formatted = tree_entry_display(entry, tool_calls_by_id)
-          display_indent = multiple_roots ? [indent - 1, 0].max : indent
-          result << {
+          {
             entryId: entry_id,
             parentId: entry["parentId"],
             role: formatted[:role],
             text: formatted[:text],
             current: !@current_leaf.to_s.empty? && entry_id == @current_leaf.to_s,
-            depth: display_indent,
-            isLast: is_last,
-            ancestorContinues: gutters.map { |gutter| gutter[:show] },
-            activePath: active_path.include?(entry_id),
+            depth: row[:depth],
+            isLast: row[:is_last],
+            ancestorContinues: row[:gutters].map { |gutter| gutter[:show] },
+            activePath: row[:active_path],
             selectable: @selectable.call(entry),
-            label: node[:source]["label"] || entry["resolvedLabel"],
-            labelTimestamp: node[:source]["labelTimestamp"],
-            prefix: tree_prefix(display_indent, gutters, show_connector && !virtual_root_child, is_last, !node[:children].empty?)
+            label: row[:source]["label"] || entry["resolvedLabel"],
+            labelTimestamp: row[:source]["labelTimestamp"],
+            prefix: row[:prefix]
           }.compact
-
-          children = node[:children].sort_by { |child| tree_nodes.contains_active_path?(child, active_path) ? 0 : 1 }
-          multiple_children = children.length > 1
-          child_indent = if multiple_children
-                           indent + 1
-                         elsif just_branched && indent.positive?
-                           indent + 1
-                         else
-                           indent
-                         end
-          connector_position = [display_indent - 1, 0].max
-          child_gutters = show_connector && !virtual_root_child ? gutters + [{ position: connector_position, show: !is_last }] : gutters
-          children.each_with_index.reverse_each do |child, index|
-            stack << [child, child_indent, multiple_children, multiple_children, index == children.length - 1, child_gutters, false]
-          end
         end
-        result
       end
 
       private
@@ -97,31 +71,6 @@ module Kward
         { role: entry["type"].to_s.empty? ? "entry" : entry["type"].to_s, text: entry["type"].to_s }
       end
 
-      def tree_prefix(display_indent, gutters, show_connector, is_last, foldable)
-        return "" if display_indent.to_i <= 0
-
-        connector_position = show_connector ? display_indent - 1 : -1
-        (0...(display_indent * 3)).map do |index|
-          level = index / 3
-          position = index % 3
-          gutter = gutters.find { |candidate| candidate[:position] == level }
-
-          if gutter
-            position.zero? && gutter[:show] ? "│" : " "
-          elsif show_connector && level == connector_position
-            if position.zero?
-              is_last ? "└" : "├"
-            elsif position == 1
-              foldable ? "⊟" : "─"
-            else
-              " "
-            end
-          else
-            " "
-          end
-        end.join
-      end
-
       def format_tool_result(message, tool_calls_by_id)
         tool_call = tool_calls_by_id[MessageAccess.tool_call_id(message).to_s]
         return SessionTreeToolDisplay.label(tool_call) if tool_call
@@ -132,11 +81,11 @@ module Kward
       end
 
       def display_message_text(message)
-        SessionTreeNodes.truncate_text(MessageText.full_text(message))
+        MessageText.preview(message)
       end
 
       def truncate_tree_text(text)
-        SessionTreeNodes.truncate_text(text)
+        MessageText.truncate_preview(text)
       end
     end
   end

data/lib/kward/rpc/tool_event_normalizer.rb

@@ -7,9 +7,10 @@ module Kward
   module RPC
     # Converts tool calls and results into RPC event payloads.
     class ToolEventNormalizer
-      def initialize(tool_call, content: nil)
+      def initialize(tool_call, content: nil, tool_registry: nil)
         @tool_call = tool_call
         @content = content
+        @tool_registry = tool_registry
         @fields = ToolMetadata.normalized_tool_fields(@tool_call)
       end
 
@@ -17,10 +18,17 @@ module Kward
         {
           toolCallId: @fields[:toolCallId],
           toolName: @fields[:toolName],
-          args: @fields[:args]
+          args: @fields[:args],
+          metadata: metadata
         }.compact
       end
 
+      def update_payload(elapsed_ms: nil)
+        payload = call_payload.merge(delta: { content: @content.to_s })
+        payload[:elapsedMs] = elapsed_ms if elapsed_ms
+        payload
+      end
+
       def result_payload
         call_payload.merge(
           content: @content,
@@ -43,6 +51,12 @@ module Kward
 
       private
 
+      def metadata
+        return unless @tool_registry&.respond_to?(:metadata_for)
+
+        @tool_registry.metadata_for(@fields[:toolName])
+      end
+
       def normalized_result
         text = @content.to_s
         is_error = ToolMetadata.error_result?(text)