conductor_ruby 0.1.0 → 0.1.1

data/lib/conductor/agents/guardrail.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module Conductor
+  module Agents
+    # Result of a guardrail check
+    GuardrailResult = Struct.new(:passed, :message, :fixed_output, keyword_init: true) do
+      def initialize(passed:, message: '', fixed_output: nil)
+        super
+      end
+
+      def passed?
+        passed ? true : false
+      end
+    end
+
+    # Validation applied to an agent's input or output.
+    #
+    #   Guardrail.new(name: 'no_pii', position: :output, on_fail: :retry) do |content|
+    #     content =~ SSN ? GuardrailResult.new(passed: false, message: 'Redact it') : GuardrailResult.new(passed: true)
+    #   end
+    #
+    # A guardrail with a block runs as a worker in this process (guardrailType "custom");
+    # one with only a name references a worker running elsewhere ("external").
+    class Guardrail
+      POSITIONS = %w[input output].freeze
+      ON_FAIL = %w[retry raise fix human].freeze
+
+      attr_reader :name, :position, :on_fail, :max_retries, :func
+
+      # @param name [String, nil] required when no block is given
+      # @param position [Symbol, String] :input or :output
+      # @param on_fail [Symbol, String] :retry, :raise, :fix or :human
+      def initialize(name: nil, position: :output, on_fail: :raise, max_retries: 3, func: nil, &block)
+        @position = position.to_s
+        @on_fail = on_fail.to_s
+        raise ConfigurationError, "invalid position #{position.inspect}; use :input or :output" unless POSITIONS.include?(@position)
+        raise ConfigurationError, "invalid on_fail #{on_fail.inspect}; use one of #{ON_FAIL.join(', ')}" unless ON_FAIL.include?(@on_fail)
+        raise ConfigurationError, 'on_fail: :human is only valid for position: :output' if @on_fail == 'human' && @position == 'input'
+        raise ConfigurationError, 'max_retries must be >= 1' if max_retries.to_i < 1
+
+        @func = func || block
+        raise ConfigurationError, 'a guardrail needs a name or a block' if @func.nil? && name.nil?
+
+        @name = (name || 'guardrail').to_s
+        @max_retries = max_retries.to_i
+      end
+
+      # True when the check runs somewhere else (no local implementation)
+      def external?
+        @func.nil?
+      end
+
+      # @param content [String]
+      # @return [GuardrailResult]
+      def check(content)
+        raise Error, "cannot check external guardrail #{@name.inspect} locally" if external?
+
+        result = @func.call(content)
+        return result if result.is_a?(GuardrailResult)
+        return GuardrailResult.new(passed: result) if [true, false].include?(result)
+
+        raise Error, "guardrail #{@name.inspect} must return a GuardrailResult or true/false, got #{result.class}"
+      end
+
+      # Wire discriminator (see ConfigSerializer)
+      def guardrail_type
+        external? ? 'external' : 'custom'
+      end
+
+      def to_s
+        "#<#{self.class.name.split('::').last} #{@name} position=#{@position} on_fail=#{@on_fail}>"
+      end
+      alias inspect to_s
+    end
+
+    # Reject content that matches (mode :block) or fails to match (mode :allow) regex patterns.
+    class RegexGuardrail < Guardrail
+      MODES = %w[block allow].freeze
+
+      attr_reader :pattern_strings, :mode, :message
+
+      # @param patterns [String, Regexp, Array<String, Regexp>]
+      def initialize(patterns, mode: :block, position: :output, on_fail: :raise, name: 'regex_guardrail',
+                     message: nil, max_retries: 3)
+        @mode = mode.to_s
+        raise ConfigurationError, "invalid mode #{mode.inspect}; use :block or :allow" unless MODES.include?(@mode)
+
+        @pattern_strings = Array(patterns).map { |p| p.is_a?(Regexp) ? p.source : p.to_s }
+        @patterns = @pattern_strings.map { |p| Regexp.new(p) }
+        @message = message
+        super(name: name, position: position, on_fail: on_fail, max_retries: max_retries, func: method(:evaluate))
+      end
+
+      def guardrail_type
+        'regex'
+      end
+
+      private
+
+      def evaluate(content)
+        text = content.to_s
+        matched = @patterns.any? { |p| p.match?(text) }
+        if @mode == 'block' && matched
+          GuardrailResult.new(passed: false, message: @message || 'Content matched a blocked pattern.')
+        elsif @mode == 'allow' && !matched
+          GuardrailResult.new(passed: false, message: @message || 'Content did not match any allowed pattern.')
+        else
+          GuardrailResult.new(passed: true)
+        end
+      end
+    end
+
+    # Ask an LLM (on the server) whether content complies with a policy.
+    class LlmGuardrail < Guardrail
+      attr_reader :model, :policy, :max_tokens
+
+      # @param model [String] "provider/model"
+      def initialize(model, policy, position: :output, on_fail: :raise, name: 'llm_guardrail', max_retries: 3,
+                     max_tokens: nil)
+        raise ConfigurationError, 'LlmGuardrail needs a model in "provider/model" form' unless model.to_s.include?('/')
+
+        @model = model
+        @policy = policy
+        @max_tokens = max_tokens
+        super(name: name, position: position, on_fail: on_fail, max_retries: max_retries, func: method(:evaluate))
+      end
+
+      def guardrail_type
+        'llm'
+      end
+
+      private
+
+      # The server compiles this guardrail into an LLM task; there is no local evaluation.
+      def evaluate(_content)
+        GuardrailResult.new(passed: false, message: 'LlmGuardrail is evaluated by the Conductor server')
+      end
+    end
+  end
+end

data/lib/conductor/agents/handoff.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module Conductor
+  module Agents
+    # Rules that transfer control between agents in a team (swarm orchestration).
+    #
+    #   Handoff::OnTextMention.new(target: 'filer', text: 'ACTIONABLE')
+    #   Handoff::OnToolResult.new(target: 'refund', tool_name: 'check_order')
+    #   Handoff::OnCondition.new(target: 'summarizer') { |ctx| ctx['iteration'].to_i > 5 }
+    module Handoff
+      # Base class. +target+ is the receiving agent's name (an Agent is accepted too).
+      class Condition
+        attr_reader :target
+
+        def initialize(target:)
+          @target = target.respond_to?(:name) ? target.name.to_s : target.to_s
+          raise ConfigurationError, 'handoff target is required' if @target.empty?
+        end
+
+        # @param _context [Hash] result, tool_name, tool_result, messages, iteration
+        def should_handoff(_context)
+          false
+        end
+
+        def to_s
+          "#<#{self.class.name.split('::').last} -> #{@target}>"
+        end
+        alias inspect to_s
+
+        protected
+
+        def ctx(context, key)
+          return nil unless context.respond_to?(:key?)
+
+          context.key?(key.to_s) ? context[key.to_s] : context[key.to_sym]
+        end
+      end
+
+      # After a named tool ran (optionally only when its result contains a substring)
+      class OnToolResult < Condition
+        attr_reader :tool_name, :result_contains
+
+        def initialize(target:, tool_name:, result_contains: nil)
+          @tool_name = tool_name.to_s
+          @result_contains = result_contains
+          super(target: target)
+        end
+
+        def should_handoff(context)
+          return false unless ctx(context, :tool_name).to_s == @tool_name
+          return true if @result_contains.nil?
+
+          ctx(context, :tool_result).to_s.include?(@result_contains.to_s)
+        end
+      end
+
+      # When the output mentions +text+ (case-insensitive)
+      class OnTextMention < Condition
+        attr_reader :text
+
+        def initialize(target:, text:)
+          @text = text.to_s
+          raise ConfigurationError, 'text is required' if @text.empty?
+
+          super(target: target)
+        end
+
+        def should_handoff(context)
+          ctx(context, :result).to_s.downcase.include?(@text.downcase)
+        end
+      end
+
+      # When a block returns true; runs as the <agent>_handoff_<target> worker
+      class OnCondition < Condition
+        attr_reader :condition
+
+        def initialize(target:, condition: nil, &block)
+          @condition = condition || block
+          raise ConfigurationError, 'OnCondition needs a block' if @condition.nil?
+
+          super(target: target)
+        end
+
+        def should_handoff(context)
+          @condition.call(context) ? true : false
+        rescue StandardError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/conductor/agents/memory.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Agents
+    # Conversation history seeded into the agent (memory: on Agent). Messages are
+    # prepended to the LLM conversation by the server; max_messages trims the oldest
+    # non-system messages first.
+    class ConversationMemory
+      attr_reader :messages, :max_messages
+
+      def initialize(messages: [], max_messages: nil)
+        @messages = messages.map { |m| m.transform_keys(&:to_s) }
+        @max_messages = max_messages
+        trim
+      end
+
+      def add_user_message(content)
+        push('role' => 'user', 'message' => content.to_s)
+      end
+
+      def add_assistant_message(content)
+        push('role' => 'assistant', 'message' => content.to_s)
+      end
+
+      def add_system_message(content)
+        push('role' => 'system', 'message' => content.to_s)
+      end
+
+      def add_tool_call(tool_name, arguments, task_reference_name: nil)
+        ref = task_reference_name || "#{tool_name}_ref"
+        push('role' => 'tool_call', 'message' => '',
+             'tool_calls' => [{ 'name' => tool_name.to_s, 'taskReferenceName' => ref, 'input' => arguments }])
+      end
+
+      def add_tool_result(tool_name, result, task_reference_name: nil)
+        ref = task_reference_name || "#{tool_name}_ref"
+        push('role' => 'tool', 'message' => result.to_s, 'toolCallId' => ref, 'taskReferenceName' => ref)
+      end
+
+      # Deep copy of the messages
+      def to_chat_messages
+        Marshal.load(Marshal.dump(@messages))
+      end
+
+      def clear
+        @messages.clear
+      end
+
+      def empty?
+        @messages.empty?
+      end
+
+      private
+
+      def push(message)
+        @messages << message
+        trim
+      end
+
+      def trim
+        return unless @max_messages && @messages.size > @max_messages
+
+        system_msgs, others = @messages.partition { |m| m['role'] == 'system' }
+        if system_msgs.size >= @max_messages
+          @messages = system_msgs.last(@max_messages)
+          return
+        end
+
+        keep = @max_messages - system_msgs.size
+        dropped = others.first(others.size - keep)
+        @messages = @messages.reject { |m| dropped.any? { |d| d.equal?(m) } }
+      end
+    end
+  end
+end

data/lib/conductor/agents/plans.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'agent'
+
+module Conductor
+  module Agents
+    # Build the server-side planner, optional recovery agent, and coordinator.
+    module Plans
+      def plan_execute(name:, tools:, model:, planner_instructions: '', fallback_instructions: nil,
+                       fallback_max_turns: nil, planner_context: [])
+        planner = Agent.new(name: "#{name}_planner", model: model, instructions: planner_instructions)
+        unless fallback_instructions.nil? || fallback_instructions.empty?
+          fallback = Agent.new(name: "#{name}_fallback", model: model,
+                               instructions: fallback_instructions, tools: tools)
+        end
+        Agent.new(name: name, model: model, strategy: :plan_execute, tools: tools,
+                  planner: planner, fallback: fallback, fallback_max_turns: fallback_max_turns,
+                  planner_context: planner_context)
+      end
+    end
+  end
+end

data/lib/conductor/agents/prompt_template.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Agents
+    # Reference to a prompt template stored on the server, used as Agent#instructions.
+    class PromptTemplate
+      attr_reader :name, :variables, :version
+
+      def initialize(name:, variables: {}, version: nil)
+        @name = name.to_s
+        @variables = variables || {}
+        @version = version
+      end
+
+      def to_h
+        h = { 'type' => 'prompt_template', 'name' => @name }
+        h['variables'] = @variables unless @variables.empty?
+        h['version'] = @version unless @version.nil?
+        h
+      end
+    end
+  end
+end

data/lib/conductor/agents/runtime/agent_config.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Agents
+    # Runtime knobs, read from CONDUCTOR_AGENT_* environment variables (same names and
+    # defaults as the Python SDK's AgentConfig).
+    class AgentConfig
+      TRUE_VALUES = %w[true 1 yes on].freeze
+      FALSE_VALUES = %w[false 0 no off].freeze
+
+      attr_accessor :worker_poll_interval_ms, :worker_thread_count, :auto_register_integrations,
+                    :streaming_enabled, :status_poll_interval_seconds, :system_worker_thread_count
+
+      def initialize(worker_poll_interval_ms: 100, worker_thread_count: 1, auto_register_integrations: false,
+                     streaming_enabled: true, status_poll_interval_seconds: 0.5, system_worker_thread_count: 10)
+        @worker_poll_interval_ms = worker_poll_interval_ms
+        @worker_thread_count = worker_thread_count
+        @auto_register_integrations = auto_register_integrations
+        @streaming_enabled = streaming_enabled
+        @status_poll_interval_seconds = status_poll_interval_seconds
+        @system_worker_thread_count = system_worker_thread_count
+      end
+
+      # @param env [Hash] defaults to ENV
+      def self.from_env(env = ENV)
+        new(
+          worker_poll_interval_ms: int(env, 'CONDUCTOR_AGENT_WORKER_POLL_INTERVAL', 100),
+          worker_thread_count: int(env, 'CONDUCTOR_AGENT_WORKER_THREADS', 1),
+          auto_register_integrations: bool(env, 'CONDUCTOR_AGENT_INTEGRATIONS_AUTO_REGISTER', false),
+          streaming_enabled: bool(env, 'CONDUCTOR_AGENT_STREAMING_ENABLED', true)
+        )
+      end
+
+      def self.int(env, key, default)
+        raw = env[key].to_s.strip
+        raw.empty? ? default : Integer(raw, 10)
+      rescue ArgumentError
+        default
+      end
+
+      def self.bool(env, key, default)
+        raw = env[key].to_s.strip.downcase
+        return default if raw.empty?
+        return true if TRUE_VALUES.include?(raw)
+        return false if FALSE_VALUES.include?(raw)
+
+        default
+      end
+      private_class_method :int, :bool
+    end
+  end
+end

data/lib/conductor/agents/runtime/agent_runtime.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'logger'
+require 'set'
+require_relative '../errors'
+require_relative '../config_serializer'
+require_relative 'agent_config'
+require_relative 'execution'
+require_relative 'approval_request'
+require_relative 'sse_client'
+require_relative 'status_poller'
+require_relative 'tool_registry'
+require_relative '../../client/agent_client'
+require_relative '../../worker/task_handler'
+
+module Conductor
+  module Agents
+    # Runs agents against a Conductor server: serializes the agentConfig, starts the
+    # execution, registers the workers the server asks for, and streams the result.
+    #
+    #   runtime = Conductor::Agents::AgentRuntime.new(configuration: Conductor::Configuration.new)
+    #   runtime.call_sync(agent, 'Weather in Lisbon?')
+    #
+    # Conductor::Agents.runtime holds a default instance built from the environment;
+    # Agent#call_sync / #call_async use it.
+    class AgentRuntime
+      attr_reader :configuration, :agent_config, :client, :api_client, :logger
+
+      def initialize(configuration: nil, agent_config: nil, logger: nil, api_client: nil, agent_client: nil)
+        @configuration = configuration || Configuration.new
+        @agent_config = agent_config || AgentConfig.from_env
+        @logger = logger || Logger.new($stdout, level: Logger::INFO, progname: 'conductor-agents')
+        @api_client = api_client || Http::ApiClient.new(configuration: @configuration)
+        @client = agent_client || Client::AgentClient.new(@api_client)
+        @registry = ToolRegistry.new(@agent_config, logger: @logger)
+        @handlers = []
+        @running_workers = Set.new
+        @stream_threads = []
+        @mutex = Mutex.new
+      end
+
+      # Run and wait for the answer
+      # @return [String]
+      def call_sync(agent, prompt, session_id: nil, timeout: nil, **options)
+        call_async(agent, prompt, session_id: session_id, **options).result(timeout: timeout)
+      end
+
+      # Start the agent and return immediately with an Execution
+      # @param session_id [String, nil] conversation id to continue
+      # @param media [Array<String>, nil], context [Hash, nil], idempotency_key [String, nil], timeout_seconds [Integer, nil]
+      # @yield [answer, execution] runs on the stream thread when the execution finishes
+      # @return [Execution]
+      def call_async(agent, prompt, session_id: nil, media: nil, context: nil, idempotency_key: nil,
+                     timeout_seconds: nil, on_event: nil, &on_done)
+        payload = start_payload(agent, prompt, session_id: session_id, media: media, context: context,
+                                               idempotency_key: idempotency_key, timeout_seconds: timeout_seconds)
+        response = @client.start_agent(payload)
+        execution_id = response['executionId'] || raise(Error, "server returned no executionId: #{response.inspect}")
+
+        execution = Execution.new(execution_id, client: @client, agent_name: response['agentName'] || agent.name, runtime: self)
+        start_workers(agent, response['requiredWorkers'], domain: payload['runId'])
+        attach(execution, agent: agent, on_event: on_event, &on_done)
+        execution
+      end
+
+      # Register agents on the server without running them
+      # @return [Array<String>] deployed agent names
+      def deploy(*agents)
+        agents.flatten.map do |agent|
+          response = @client.deploy_agent('agentConfig' => ConfigSerializer.serialize(agent))
+          response['agentName'] || agent.name
+        end
+      end
+
+      # Compile without registering: { "workflowDef", "requiredWorkers" }
+      def compile(agent)
+        @client.compile_agent('agentConfig' => ConfigSerializer.serialize(agent))
+      end
+
+      # Deploy, start workers for every tool, and (by default) block until INT/TERM
+      def serve(*agents, blocking: true)
+        agents = agents.flatten
+        agents.each do |agent|
+          response = @client.deploy_agent('agentConfig' => ConfigSerializer.serialize(agent))
+          start_workers(agent, response['requiredWorkers'], domain: nil)
+        end
+        return self unless blocking
+
+        wait_for_signal
+        shutdown
+        self
+      end
+
+      # Follow an execution on a background thread (used by call_async and Execution#result)
+      def attach(execution, agent: nil, on_event: nil, &on_done)
+        execution.attached!
+        thread = Thread.new do
+          Thread.current.name = "conductor-agent-stream-#{execution.execution_id}"
+          follow(execution, agent, on_event: on_event, &on_done)
+        end
+        @mutex.synchronize { @stream_threads << thread }
+        thread
+      end
+
+      # Stop workers and stream threads
+      def shutdown(timeout: 5)
+        handlers, threads = @mutex.synchronize do
+          h = @handlers.dup
+          t = @stream_threads.dup
+          @handlers.clear
+          @stream_threads.clear
+          @running_workers.clear
+          [h, t]
+        end
+        handlers.each { |h| h.stop(timeout: timeout) }
+        threads.each do |t|
+          t.join(timeout)
+          t.kill if t.alive?
+        end
+        self
+      end
+
+      # Names of the workers currently polling
+      def running_workers
+        @mutex.synchronize { @running_workers.map(&:first) }
+      end
+
+      # Build the AgentStartRequest body
+      def start_payload(agent, prompt, session_id: nil, media: nil, context: nil, idempotency_key: nil, timeout_seconds: nil)
+        payload = {
+          'agentConfig' => ConfigSerializer.serialize(agent),
+          'prompt' => prompt.to_s,
+          'sessionId' => session_id.to_s,
+          'media' => Array(media)
+        }
+        payload['context'] = context if context && !context.empty?
+        payload['idempotencyKey'] = idempotency_key if idempotency_key
+        payload['timeoutSeconds'] = timeout_seconds if timeout_seconds
+        payload['runId'] = SecureRandom.hex(16) if agent.stateful_tree?
+        payload
+      end
+
+      private
+
+      # Start workers for the tools and system tasks the server requires (skipping ones already polling)
+      def start_workers(agent, required_workers, domain:)
+        workers = @registry.workers_for(agent, required_workers: required_workers, domain: domain)
+        fresh = @mutex.synchronize do
+          workers.reject { |w| @running_workers.include?([w.task_definition_name, w.domain]) }
+                 .each { |w| @running_workers << [w.task_definition_name, w.domain] }
+        end
+        return if fresh.empty?
+
+        handler = Worker::TaskHandler.new(workers: fresh, configuration: @configuration, logger: @logger,
+                                          scan_for_annotated_workers: false, register_task_definitions: true)
+        handler.start
+        @mutex.synchronize { @handlers << handler }
+        @logger.info("agent workers started: #{fresh.map(&:task_definition_name).join(', ')}")
+      end
+
+      def follow(execution, agent, on_event: nil, &on_done)
+        events = event_source(execution.execution_id)
+        events.each do |event|
+          handle_event(execution, agent, event)
+          run_callback(on_event, event) if on_event
+          break if execution.done?
+        end
+        execution.fail('stream ended before the execution finished') unless execution.done?
+      rescue StandardError => e
+        @logger.error("stream for #{execution.execution_id} failed: #{e.class}: #{e.message}")
+        execution.fail("#{e.class}: #{e.message}") unless execution.done?
+      ensure
+        run_callback(on_done, execution.answer, execution) if on_done
+      end
+
+      def event_source(execution_id)
+        poller = StatusPoller.new(@client, interval: @agent_config.status_poll_interval_seconds, logger: @logger)
+        return poller.each_event(execution_id) unless @agent_config.streaming_enabled
+
+        sse = SseClient.new(@api_client, logger: @logger)
+        Enumerator.new do |y|
+          sse.each_event(execution_id) { |ev| y << ev }
+        rescue SseUnavailableError => e
+          @logger.info("SSE unavailable (#{e.message}); polling status instead")
+          poller.each_event(execution_id) { |ev| y << ev }
+        end
+      end
+
+      def handle_event(execution, agent, event)
+        data = event['data'] || {}
+        execution.record_event(event)
+        case event['event'].to_s
+        when 'message'
+          execution.append_text(data['content'])
+        when 'tool_call'
+          execution.add_tool_call(data['toolName'], strip_injected(data['args']))
+        when 'tool_result'
+          execution.add_tool_result(data['toolName'], data['result'])
+        when 'waiting'
+          handle_waiting(execution, agent, data)
+        when 'done'
+          execution.token_usage = fetch_token_usage(execution.execution_id)
+          execution.finish(status: 'COMPLETED', output: data['output'] || {})
+        when 'error'
+          execution.finish(status: data['status'] || 'FAILED', output: data['output'] || {},
+                           reason: data['content'] || 'execution failed')
+        end
+      end
+
+      def handle_waiting(execution, agent, data)
+        pending = data['pendingTool'] || {}
+        request = ApprovalRequest.new(execution.execution_id, pending, client: @client, execution: execution)
+        execution.mark_waiting(request)
+        handler = agent&.approval_handler
+        return if handler.nil? || request.tool_calls.empty?
+
+        run_callback(handler, request)
+      end
+
+      def run_callback(callable, *args)
+        callable.call(*args)
+      rescue StandardError => e
+        @logger.error("callback raised #{e.class}: #{e.message}")
+      end
+
+      def strip_injected(args)
+        return {} unless args.is_a?(Hash)
+
+        args.reject { |k, _| Dispatch::INJECTED_KEYS.include?(k.to_s) }
+      end
+
+      # Sum tokenUsage over the execution and its sub-agent executions
+      def fetch_token_usage(execution_id, visited = Set.new)
+        return TokenUsage.new if visited.include?(execution_id) || visited.size > 50
+
+        visited << execution_id
+        run = @client.get_execution(execution_id)
+        usage = run['tokenUsage'] || {}
+        total = TokenUsage.new(prompt_tokens: usage['promptTokens'].to_i, completion_tokens: usage['completionTokens'].to_i,
+                               total_tokens: usage['totalTokens'].to_i)
+        Array(run['tasks']).each do |task|
+          sub = task['subWorkflowId']
+          total += fetch_token_usage(sub, visited) if sub && !sub.to_s.empty?
+        end
+        total
+      rescue StandardError => e
+        @logger.debug("token usage unavailable for #{execution_id}: #{e.message}")
+        TokenUsage.new
+      end
+
+      def wait_for_signal
+        queue = Queue.new
+        %w[INT TERM].each { |sig| trap(sig) { queue << sig } }
+        @logger.info('serving agents; press Ctrl-C to stop')
+        queue.pop
+      end
+    end
+  end
+end