kward 0.67.0 → 0.68.0

data/lib/kward/cli/compaction.rb

@@ -0,0 +1,25 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # CLI slash-command helpers for manual context compaction.
+    module CompactionCommands
+      private
+
+      def compact_context(agent, argument)
+        result = Compactor.new(
+          conversation: agent.conversation,
+          client: @client,
+          tool_result_summarizer: lambda { |tool_call, content| tool_result_summary(tool_call, content) }
+        ).compact(custom_instructions: argument)
+        @prompt.say("\nCompacted context: #{result.old_message_count} messages -> #{result.new_message_count} messages.\n")
+        render_transcript_block("Assistant", result.summary)
+      rescue Compactor::NothingToCompact, Compactor::AlreadyCompacted, Compactor::EmptySummary => e
+        @prompt.say("\n#{e.message}\n")
+      rescue StandardError => e
+        @prompt.say("\nCompaction error: #{e.message}\n")
+      end
+
+    end
+  end
+end

data/lib/kward/cli/doctor.rb

@@ -0,0 +1,121 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # Environment and configuration diagnostics for the `doctor` command.
+    module Doctor
+      private
+
+      # Writes the doctor output for the terminal CLI flow.
+      def print_doctor
+        lines = ["#{colored("Kward Doctor", :green, :bold)}", ""]
+        doctor_checks.each do |check|
+          lines << "#{doctor_mark(check.fetch(:status))} #{check.fetch(:label)}: #{check.fetch(:message)}"
+        end
+        @prompt.say lines.join("\n")
+      end
+
+      def doctor_checks
+        config = safely_read_config
+        [
+          doctor_config_check,
+          doctor_config_json_check(config),
+          doctor_directory_check("Config directory", ConfigFiles.config_dir),
+          doctor_directory_check("Session directory", SessionStore.new(cwd: current_workspace_root).session_dir, create: true),
+          doctor_workspace_check,
+          doctor_model_check,
+          doctor_auth_check(config),
+          doctor_pan_check(config),
+          { status: :ok, label: "Color", message: @color_enabled ? "enabled" : "disabled" }
+        ]
+      end
+
+      def safely_read_config
+        ConfigFiles.read_config
+      rescue StandardError
+        nil
+      end
+
+      def doctor_config_check
+        path = ConfigFiles.config_path
+        if File.exist?(path)
+          readable = File.readable?(path)
+          return { status: readable ? :ok : :error, label: "Config", message: readable ? path : "not readable: #{path}" }
+        end
+
+        { status: :warning, label: "Config", message: "not found: #{path}" }
+      end
+
+      def doctor_config_json_check(config)
+        return { status: :error, label: "Config JSON", message: "invalid or unreadable" } unless config.is_a?(Hash)
+
+        { status: :ok, label: "Config JSON", message: "valid" }
+      end
+
+      def doctor_directory_check(label, path, create: false)
+        FileUtils.mkdir_p(path, mode: 0o700) if create
+        if Dir.exist?(path) && File.writable?(path)
+          { status: :ok, label: label, message: "writable: #{path}" }
+        elsif Dir.exist?(path)
+          { status: :error, label: label, message: "not writable: #{path}" }
+        else
+          { status: :error, label: label, message: "missing: #{path}" }
+        end
+      rescue StandardError => e
+        { status: :error, label: label, message: e.message }
+      end
+
+      def doctor_workspace_check
+        root = current_workspace_root
+        return { status: :ok, label: "Workspace", message: root } if Dir.exist?(root) && File.directory?(root)
+
+        { status: :error, label: "Workspace", message: "not a directory: #{root}" }
+      end
+
+      def doctor_model_check
+        provider = @client.current_provider if @client.respond_to?(:current_provider)
+        model = @client.current_model if @client.respond_to?(:current_model)
+        parts = [provider, model].compact.map(&:to_s).reject(&:empty?)
+        return { status: :ok, label: "Model", message: parts.join(" / ") } if parts.any?
+
+        { status: :warning, label: "Model", message: "not configured" }
+      rescue StandardError => e
+        { status: :warning, label: "Model", message: e.message }
+      end
+
+      def doctor_auth_check(config)
+        openai_auth = OpenAIOAuth.default_auth_path
+        github_auth = GithubOAuth.default_auth_path
+        has_openrouter = !config.to_h["openrouter_api_key"].to_s.empty? || !ENV["OPENROUTER_API_KEY"].to_s.empty?
+        paths = []
+        paths << "OpenAI OAuth" if File.exist?(openai_auth)
+        paths << "GitHub OAuth" if File.exist?(github_auth)
+        paths << "OpenRouter API key" if has_openrouter
+        return { status: :ok, label: "Auth", message: paths.join(", ") } if paths.any?
+
+        { status: :warning, label: "Auth", message: "no saved credentials found; run `kward login`" }
+      end
+
+      def doctor_pan_check(config)
+        pan = config.to_h["pan_mode"] || {}
+        if !pan["username"].to_s.empty? && !pan["password"].to_s.empty?
+          { status: :ok, label: "Pan mode", message: "credentials configured" }
+        else
+          { status: :warning, label: "Pan mode", message: "username/password not configured" }
+        end
+      end
+
+      def doctor_mark(status)
+        case status
+        when :ok
+          colored("✓", :green, :bold)
+        when :warning
+          colored("!", :yellow, :bold)
+        else
+          colored("✗", :red, :bold)
+        end
+      end
+
+    end
+  end
+end

data/lib/kward/cli/interactive_turn.rb

@@ -0,0 +1,225 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # Interactive turn loop helpers for streaming, cancellation, and queued user input.
+    module InteractiveTurn
+      private
+
+      def run_interactive_turn(agent, input, display_input: nil)
+        prepare_memory_context(agent.conversation, input) if agent.respond_to?(:conversation)
+        print_user_transcript(input, display_input: display_input) if prompt_interface?
+        return run_blocking_interactive_turn(agent, input, display_input: display_input) unless prompt_interface?
+
+        queued_inputs = []
+        cancellation = Cancellation.new
+        cancelled = false
+        steering = steering_supported? ? Steering.new : nil
+        event_queue = Queue.new
+        stream_state = {
+          streamed: false,
+          last_flush: monotonic_now,
+          stream_block_open: false,
+          markdown_streams: {},
+          defer_assistant_streaming: defer_assistant_streaming?(agent)
+        }
+        markdown_chunks = []
+        answer = nil
+        error = nil
+        @prompt.begin_busy_input("You>") if @prompt.respond_to?(:begin_busy_input)
+
+        worker = Thread.new do
+          options = agent_display_options(display_input)
+          options[:cancellation] = cancellation
+          options[:steering] = steering if steering
+          answer = agent.ask(input, **options) do |event|
+            event_queue << event
+          end
+        rescue StandardError => e
+          error = e
+        end
+        worker.report_on_exception = false
+
+        while worker.alive?
+          begin
+            poll_result = collect_busy_input(queued_inputs, steering)
+            sleep 0.01
+          rescue Interrupt
+            poll_result = PromptInterface::CANCEL_INPUT
+          end
+          if poll_result == PromptInterface::CANCEL_INPUT && !cancelled
+            cancelled = true
+            cancellation.cancel!
+            worker.raise(Cancellation::CancelledError, "cancelled") if worker.alive?
+          end
+          drain_interactive_events(event_queue, markdown_chunks, stream_state, agent)
+        end
+        begin
+          worker.join
+        rescue Cancellation::CancelledError => e
+          error ||= e
+        end
+        drain_busy_input(queued_inputs, nil) unless cancelled
+        drain_interactive_events(event_queue, markdown_chunks, stream_state, agent, force: true)
+        raise error if error && !error.is_a?(Cancellation::CancelledError)
+
+        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless cancelled || stream_state[:streamed] || answer.to_s.empty?
+        persist_memory_state(agent.conversation) if agent.respond_to?(:conversation)
+        auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation) && queued_inputs.empty? && !cancelled
+        queued_inputs
+      ensure
+        @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
+      end
+
+      def drain_interactive_events(event_queue, markdown_chunks, stream_state, agent = nil, force: false)
+        drained = 0
+        loop do
+          break if !force && drained >= INTERACTIVE_EVENT_DRAIN_LIMIT
+
+          event = event_queue.pop(true)
+          drained += 1
+          notify_plugin_transcript_event(event, agent.respond_to?(:conversation) ? agent.conversation : nil)
+          handle_interactive_event(event, markdown_chunks, stream_state)
+        rescue ThreadError
+          break
+        end
+
+        flush_interactive_markdown_deltas(markdown_chunks, stream_state, force: force)
+      end
+
+      def handle_interactive_event(event, markdown_chunks, stream_state)
+        case event
+        when Events::ReasoningDelta
+          stream_state[:streamed] = true
+          append_markdown_delta(markdown_chunks, "Reasoning", event.delta)
+        when Events::AssistantDelta
+          stream_state[:streamed] = true
+          append_markdown_delta(markdown_chunks, "Assistant", event.delta)
+        when Events::SteeringApplied
+          @prompt.clear_steered_count if @prompt.respond_to?(:clear_steered_count)
+        when Events::Retry
+          stream_state[:streamed] = true
+          finish_interactive_markdown_deltas(markdown_chunks, stream_state)
+          print_retry(event)
+        when Events::ToolCall
+          stream_state[:streamed] = true
+          finish_interactive_markdown_deltas(markdown_chunks, stream_state)
+          print_tool_call(event.tool_call)
+        when Events::ToolResult
+          stream_state[:streamed] = true
+          finish_interactive_markdown_deltas(markdown_chunks, stream_state)
+          update_session_diff(event.content, tool_call: event.tool_call)
+          print_tool_result(event.tool_call, event.content, line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
+        end
+      end
+
+      def flush_interactive_markdown_deltas(markdown_chunks, stream_state, force: false)
+        if force
+          finish_interactive_markdown_deltas(markdown_chunks, stream_state)
+          return
+        end
+        return if markdown_chunks.empty?
+        return unless monotonic_now - stream_state[:last_flush] >= STREAM_RENDER_INTERVAL
+
+        chunks_to_flush = markdown_chunks
+        if stream_state[:defer_assistant_streaming]
+          chunks_to_flush, delayed_chunks = split_deferred_assistant_entries(markdown_chunks)
+          return if chunks_to_flush.empty?
+
+          markdown_chunks.replace(delayed_chunks)
+        end
+
+        stream_state[:stream_block_open] = true if flush_markdown_deltas(chunks_to_flush, finish: false, streams: stream_state[:markdown_streams])
+        stream_state[:last_flush] = monotonic_now
+      end
+
+      def finish_interactive_markdown_deltas(markdown_chunks, stream_state)
+        wrote = flush_markdown_deltas(markdown_chunks, streams: stream_state[:markdown_streams])
+        finish_stream_block if stream_state[:stream_block_open] && !wrote
+        stream_state[:stream_block_open] = false
+        stream_state[:last_flush] = monotonic_now
+      end
+
+      def split_deferred_assistant_entries(markdown_chunks)
+        markdown_chunks.partition { |label, _content| label != "Assistant" }
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def collect_queued_input(queued_inputs)
+        collect_busy_input(queued_inputs, nil)
+      end
+
+      def collect_busy_input(queued_inputs, steering)
+        return nil if @prompt.respond_to?(:modal_active?) && @prompt.modal_active?
+
+        poll_result = @prompt.poll_input
+        case poll_result
+        when String
+          if steering && !poll_result.strip.empty?
+            begin
+              steering.submit(poll_result)
+              @prompt.set_steered_count(1) if @prompt.respond_to?(:set_steered_count)
+            rescue StandardError
+              queued_inputs << poll_result
+              @prompt.set_queued_count(queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
+            end
+          else
+            queued_inputs << poll_result unless poll_result.strip.empty?
+            @prompt.set_queued_count(queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
+          end
+        when PromptInterface::EXIT_INPUT
+          queued_inputs << "/exit"
+          @prompt.set_queued_count(queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
+        end
+        poll_result
+      end
+
+      def drain_queued_input(queued_inputs)
+        drain_busy_input(queued_inputs, nil)
+      end
+
+      def drain_busy_input(queued_inputs, steering)
+        deadline = Time.now + 0.15
+        loop do
+          poll_result = collect_busy_input(queued_inputs, steering)
+          break if Time.now > deadline && poll_result.nil?
+
+          sleep 0.01
+        end
+      end
+
+      def steering_supported?
+        @client.respond_to?(:supports_in_flight_steer?) && @client.supports_in_flight_steer?
+      end
+
+      def defer_assistant_streaming?(agent)
+        return false unless agent.respond_to?(:conversation)
+
+        conversation = agent.conversation
+        model = conversation.respond_to?(:model) && conversation.model ? conversation.model : current_model_id
+        ModelInfo.reasoning_supported?(current_model_provider, model)
+      end
+
+      def run_blocking_interactive_turn(agent, input, display_input: nil)
+        streamed = false
+        markdown_chunks = []
+        answer = agent.ask(input, **agent_display_options(display_input)) do |event|
+          streamed = true if render_blocking_turn_event(event, markdown_chunks, tool_line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
+        end
+        flush_markdown_deltas(markdown_chunks) if streamed
+        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless streamed || answer.to_s.empty?
+        persist_memory_state(agent.conversation) if agent.respond_to?(:conversation)
+        auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation)
+        []
+      end
+
+      def agent_display_options(display_input)
+        display_input.nil? ? {} : { display_input: display_input }
+      end
+
+    end
+  end
+end

data/lib/kward/cli/memory_commands.rb

@@ -0,0 +1,133 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # Interactive memory management commands mixed into the CLI frontend.
+    module MemoryCommands
+      private
+
+      def memory_summarize_command?(argument)
+        subcommand, = argument.to_s.strip.split(/\s+/, 2)
+        ["summarize", "learn"].include?(subcommand)
+      end
+
+      def handle_memory_command(argument, agent)
+        subcommand, rest = argument.to_s.strip.split(/\s+/, 2)
+        manager = Memory::Manager.new
+        case subcommand
+        when "enable"
+          manager.enable
+          agent.conversation.refresh_system_message!
+          @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Memory enabled.\n")
+        when "disable"
+          manager.disable
+          agent.conversation.memory_context = nil
+          agent.conversation.refresh_system_message!
+          @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Memory disabled.\n")
+        when "auto-summary"
+          case rest.to_s.strip
+          when "enable", "on"
+            manager.auto_summary_enable
+            @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Memory auto-summary enabled.\n")
+          when "disable", "off"
+            manager.auto_summary_disable
+            @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Memory auto-summary disabled.\n")
+          else
+            @prompt.say("\nUsage: /memory auto-summary enable|disable\n")
+          end
+        when "core"
+          record = manager.add_core(unquote_argument(rest))
+          @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Added core memory #{record["id"]}.\n")
+        when "add"
+          record = manager.add_soft(unquote_argument(rest), scope: "workspace:#{agent.conversation.workspace_root}")
+          @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Added soft memory #{record["id"]}.\n")
+        when "list"
+          @prompt.say("\n#{format_memory_list(manager.hierarchy(workspace_root: agent.conversation.workspace_root))}\n")
+        when "forget"
+          forgotten = manager.forget_memory(rest.to_s.strip)
+          @prompt.say("\n#{forgotten ? "Forgot #{rest.to_s.strip}." : "No memory found for #{rest.to_s.strip}."}\n")
+        when "promote"
+          record = manager.promote_memory(rest.to_s.strip)
+          @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Promoted memory #{record["id"]}.\n")
+        when "relax"
+          record = manager.relax_core(rest.to_s.strip, workspace_root: agent.conversation.workspace_root)
+          @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Relaxed memory #{record["id"]}.\n")
+        when "inspect"
+          @prompt.say("\n#{JSON.pretty_generate(manager.inspect_memory)}\n")
+        when "why"
+          explanation = agent.conversation.last_memory_retrieval || manager.explain_retrieval
+          @prompt.say("\n#{format_memory_why(explanation)}\n")
+        when "summarize", "learn"
+          records = summarize_memory(agent.conversation, manager: manager)
+          @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} Learned #{records.length} soft #{records.length == 1 ? "memory" : "memories"}.\n")
+        else
+          @prompt.say("\nUsage: /memory enable|disable|auto-summary enable|disable|core <text>|add <text>|list|forget <id>|promote <id>|relax <id>|inspect|why|summarize\n")
+        end
+      rescue StandardError => e
+        @prompt.say("\nMemory command failed: #{e.message}\n")
+      end
+
+      def summarize_memory(conversation, manager: Memory::Manager.new)
+        records = manager.summarize_conversation(conversation, client: @client)
+        @active_session&.update_memory_state(session_memories: conversation.session_memories, last_retrieval: conversation.last_memory_retrieval)
+        records
+      end
+
+      def unquote_argument(text)
+        value = text.to_s.strip
+        value = value[1...-1] if value.length >= 2 && ((value.start_with?("\"") && value.end_with?("\"")) || (value.start_with?("'") && value.end_with?("'")))
+        value
+      end
+
+      def format_memory_list(memories)
+        sections = [
+          ["Global Core Memories:", Array(memories["global_core"])],
+          ["Workspace Core Memories:", Array(memories["workspace_core"])],
+          ["Workspace Soft Memories:", Array(memories["workspace_soft"])]
+        ]
+
+        sections.flat_map do |heading, records|
+          lines = [heading]
+          records.each { |item| lines << "- #{item["id"]} [#{item["scope"]}] #{item["text"]}" }
+          lines << "- none" if records.empty?
+          lines
+        end.join("\n")
+      end
+
+      def format_memory_why(explanation)
+        reasons = Array(explanation["reasons"])
+        return explanation["message"] || "No memories were retrieved." if reasons.empty?
+
+        (["Memory retrieval reasons:"] + reasons.map { |item| "- #{item["id"]} (#{item["layer"]}, score #{item["score"]}): #{Array(item["reasons"]).join("; ")}" }).join("\n")
+      end
+
+      def prepare_memory_context(conversation, input)
+        manager = Memory::Manager.new
+        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!
+      rescue StandardError => e
+        warn "Memory retrieval failed: #{e.message}"
+        nil
+      end
+
+      def persist_memory_state(conversation)
+        @active_session&.update_memory_state(session_memories: conversation.session_memories, last_retrieval: conversation.last_memory_retrieval)
+      rescue StandardError
+        nil
+      end
+
+      def auto_summarize_memory(conversation)
+        manager = Memory::Manager.new
+        return unless manager.enabled? && manager.auto_summary_enabled?
+
+        summarize_memory(conversation, manager: manager)
+      rescue StandardError => e
+        warn "Memory auto-summary failed: #{e.message}"
+        nil
+      end
+
+    end
+  end
+end

data/lib/kward/cli/plugins.rb

@@ -0,0 +1,112 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # Plugin command loading and execution helpers mixed into the CLI frontend.
+    module Plugins
+      private
+
+      def prompt_templates
+        @prompt_templates ||= ConfigFiles.prompt_templates(reserved_commands: BUILTIN_SLASH_COMMAND_NAMES)
+      end
+
+      def plugin_registry
+        @plugin_registry ||= PluginRegistry.load(reserved_commands: reserved_slash_command_names)
+      end
+
+      def plugin_commands
+        plugin_registry.commands
+      end
+
+      def plugin_command_for(command)
+        plugin_registry.command_for(command)
+      end
+
+      def reload_plugins(conversation)
+        @plugin_registry = PluginRegistry.load(reserved_commands: reserved_slash_command_names)
+        conversation.plugin_registry = @plugin_registry if conversation.respond_to?(:plugin_registry=)
+        conversation.refresh_system_message! if conversation.respond_to?(:refresh_system_message!)
+        @prompt.say("\nPlugins reloaded.\n")
+      end
+
+      def reserved_slash_command_names
+        BUILTIN_SLASH_COMMAND_NAMES + prompt_templates.map(&:command)
+      end
+
+      def slash_command_entries
+        prompt_entries = prompt_templates.map do |template|
+          {
+            name: template.command,
+            description: template.description,
+            argument_hint: template.argument_hint
+          }
+        end
+        plugin_entries = plugin_commands.map(&:entry)
+        BUILTIN_SLASH_COMMANDS + prompt_entries + plugin_entries
+      end
+
+      def prompt_template_for(command)
+        prompt_templates.find { |template| template.command == command }
+      end
+
+      def expand_prompt_template(input)
+        PromptCommands.expand(input, templates: prompt_templates, reserved_commands: BUILTIN_SLASH_COMMAND_NAMES)
+      end
+
+      def run_plugin_command(name, argument, agent)
+        command = plugin_command_for(name)
+        return [false, nil] unless command
+
+        agent.conversation.plugin_registry ||= plugin_registry if agent.conversation.respond_to?(:plugin_registry)
+        context = plugin_context(agent.conversation, argument)
+        command.handler.call(argument, context)
+        [true, nil]
+      rescue StandardError => e
+        @prompt.say("\nPlugin command /#{name} error: #{e.message}\n")
+        [true, nil]
+      end
+
+      def plugin_context(conversation, args)
+        PluginRegistry::Context.new(
+          conversation: conversation,
+          args: args,
+          session: @active_session,
+          workspace_root: conversation.workspace_root,
+          say_callback: lambda { |message| @prompt.say("\n#{message}\n") }
+        )
+      end
+
+      def selected_slash_command_input(input)
+        return nil if prompt_interface?
+        return nil unless @prompt.respond_to?(:select)
+        return nil unless input.match?(%r{\A/[^\s/]*\z})
+        return nil if prompt_template_for(input.delete_prefix("/"))
+
+        prefix = input.delete_prefix("/").downcase
+        return nil if slash_command_entries.any? { |entry| entry[:name].downcase == prefix }
+
+        matches = slash_command_entries.select { |entry| entry[:name].downcase.start_with?(prefix) }
+        return nil if matches.empty?
+
+        labels = matches.map { |entry| slash_command_label(entry) }
+        choice = @prompt.select("Slash command>", labels)
+        entry = matches[labels.index(choice)]
+        entry ? "/#{entry[:name]}" : nil
+      end
+
+      def slash_command_label(entry)
+        hint = entry[:argument_hint].to_s.empty? ? "" : " #{entry[:argument_hint]}"
+        description = entry[:description].to_s.empty? ? "" : " - #{entry[:description]}"
+        "/#{entry[:name]}#{hint}#{description}"
+      end
+
+      def notify_plugin_transcript_event(event, conversation)
+        return unless conversation
+        return if plugin_registry.transcript_event_handlers.empty?
+
+        plugin_registry.notify_transcript_event(event, plugin_context(conversation, ""))
+      end
+
+    end
+  end
+end