conductor_ruby 0.1.0 → 0.1.1

data/lib/conductor/agents/termination.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module Conductor
+  module Agents
+    # Composable rules that decide when an agent loop stops.
+    #
+    #   stop = Termination::TextMention.new('DONE') | Termination::MaxMessage.new(20)
+    #   Agent.new(..., termination: stop)
+    #
+    # Conditions serialize to the server (ConfigSerializer) and the same objects back the
+    # local <agent>_termination worker the server asks for.
+    module Termination
+      Result = Struct.new(:should_terminate, :reason, keyword_init: true) do
+        def initialize(should_terminate:, reason: '')
+          super
+        end
+      end
+
+      # Base class. Context keys: result, messages, iteration, token_usage (String or Symbol keys).
+      class Condition
+        def should_terminate(_context)
+          raise NotImplementedError
+        end
+
+        def &(other)
+          And.new(self, other)
+        end
+
+        def |(other)
+          Or.new(self, other)
+        end
+
+        def to_s
+          "#<#{self.class.name.split('::').last}>"
+        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
+
+      # Stop when the output contains +text+
+      class TextMention < Condition
+        attr_reader :text, :case_sensitive
+
+        def initialize(text, case_sensitive: false)
+          raise ConfigurationError, 'text is required' if text.to_s.empty?
+
+          @text = text.to_s
+          @case_sensitive = case_sensitive ? true : false
+          super()
+        end
+
+        def should_terminate(context)
+          result = ctx(context, :result).to_s
+          needle = @text
+          unless @case_sensitive
+            result = result.downcase
+            needle = needle.downcase
+          end
+          return Result.new(should_terminate: true, reason: "Text '#{@text}' found in output") if result.include?(needle)
+
+          Result.new(should_terminate: false)
+        end
+      end
+
+      # Stop when the whole output (stripped) equals +stop_message+
+      class StopMessage < Condition
+        attr_reader :stop_message
+
+        def initialize(stop_message = 'TERMINATE')
+          @stop_message = stop_message.to_s
+          super()
+        end
+
+        def should_terminate(context)
+          return Result.new(should_terminate: true, reason: "Stop message '#{@stop_message}' received") if ctx(context, :result).to_s.strip == @stop_message
+
+          Result.new(should_terminate: false)
+        end
+      end
+
+      # Stop after +max_messages+ messages (falls back to the loop iteration count)
+      class MaxMessage < Condition
+        attr_reader :max_messages
+
+        def initialize(max_messages)
+          raise ConfigurationError, 'max_messages must be >= 1' unless max_messages.is_a?(Integer) && max_messages >= 1
+
+          @max_messages = max_messages
+          super()
+        end
+
+        def should_terminate(context)
+          messages = ctx(context, :messages)
+          count = messages.is_a?(Array) ? messages.size : 0
+          count = ctx(context, :iteration).to_i if count.zero?
+          return Result.new(should_terminate: true, reason: "Message count (#{count}) >= limit (#{@max_messages})") if count >= @max_messages
+
+          Result.new(should_terminate: false)
+        end
+      end
+
+      # Stop when token usage crosses a budget
+      class TokenUsage < Condition
+        attr_reader :max_total_tokens, :max_prompt_tokens, :max_completion_tokens
+
+        def initialize(max_total_tokens: nil, max_prompt_tokens: nil, max_completion_tokens: nil)
+          raise ConfigurationError, 'at least one token limit must be specified' if [max_total_tokens, max_prompt_tokens, max_completion_tokens].all?(&:nil?)
+
+          @max_total_tokens = max_total_tokens
+          @max_prompt_tokens = max_prompt_tokens
+          @max_completion_tokens = max_completion_tokens
+          super()
+        end
+
+        def should_terminate(context)
+          usage = ctx(context, :token_usage)
+          return Result.new(should_terminate: false) unless usage.respond_to?(:key?)
+
+          checks = [
+            [@max_total_tokens, usage_value(usage, 'total_tokens', 'totalTokens'), 'Total'],
+            [@max_prompt_tokens, usage_value(usage, 'prompt_tokens', 'promptTokens'), 'Prompt'],
+            [@max_completion_tokens, usage_value(usage, 'completion_tokens', 'completionTokens'), 'Completion']
+          ]
+          checks.each do |limit, value, label|
+            next if limit.nil? || value < limit
+
+            return Result.new(should_terminate: true, reason: "#{label} tokens (#{value}) >= limit (#{limit})")
+          end
+          Result.new(should_terminate: false)
+        end
+
+        private
+
+        def usage_value(usage, *keys)
+          keys.each do |k|
+            v = usage[k] || usage[k.to_sym]
+            return v.to_i unless v.nil?
+          end
+          0
+        end
+      end
+
+      # All children must trigger
+      class And < Condition
+        attr_reader :conditions
+
+        def initialize(*conditions)
+          @conditions = conditions.flat_map { |c| c.is_a?(And) ? c.conditions : [c] }
+          super()
+        end
+
+        def should_terminate(context)
+          reasons = []
+          @conditions.each do |c|
+            r = c.should_terminate(context)
+            return Result.new(should_terminate: false) unless r.should_terminate
+
+            reasons << r.reason unless r.reason.to_s.empty?
+          end
+          Result.new(should_terminate: true, reason: reasons.join(' AND '))
+        end
+      end
+
+      # Any child triggers
+      class Or < Condition
+        attr_reader :conditions
+
+        def initialize(*conditions)
+          @conditions = conditions.flat_map { |c| c.is_a?(Or) ? c.conditions : [c] }
+          super()
+        end
+
+        def should_terminate(context)
+          @conditions.each do |c|
+            r = c.should_terminate(context)
+            return r if r.should_terminate
+          end
+          Result.new(should_terminate: false)
+        end
+      end
+    end
+  end
+end

data/lib/conductor/agents/tool.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'errors'
+
+module Conductor
+  module Agents
+    # Wire values for ToolConfig#toolType. Only +worker+ and +cli+ tools run in this
+    # process; every other type is executed by the Conductor server.
+    module ToolType
+      WORKER = 'worker'
+      HTTP = 'http'
+      API = 'api'
+      MCP = 'mcp'
+      HUMAN = 'human'
+      AGENT_TOOL = 'agent_tool'
+      GENERATE_IMAGE = 'generate_image'
+      GENERATE_AUDIO = 'generate_audio'
+      GENERATE_VIDEO = 'generate_video'
+      GENERATE_PDF = 'generate_pdf'
+      RAG_INDEX = 'rag_index'
+      RAG_SEARCH = 'rag_search'
+      PULL_WORKFLOW_MESSAGES = 'pull_workflow_messages'
+      CLI = 'cli'
+
+      MEDIA = [GENERATE_IMAGE, GENERATE_AUDIO, GENERATE_VIDEO, GENERATE_PDF].freeze
+      RAG = [RAG_INDEX, RAG_SEARCH].freeze
+      LOCAL = [WORKER, CLI].freeze
+      ALL = [WORKER, HTTP, API, MCP, HUMAN, AGENT_TOOL, *MEDIA, *RAG, PULL_WORKFLOW_MESSAGES, CLI].freeze
+
+      def self.valid?(type)
+        ALL.include?(type.to_s)
+      end
+    end
+
+    # A tool call with pre-filled arguments (Agent#prefill_tools)
+    PrefillToolCall = Struct.new(:tool_name, :arguments, :tool, keyword_init: true) do
+      def to_h
+        { 'toolName' => tool_name, 'arguments' => arguments || {} }
+      end
+    end
+
+    # A tool an agent can call. This is the developer-facing type: the counterpart of
+    # the Java SDK's @Tool / HttpTool / McpTool builders and the Python SDK's @tool /
+    # http_tool / mcp_tool functions. The wire-level tool config the server receives is
+    # produced by ConfigSerializer and never handed to developers.
+    #
+    # Worker tools are created by the Tools DSL (+tool def ...+); server-side tools by
+    # the factories below (Tool.http, .mcp, .human, .agent, ...).
+    class Tool
+      RETRY_POLICIES = %w[fixed linear_backoff exponential_backoff].freeze
+      RETRY_LOGIC = {
+        'fixed' => 'FIXED',
+        'linear_backoff' => 'LINEAR_BACKOFF',
+        'exponential_backoff' => 'EXPONENTIAL_BACKOFF'
+      }.freeze
+      CREDENTIAL_PLACEHOLDER = /\$\{(\w+)\}/
+
+      attr_accessor :name, :description, :input_schema, :output_schema, :func,
+                    :approval_required, :timeout_seconds, :tool_type, :config,
+                    :guardrails, :credentials, :stateful, :max_calls,
+                    :retry_count, :retry_delay_seconds, :retry_policy
+
+      # @param name [String] tool name; for worker tools this is also the Conductor task name
+      # @param func [Proc, Method, nil] local implementation; nil for server-side tools
+      def initialize(name:, description: '', input_schema: nil, output_schema: nil, func: nil,
+                     approval_required: false, timeout_seconds: nil, tool_type: ToolType::WORKER,
+                     config: nil, guardrails: nil, credentials: nil, stateful: false, max_calls: nil,
+                     retry_count: 2, retry_delay_seconds: 2, retry_policy: 'linear_backoff')
+        raise ConfigurationError, 'tool name is required' if name.nil? || name.to_s.empty?
+        raise ConfigurationError, "unknown tool_type #{tool_type.inspect}" unless ToolType.valid?(tool_type)
+        unless RETRY_POLICIES.include?(retry_policy.to_s) || RETRY_LOGIC.value?(retry_policy.to_s)
+          raise ConfigurationError, "retry_policy must be one of #{RETRY_POLICIES.join(', ')}"
+        end
+
+        @name = name.to_s
+        @description = description.to_s
+        @input_schema = input_schema || {}
+        @output_schema = output_schema || {}
+        @func = func
+        @approval_required = approval_required ? true : false
+        @timeout_seconds = timeout_seconds
+        @tool_type = tool_type.to_s
+        @config = config || {}
+        @guardrails = Array(guardrails)
+        @credentials = Array(credentials).map(&:to_s).uniq
+        @stateful = stateful ? true : false
+        @max_calls = max_calls
+        @retry_count = retry_count
+        @retry_delay_seconds = retry_delay_seconds
+        @retry_policy = retry_policy.to_s
+      end
+
+      # True when this tool needs a worker polling in this process
+      def local?
+        !@func.nil? && ToolType::LOCAL.include?(@tool_type)
+      end
+
+      def server_side?
+        !local?
+      end
+
+      # Conductor retryLogic value for this tool's retry policy
+      def retry_logic
+        RETRY_LOGIC.fetch(@retry_policy) { @retry_policy.upcase }
+      end
+
+      # Add secret names this tool needs (deduplicated)
+      # @return [self]
+      def add_credentials(*names)
+        @credentials = (@credentials + names.flatten.map(&:to_s)).uniq
+        self
+      end
+
+      # A copy of this tool guarded by +guardrails+ (replaces any existing ones)
+      # @return [Tool]
+      def with_guardrails(*guardrails)
+        copy = dup
+        copy.guardrails = guardrails.flatten
+        copy
+      end
+
+      # Build a pre-filled call for Agent#prefill_tools
+      def call(**args)
+        PrefillToolCall.new(tool_name: @name, arguments: args.transform_keys(&:to_s), tool: self)
+      end
+
+      def to_s
+        "#<Conductor::Agents::Tool #{@name} (#{@tool_type})>"
+      end
+      alias inspect to_s
+
+      class << self
+        # Tool backed by an HTTP endpoint; the server makes the call.
+        # Headers may reference secrets as ${NAME}; every placeholder must be listed in +credentials+.
+        def http(name, url, description: '', method: 'GET', headers: nil, input_schema: nil,
+                 accept: ['application/json'], content_type: 'application/json', credentials: nil)
+          creds = Array(credentials).map(&:to_s)
+          validate_placeholders!(headers, creds)
+          new(
+            name: name, description: description,
+            input_schema: input_schema || { 'type' => 'object', 'properties' => {} },
+            tool_type: ToolType::HTTP,
+            config: { 'url' => url, 'method' => method.to_s.upcase, 'headers' => headers || {},
+                      'accept' => accept, 'contentType' => content_type },
+            credentials: creds
+          )
+        end
+
+        # Tools discovered from an OpenAPI endpoint; the server does the discovery.
+        def api(url, name: 'api_tools', description: nil, headers: nil, tool_names: nil, max_tools: 64, credentials: nil)
+          creds = Array(credentials).map(&:to_s)
+          validate_placeholders!(headers, creds)
+          config = { 'url' => url }
+          config['headers'] = headers if headers
+          config['tool_names'] = Array(tool_names) if tool_names
+          config['max_tools'] = max_tools
+          new(name: name, description: description || "API tools from #{url}", tool_type: ToolType::API,
+              config: config, credentials: creds)
+        end
+
+        # Tools served by an MCP server; discovery (LIST_MCP_TOOLS) and calls happen on the server.
+        def mcp(server_url, name: 'mcp_tools', description: nil, headers: nil, tool_names: nil,
+                max_tools: 64, credentials: nil)
+          creds = Array(credentials).map(&:to_s)
+          validate_placeholders!(headers, creds)
+          config = { 'server_url' => server_url }
+          config['headers'] = headers if headers
+          config['tool_names'] = Array(tool_names) if tool_names
+          config['max_tools'] = max_tools
+          new(name: name, description: description || "MCP tools from #{server_url}", tool_type: ToolType::MCP,
+              config: config, credentials: creds)
+        end
+
+        # Tool that pauses for a human answer (Conductor HUMAN task)
+        def human(name, description:, input_schema: nil)
+          new(
+            name: name, description: description, tool_type: ToolType::HUMAN,
+            input_schema: input_schema || {
+              'type' => 'object',
+              'properties' => { 'question' => { 'type' => 'string',
+                                                'description' => 'The question or request for the human operator.' } },
+              'required' => ['question']
+            }
+          )
+        end
+
+        # Another agent exposed as a tool (runs as a sub-workflow)
+        def agent(agent, name: nil, description: nil, retry_count: nil, retry_delay_seconds: nil, optional: nil)
+          agent_name = agent.respond_to?(:name) ? agent.name : agent.to_s
+          config = { 'agent' => agent }
+          config['retryCount'] = retry_count unless retry_count.nil?
+          config['retryDelaySeconds'] = retry_delay_seconds unless retry_delay_seconds.nil?
+          config['optional'] = optional unless optional.nil?
+          new(
+            name: name || agent_name,
+            description: description || "Invoke the #{agent_name} agent",
+            input_schema: {
+              'type' => 'object',
+              'properties' => { 'request' => { 'type' => 'string',
+                                               'description' => 'The request or question to send to this agent.' } },
+              'required' => ['request']
+            },
+            tool_type: ToolType::AGENT_TOOL,
+            config: config
+          )
+        end
+
+        # Media generation tools (server-side)
+        def image(name, description:, llm_provider:, model:, input_schema: nil, **defaults)
+          media(ToolType::GENERATE_IMAGE, 'GENERATE_IMAGE', name, description, llm_provider, model, input_schema, defaults)
+        end
+
+        def audio(name, description:, llm_provider:, model:, input_schema: nil, **defaults)
+          media(ToolType::GENERATE_AUDIO, 'GENERATE_AUDIO', name, description, llm_provider, model, input_schema, defaults)
+        end
+
+        def video(name, description:, llm_provider:, model:, input_schema: nil, **defaults)
+          media(ToolType::GENERATE_VIDEO, 'GENERATE_VIDEO', name, description, llm_provider, model, input_schema, defaults)
+        end
+
+        def pdf(name = 'generate_pdf', description: 'Generate a PDF document.', input_schema: nil, **defaults)
+          new(name: name, description: description, tool_type: ToolType::GENERATE_PDF,
+              input_schema: input_schema || { 'type' => 'object', 'properties' => {} },
+              config: { 'taskType' => 'GENERATE_PDF' }.merge(stringify(defaults)))
+        end
+
+        # RAG tools (server-side)
+        def index(name, description:, vector_db:, index:, embedding_model_provider:, embedding_model:,
+                  namespace: 'default_ns', chunk_size: nil, chunk_overlap: nil, dimensions: nil, input_schema: nil)
+          config = { 'taskType' => 'LLM_INDEX_TEXT', 'vectorDB' => vector_db, 'namespace' => namespace, 'index' => index,
+                     'embeddingModelProvider' => embedding_model_provider, 'embeddingModel' => embedding_model }
+          config['chunkSize'] = chunk_size if chunk_size
+          config['chunkOverlap'] = chunk_overlap if chunk_overlap
+          config['dimensions'] = dimensions if dimensions
+          new(name: name, description: description, tool_type: ToolType::RAG_INDEX,
+              input_schema: input_schema || { 'type' => 'object', 'properties' => {} }, config: config)
+        end
+
+        def search(name, description:, vector_db:, index:, embedding_model_provider:, embedding_model:,
+                   namespace: 'default_ns', max_results: 5, dimensions: nil, input_schema: nil)
+          config = { 'taskType' => 'LLM_SEARCH_INDEX', 'vectorDB' => vector_db, 'namespace' => namespace, 'index' => index,
+                     'embeddingModelProvider' => embedding_model_provider, 'embeddingModel' => embedding_model,
+                     'maxResults' => max_results }
+          config['dimensions'] = dimensions if dimensions
+          new(name: name, description: description, tool_type: ToolType::RAG_SEARCH,
+              input_schema: input_schema || { 'type' => 'object', 'properties' => {} }, config: config)
+        end
+
+        # Wait for messages posted to the execution (PULL_WORKFLOW_MESSAGES)
+        def wait_for_message(name, description:, batch_size: 1, blocking: true)
+          config = { 'batchSize' => batch_size }
+          config['blocking'] = false unless blocking
+          new(name: name, description: description, tool_type: ToolType::PULL_WORKFLOW_MESSAGES,
+              input_schema: { 'type' => 'object', 'properties' => {} }, config: config)
+        end
+
+        private
+
+        def media(tool_type, task_type, name, description, llm_provider, model, input_schema, defaults)
+          new(name: name, description: description, tool_type: tool_type,
+              input_schema: input_schema || { 'type' => 'object', 'properties' => {} },
+              config: { 'taskType' => task_type, 'llmProvider' => llm_provider, 'model' => model }.merge(stringify(defaults)))
+        end
+
+        def stringify(hash)
+          hash.transform_keys(&:to_s)
+        end
+
+        def validate_placeholders!(headers, credentials)
+          return unless headers
+
+          placeholders = headers.to_s.scan(CREDENTIAL_PLACEHOLDER).flatten.uniq
+          missing = placeholders - credentials
+          return if missing.empty?
+
+          raise ConfigurationError,
+                "Header placeholder(s) #{missing.inspect} not declared in credentials: #{credentials.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/conductor/agents/tools/schema_builder.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Agents
+    module Tools
+      # Builds a JSON schema for a tool method from its keyword arguments.
+      #
+      # Ruby exposes keyword names and whether they are required (+Method#parameters+) but
+      # never the default expressions, and the Tools DSL uses the default as the type:
+      #
+      #   tool def get_weather(city: String, units: 'metric', limit: 10, tags: [String], mode: %w[a b])
+      #
+      # so the defaults are read from the method's AST (RubyVM::AbstractSyntaxTree.of). That
+      # works on MRI whenever the method's source file is on disk (and for eval'd code on
+      # Ruby >= 3.2 with RubyVM.keep_script_lines = true). When the AST is unavailable the
+      # builder falls back to Python's behaviour: every keyword becomes an untyped property
+      # ({}), required when the keyword has no default.
+      module SchemaBuilder # rubocop:disable Metrics/ModuleLength
+        CLASS_TYPES = {
+          'String' => 'string', 'Symbol' => 'string',
+          'Integer' => 'integer',
+          'Float' => 'number', 'Numeric' => 'number', 'BigDecimal' => 'number',
+          'TrueClass' => 'boolean', 'FalseClass' => 'boolean',
+          'Hash' => 'object', 'Array' => 'array',
+          'Time' => 'string', 'Date' => 'string', 'DateTime' => 'string'
+        }.freeze
+
+        POSITIONAL = %i[req opt rest].freeze
+
+        module_function
+
+        # @param method [Method, UnboundMethod]
+        # @return [Hash] JSON schema for the tool input
+        def input_schema(method)
+          params = method.parameters
+          positional = params.select { |kind, _| POSITIONAL.include?(kind) }
+          unless positional.empty?
+            raise ConfigurationError,
+                  "tool #{method.name}: use keyword arguments only (found positional #{positional.map(&:last).inspect})"
+          end
+
+          defaults = keyword_defaults(method)
+          properties = {}
+          required = []
+
+          params.each do |kind, name|
+            case kind
+            when :keyreq
+              properties[name.to_s] = defaults.key?(name) ? schema_for(defaults[name]) : {}
+              required << name.to_s
+            when :key
+              if defaults.key?(name)
+                schema, is_required = schema_for_default(defaults[name])
+                properties[name.to_s] = schema
+                required << name.to_s if is_required
+              else
+                properties[name.to_s] = {}
+              end
+            end
+          end
+
+          schema = { 'type' => 'object', 'properties' => properties }
+          schema['required'] = required unless required.empty?
+          schema
+        end
+
+        # Default output schema for worker tools: Dispatch always returns a JSON object
+        def default_output_schema
+          { 'type' => 'object', 'additionalProperties' => {} }
+        end
+
+        # Map keyword name => default AST node, or {} when no AST is available
+        def keyword_defaults(method)
+          ast = ast_of(method)
+          return {} unless ast
+
+          args = find_node(ast, :ARGS)
+          return {} unless args
+
+          kw = args.children[7]
+          result = {}
+          each_node(kw) do |node|
+            next unless node.type == :KW_ARG
+
+            lasgn = node.children[0]
+            next unless lasgn.respond_to?(:type) && lasgn.type == :LASGN
+
+            name, default = lasgn.children
+            # required keywords (city:) carry a Symbol placeholder instead of a default node
+            result[name] = default if default.is_a?(RubyVM::AbstractSyntaxTree::Node)
+          end
+          result
+        end
+
+        def ast_of(method)
+          return nil unless defined?(RubyVM::AbstractSyntaxTree)
+
+          RubyVM::AbstractSyntaxTree.of(method)
+        rescue StandardError
+          nil
+        end
+
+        # Schema for a default that stands for a *type* (class constant or array of one)
+        def schema_for(node)
+          schema_for_default(node).first
+        end
+
+        # @return [Array(Hash, Boolean)] schema and whether the parameter is required
+        def schema_for_default(node)
+          case node.type
+          when :CONST
+            type = CLASS_TYPES[node.children[0].to_s]
+            [type ? { 'type' => type } : {}, true]
+          when :COLON2
+            type = CLASS_TYPES[node.children[1].to_s]
+            [type ? { 'type' => type } : {}, true]
+          when :STR
+            [{ 'type' => 'string', 'default' => node.children[0] }, false]
+          when :DSTR, :XSTR, :DXSTR
+            [{ 'type' => 'string' }, false]
+          when :LIT, :INTEGER, :FLOAT, :RATIONAL, :IMAGINARY
+            literal_schema(node.children[0])
+          when :TRUE
+            [{ 'type' => 'boolean', 'default' => true }, false]
+          when :FALSE
+            [{ 'type' => 'boolean', 'default' => false }, false]
+          when :NIL
+            [{}, false]
+          when :LIST, :ZLIST
+            list_schema(node)
+          when :HASH
+            [{ 'type' => 'object', 'default' => {} }, false]
+          else
+            [{}, false]
+          end
+        end
+
+        def literal_schema(value)
+          case value
+          when Integer then [{ 'type' => 'integer', 'default' => value }, false]
+          when Float then [{ 'type' => 'number', 'default' => value }, false]
+          when Symbol then [{ 'type' => 'string', 'default' => value.to_s }, false]
+          when Regexp then [{ 'type' => 'string', 'pattern' => value.source }, false]
+          else [{}, false]
+          end
+        end
+
+        def list_schema(node)
+          elements = node.type == :ZLIST ? [] : node.children.compact
+          return [{ 'type' => 'array', 'default' => [] }, false] if elements.empty?
+
+          if elements.size == 1 && %i[CONST COLON2].include?(elements[0].type)
+            item, = schema_for_default(elements[0])
+            return [{ 'type' => 'array', 'items' => item }, true]
+          end
+
+          if elements.all? { |e| e.type == :STR }
+            values = elements.map { |e| e.children[0] }
+            return [{ 'type' => 'string', 'enum' => values, 'default' => values.first }, false]
+          end
+
+          if elements.all? { |e| %i[LIT INTEGER].include?(e.type) && e.children[0].is_a?(Integer) }
+            values = elements.map { |e| e.children[0] }
+            return [{ 'type' => 'integer', 'enum' => values, 'default' => values.first }, false]
+          end
+
+          [{ 'type' => 'array' }, false]
+        end
+
+        def find_node(node, type)
+          found = nil
+          each_node(node) do |n|
+            if n.type == type
+              found = n
+              break
+            end
+          end
+          found
+        end
+
+        def each_node(node, &block)
+          return unless node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+
+          block.call(node)
+          node.children.each { |child| each_node(child, &block) }
+        end
+      end
+    end
+  end
+end