little_ghost 0.1.0 → 0.2.0

data/lib/little_ghost/models/catalog.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module LittleGhost
+  # Immutable model identities, metadata, configuration readers, and catalogs.
+  module Models
+    # Resolves model facts from refreshed data and the snapshot packaged with
+    # LittleGhost. Refresh is always explicit.
+    class Catalog
+      ARRAY_ATTRIBUTES = %i[input_modalities output_modalities supported_parameters].freeze # :nodoc:
+
+      # Path to the offline model metadata snapshot packaged with the gem.
+      SNAPSHOT_PATH = File.expand_path("../data/model_catalog.json", __dir__)
+
+      # Builds a layered catalog from bundled and refreshed facts.
+      def initialize(sources: [], snapshot_path: SNAPSHOT_PATH, clock: -> { Time.now.utc })
+        @sources = Array(sources).freeze
+        @snapshot = load_snapshot(snapshot_path)
+        @refreshed = {}
+        @clock = clock
+        @mutex = Mutex.new
+      end
+
+      # Returns immutable normalized details for +target+.
+      def details(target)
+        target = Target.parse(target)
+        records = [@snapshot[target.to_s], @mutex.synchronize { @refreshed[target.to_s] }].compact
+        merge_details(target, records)
+      end
+
+      # Refreshes one target or all models. Failed sources leave the last good
+      # catalog untouched and are returned to the caller for reporting.
+      def refresh!(target: nil)
+        requested = target && Target.parse(target)
+        records = {}
+        errors = []
+        @sources.each do |source|
+          values = source.refresh(target: requested)
+          normalized = normalize_records(
+            values,
+            source.name,
+            attribute_merge_strategies: source.attribute_merge_strategies
+          )
+          records = records.merge(normalized) { |_key, older, newer| merge_records(older, newer) }
+        rescue => error
+          errors << error
+        end
+        @mutex.synchronize { @refreshed = @refreshed.merge(records) { |_key, older, newer| merge_records(older, newer) } } unless records.empty?
+        {updated: records.keys.freeze, errors: errors.freeze}.freeze
+      end
+
+      private
+
+      def load_snapshot(path)
+        return {} unless File.file?(path)
+
+        normalize_records(JSON.parse(File.read(path)), "bundled")
+      rescue JSON::ParserError => error
+        raise ConfigurationError, "Bundled model catalog is invalid: #{error.message}"
+      end
+
+      def normalize_records(values, source, attribute_merge_strategies: {})
+        strategies = normalize_merge_strategies(attribute_merge_strategies)
+        values.to_h.each_with_object({}) do |(target, attributes), result|
+          data = attributes.to_h.transform_keys(&:to_sym)
+          provenance = data.delete(:provenance) || data.keys.to_h { |key| [key, source] }
+          provenance = provenance.to_h { |key, value| [key.to_sym, value] }
+          observed_at = data.delete(:observed_at)
+          validate_array_attributes!(data)
+          record_strategies = strategies.select { |attribute, _strategy| data.key?(attribute) }.freeze
+          validate_strategy_values!(data, record_strategies)
+          result[Target.parse(target).to_s] = {
+            attributes: data,
+            provenance:,
+            observed_at:,
+            attribute_merge_strategies: record_strategies
+          }
+        end
+      end
+
+      def merge_details(target, records)
+        merged = records.reduce({attributes: {}, provenance: {}, observed_at: nil}) { |left, right| merge_records(left, right) }
+        Details.new(
+          target:,
+          attributes: merged.fetch(:attributes),
+          provenance: merged.fetch(:provenance),
+          observed_at: merged[:observed_at]
+        )
+      end
+
+      def merge_records(left, right)
+        attributes = left.fetch(:attributes, {}).merge(right.fetch(:attributes, {}))
+        provenance = left.fetch(:provenance, {}).merge(right.fetch(:provenance, {}))
+        right_strategies = right.fetch(:attribute_merge_strategies, {})
+        apply_attribute_merge_strategies!(attributes, provenance, left, right, right_strategies)
+        strategies = left.fetch(:attribute_merge_strategies, {}).dup
+        right.fetch(:attributes, {}).each_key { |attribute| strategies.delete(attribute) }
+        strategies.merge!(right_strategies).freeze
+        {
+          attributes:,
+          provenance:,
+          observed_at: right[:observed_at] || left[:observed_at],
+          attribute_merge_strategies: strategies
+        }
+      end
+
+      def normalize_merge_strategies(strategies)
+        strategies.to_h.each_with_object({}) do |(attribute, strategy), normalized|
+          unless attribute.is_a?(String) || attribute.is_a?(Symbol)
+            raise ConfigurationError, "Catalog merge strategy attributes must be strings or symbols"
+          end
+          unless strategy == :union || strategy == "union"
+            raise ConfigurationError, "Unsupported catalog merge strategy: #{strategy}"
+          end
+
+          normalized[attribute.to_sym] = :union
+        end.freeze
+      end
+
+      def apply_attribute_merge_strategies!(attributes, provenance, left, right, strategies)
+        strategies.each do |attribute, strategy|
+          existing = left.fetch(:attributes, {})[attribute]
+          refreshed = right.fetch(:attributes, {})[attribute]
+          next unless existing && refreshed
+
+          attributes[attribute] = (existing + refreshed).uniq if strategy == :union
+          previous_source = left.fetch(:provenance, {})[attribute]
+          current_source = right.fetch(:provenance, {})[attribute]
+          sources = [previous_source, current_source].compact.uniq
+          provenance[attribute] = sources.join("+") unless sources.empty?
+        end
+      end
+
+      def validate_strategy_values!(attributes, strategies)
+        strategies.each_key do |attribute|
+          unless attributes.fetch(attribute).is_a?(Array)
+            raise ConfigurationError, "Catalog union attribute #{attribute} must be an array"
+          end
+        end
+      end
+
+      def validate_array_attributes!(attributes)
+        ARRAY_ATTRIBUTES.each do |attribute|
+          value = attributes[attribute]
+          next if value.nil? || value.is_a?(Array)
+
+          raise ConfigurationError, "Catalog attribute #{attribute} must be an array"
+        end
+      end
+    end
+  end
+end

data/lib/little_ghost/models/catalog_snapshot.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+
+module LittleGhost
+  module Models
+    # Generates the deterministic provider-filtered catalog packaged in the gem.
+    module CatalogSnapshot # :nodoc:
+      NAMESPACES = {
+        "amazon-bedrock" => "bedrock", "anthropic" => "anthropic", "google" => "gemini",
+        "google-vertex" => "vertex_ai", "openai" => "openai", "openrouter" => "openrouter"
+      }.freeze
+
+      def self.generate(document)
+        result = {}
+        NAMESPACES.sort.each do |namespace, provider|
+          document.fetch(namespace).fetch("models").sort.each do |model_id, value|
+            attributes = normalize(value)
+            attributes["provenance"] = attributes.keys.reject { |key| key == "observed_at" }.to_h { |key| [key, "bundled:models.dev"] }
+            result["#{provider}:#{model_id}"] = attributes
+          end
+        end
+        JSON.pretty_generate(result) + "\n"
+      end
+
+      def self.normalize(value)
+        parameters = []
+        parameters << "tools" if value["tool_call"]
+        parameters << "structured_outputs" if value["structured_output"]
+        parameters << "temperature" if value["temperature"]
+        parameters << "reasoning" if value["reasoning"]
+        {
+          "context_window" => value.dig("limit", "context"),
+          "max_output_tokens" => value.dig("limit", "output"),
+          "input_modalities" => value.dig("modalities", "input"),
+          "output_modalities" => value.dig("modalities", "output"),
+          "supported_parameters" => parameters.empty? ? nil : parameters,
+          "pricing" => value["cost"],
+          "observed_at" => value["last_updated"] || value["release_date"]
+        }.compact
+      end
+    end
+  end
+end

data/lib/little_ghost/models/configuration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "erb"
+require "date"
+require "pathname"
+require "psych"
+
+module LittleGhost
+  module Models
+    # Loads trusted provider connections or logical model profiles from YAML.
+    class Configuration
+      class << self
+        # Loads provider connections from +path+.
+        def providers(path)
+          document = read(path)
+          Providers::Configuration.new(mapping(document["providers"], path, "providers"))
+        end
+
+        # Loads model profiles and an optional default role from +path+.
+        def models(path)
+          document = read(path)
+          [mapping(document["models"], path, "models"), document["default_model"]&.to_s]
+        end
+
+        private
+
+        def read(path)
+          path = Pathname(path)
+          rendered = ERB.new(path.read, trim_mode: "-").result
+          Psych.safe_load(rendered, permitted_classes: [Date, Time], aliases: true) || {}
+        rescue Psych::Exception, NameError => error
+          raise ConfigurationError, "Invalid LittleGhost configuration in #{path}: #{error.message}"
+        end
+
+        def mapping(value, path, key)
+          raise ConfigurationError, "#{path}: #{key} must be a mapping" unless value.is_a?(Hash)
+
+          value.to_h { |name, child| [name.to_s, child.to_h] }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/little_ghost/models/details.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module LittleGhost
+  module Models
+    # Immutable normalized facts about one physical model.
+    Details = Data.define(:target, :attributes, :provenance, :observed_at) do
+      def initialize(target:, attributes: {}, provenance: {}, observed_at: nil)
+        normalized = attributes.to_h.each_with_object({}) do |(key, value), result|
+          result[key.to_sym] = freeze_value(value)
+        end
+        sources = provenance.to_h.each_with_object({}) { |(key, value), result| result[key.to_sym] = value.to_s.freeze }
+        super(
+          target: Target.parse(target),
+          attributes: normalized.freeze,
+          provenance: sources.freeze,
+          observed_at:
+        )
+      end
+
+      def [](name) = attributes[name.to_sym]
+      def known? = !attributes.empty?
+      def pricing = self[:pricing] || {}.freeze
+      def input_modalities = self[:input_modalities]
+      def supported_parameters = self[:supported_parameters]
+      def context_window = self[:context_window] || self[:context_window_tokens]
+      def max_output_tokens = self[:max_output_tokens]
+
+      def to_h
+        attributes.merge(target: target.to_s, provenance:, observed_at:)
+      end
+
+      private
+
+      def freeze_value(value)
+        case value
+        when Hash
+          value.to_h { |key, child| [key.to_sym, freeze_value(child)] }.freeze
+        when Array
+          value.map { |child| freeze_value(child) }.freeze
+        when String
+          value.dup.freeze
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/little_ghost/models/target.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module LittleGhost
+  module Models
+    # Identifies one physical model through a named provider connection.
+    Target = Data.define(:provider, :model_id) do
+      def initialize(provider:, model_id:)
+        provider = provider.to_s.strip
+        model_id = model_id.to_s.strip
+        raise ConfigurationError, "Model target provider is required" if provider.empty?
+        raise ConfigurationError, "Model target model ID is required" if model_id.empty?
+
+        super(provider: provider.freeze, model_id: model_id.freeze)
+      end
+
+      # Parses +provider:model-id+, splitting only at the first colon.
+      def self.parse(value)
+        return value if value.is_a?(self)
+
+        provider, separator, model_id = value.to_s.partition(":")
+        raise ConfigurationError, "Model target must use provider:model-id" if separator.empty?
+
+        new(provider:, model_id:)
+      end
+
+      def to_s = "#{provider}:#{model_id}"
+    end
+  end
+end

data/lib/little_ghost/provider_registry.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module LittleGhost
+  # Constructs built-in and application provider adapters from named provider
+  # connections. Register adapters during application configuration.
+  class ProviderRegistry
+    # :nodoc:
+    REQUEST_OPTIONS = %i[
+      app_name max_response_bytes max_retries max_retry_delay open_timeout read_timeout retries
+    ].freeze
+    # :nodoc:
+    BUILT_INS = {
+      "openai_compatible" => Providers::OpenAICompatible,
+      "openai" => Providers::OpenAI,
+      "openrouter" => Providers::OpenRouter,
+      "anthropic" => Providers::Anthropic,
+      "gemini" => Providers::Gemini,
+      "vertex_ai" => Providers::VertexAI,
+      "bedrock" => Providers::Bedrock
+    }.freeze
+
+    # Creates a registry with optional adapter factories keyed by adapter name.
+    # Application adapters supplement the built-in provider adapters.
+    def initialize(adapters: {})
+      @adapters = BUILT_INS.merge(adapters.to_h.transform_keys(&:to_s))
+    end
+
+    # Constructs the configured provider for +model+.
+    #
+    # Connection +configuration+ remains authoritative. The trusted per-profile
+    # +request+ mapping may adjust bounded request behavior, but cannot replace
+    # endpoints or credentials.
+    def build(adapter:, model:, configuration:, request: {}, **context)
+      factory = @adapters.fetch(adapter.to_s) do
+        raise AdapterLoadError, "Unknown provider adapter: #{adapter}"
+      end
+      options = symbolize(configuration).reject { |key, value| key == :adapter || value.nil? }
+      request_options = symbolize(request).reject { |_key, value| value.nil? }
+      unsupported = request_options.keys - REQUEST_OPTIONS
+      unless unsupported.empty?
+        raise ConfigurationError, "Unsupported request options for #{adapter}: #{unsupported.join(", ")}"
+      end
+      if request_options.key?(:retries)
+        request_options[:max_retries] ||= request_options[:retries]
+        request_options.delete(:retries)
+      end
+      if factory.is_a?(Class)
+        unless factory <= Providers::Base
+          raise AdapterLoadError, "Provider adapter #{adapter} must inherit LittleGhost::Providers::Base"
+        end
+
+        request_options.select! { |key| factory.request_options.include?(key) }
+      end
+      options.merge!(request_options)
+      provider = if factory.is_a?(Class)
+        factory.new(model:, **options)
+      else
+        factory.call(model:, configuration: options, **context)
+      end
+      unless provider.is_a?(Providers::Base)
+        raise AdapterLoadError, "Provider adapter #{adapter} must return a LittleGhost::Providers::Base"
+      end
+
+      provider
+    rescue ArgumentError => error
+      raise unless error.message.match?(/unknown keyword|missing keyword/)
+
+      raise ConfigurationError, "Invalid configuration for #{adapter}: #{error.message}"
+    end
+
+    private
+
+    def symbolize(value) = value.to_h { |key, child| [key.to_sym, child] }
+  end
+end

data/lib/little_ghost/providers/anthropic/catalog_source.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module LittleGhost
+  module Providers
+    class Anthropic < Base
+      # Enriches availability and limits from Anthropic's model list endpoint.
+      class CatalogSource < Models::Catalog::Source
+        URL = URI("https://api.anthropic.com/v1/models") # :nodoc:
+
+        # Creates a source for the named provider connection.
+        def initialize(provider:, credential_resolver:)
+          super(name: "anthropic")
+          @provider = provider
+          @credential_resolver = credential_resolver
+        end
+
+        def refresh(target: nil)
+          api_key = @credential_resolver.call.fetch("api_key")
+          values = JSON.parse(
+            Support::HTTPClient.new(open_timeout: 5, read_timeout: 30, max_response_bytes: 25 * 1024 * 1024)
+              .request(uri: URL, headers: {"x-api-key" => api_key, "anthropic-version" => "2023-06-01"})
+          ).fetch("data")
+          values.select! { |value| value["id"] == target.model_id } if target
+          values.to_h { |value| ["#{@provider}:#{value.fetch("id")}", {available: true, observed_at: value["created_at"]}.compact] }
+        rescue JSON::ParserError, KeyError => error
+          raise ProviderError, "Anthropic returned an invalid catalog: #{error.message}"
+        end
+      end
+    end
+  end
+end

data/lib/little_ghost/providers/anthropic.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+require_relative "../support/http_client"
+require_relative "../support/sse_parser"
+require_relative "anthropic/catalog_source"
+
+module LittleGhost
+  module Providers
+    # Zero-dependency Anthropic Messages API adapter.
+    class Anthropic < Base
+      # Request policy supported by the Anthropic HTTP client.
+      def self.request_options = %i[max_response_bytes open_timeout read_timeout].freeze
+
+      DEFAULT_BASE_URL = "https://api.anthropic.com/v1/" # :nodoc:
+
+      # Provider-owned model identifier.
+      attr_reader :model
+
+      # Creates an Anthropic Messages client for +model+.
+      def initialize(api_key:, model:, base_url: DEFAULT_BASE_URL, api_version: "2023-06-01",
+        open_timeout: 10, read_timeout: 120, max_response_bytes: Support::HTTPClient::DEFAULT_MAX_RESPONSE_BYTES,
+        transport: nil, **)
+        raise CredentialError, "Anthropic api_key is required" if api_key.to_s.empty?
+
+        @api_key = api_key
+        @api_version = api_version
+        @model = model
+        @transport = transport || Support::HTTPClient.new(base_url:, open_timeout:, read_timeout:, max_response_bytes:)
+      end
+
+      # Streams normalized events for +request+.
+      def stream(request)
+        return enum_for(__method__, request) unless block_given?
+
+        parser = Support::SSEParser.new
+        normalizer = Normalizer.new(model:)
+        @transport.stream(
+          path: "messages",
+          headers: {
+            "x-api-key" => @api_key,
+            "anthropic-version" => @api_version,
+            "content-type" => "application/json",
+            "accept" => "text/event-stream"
+          },
+          body: JSON.generate(request_body(request)),
+          cancellation_token: request.cancellation_token,
+          deadline: request.deadline
+        ) do |chunk|
+          parser.<<(chunk).each { |data| normalizer.consume(JSON.parse(data)).each { |event| yield event } }
+        end
+        parser.finish.each { |data| normalizer.consume(JSON.parse(data)).each { |event| yield event } }
+        normalizer.finish.each { |event| yield event }
+      rescue JSON::ParserError => error
+        raise ProtocolError, "Anthropic returned invalid JSON: #{error.message}"
+      end
+
+      # Reports tool and structured-output support from model metadata.
+      def capabilities(metadata: {})
+        parameters = metadata[:supported_parameters]
+        ModelCapabilities.new(
+          native_structured_output: parameters&.include?("structured_outputs"),
+          tools: true,
+          tool_choice: true,
+          supported_parameters: parameters
+        )
+      end
+
+      private
+
+      def request_body(request)
+        system, messages = request.messages.partition { |message| message.role == :system }
+        body = {
+          model:,
+          stream: true,
+          max_tokens: request.settings[:max_tokens] || 4096,
+          messages: messages.map { |message| anthropic_message(message) }
+        }
+        body[:system] = system.flat_map { |message| message.content.map { |block| anthropic_content(block) } } unless system.empty?
+        body[:tools] = request.tools.map { |tool| anthropic_tool(tool) } unless request.tools.empty?
+        body[:tool_choice] = (request.tool_choice == :required) ? {type: "any"} : {type: "tool", name: request.tool_choice[:name].to_s} if request.tool_choice
+        request.settings.each { |key, value| body[key] = value unless %i[reasoning_effort max_tokens].include?(key.to_sym) }
+        body
+      end
+
+      def anthropic_message(message)
+        {role: (message.role == :assistant) ? "assistant" : "user", content: message.content.map { |block| anthropic_content(block) }}
+      end
+
+      def anthropic_content(block)
+        case block
+        when Content::Text then {type: "text", text: block.text}
+        when Content::Image then {type: "image", source: {type: "base64", media_type: block.media_type, data: Base64.strict_encode64(block.data)}}
+        when Content::Document then {type: "document", source: {type: "base64", media_type: block.media_type, data: Base64.strict_encode64(block.data)}}
+        when Content::ToolUse then {type: "tool_use", id: block.id, name: block.name, input: block.input}
+        when Content::ToolResult
+          {type: "tool_result", tool_use_id: block.tool_use_id, content: Array(block.content).join("\n"), is_error: block.status == :error}
+        when Content::Reasoning then {type: "thinking", thinking: block.text, signature: block.signature}.compact
+        else raise ConfigurationError, "Unsupported Anthropic content block: #{block.class}"
+        end
+      end
+
+      def anthropic_tool(tool)
+        value = tool.is_a?(Hash) ? tool.transform_keys(&:to_sym) : {name: tool.name, description: tool.description, input_schema: tool.input_schema}
+        {name: value.fetch(:name), description: value[:description], input_schema: value[:input_schema] || {}}
+      end
+
+      class Normalizer # :nodoc:
+        def initialize(model:)
+          @model = model
+          @text = +""
+          @reasoning = +""
+          @tools = {}
+          @usage = Usage.new
+          @terminal = false
+        end
+
+        def consume(event)
+          case event["type"]
+          when "message_start"
+            message = event.fetch("message")
+            @id = message["id"]
+            @usage = usage(message["usage"])
+            [StreamEvent.build(:message_start, id: @id, model: message["model"] || @model)]
+          when "content_block_start"
+            start_block(event)
+          when "content_block_delta"
+            delta_block(event)
+          when "content_block_stop"
+            stop_block(event)
+          when "message_delta"
+            @stop_reason = stop_reason(event.dig("delta", "stop_reason"))
+            @usage = usage(event["usage"], previous: @usage)
+            [StreamEvent.build(:usage, usage: @usage)]
+          when "message_stop"
+            @terminal = true
+            []
+          when "error"
+            raise ProviderError, "Anthropic request failed: #{event.dig("error", "message") || "unknown error"}"
+          else
+            []
+          end
+        end
+
+        def finish
+          raise ProtocolError, "Anthropic stream ended before message_stop" unless @terminal
+
+          blocks = []
+          blocks << Content::Reasoning.new(text: @reasoning) unless @reasoning.empty?
+          blocks << Content::Text.new(text: @text) unless @text.empty?
+          @tools.sort.each { |_index, tool| blocks << Content::ToolUse.new(id: tool[:id], name: tool[:name], input: parse_input(tool[:input])) }
+          response = ModelResponse.new(
+            message: Message.new(role: :assistant, content: blocks),
+            stop_reason: @stop_reason || (@tools.empty? ? :end_turn : :tool_use),
+            usage: @usage,
+            metadata: {id: @id, model: @model}
+          )
+          [StreamEvent.build(:message_stop, response:)]
+        end
+
+        private
+
+        def start_block(event)
+          block = event.fetch("content_block")
+          return [] unless block["type"] == "tool_use"
+
+          index = event.fetch("index")
+          @tools[index] = {id: block["id"], name: block["name"], input: +""}
+          [StreamEvent.build(:tool_call_start, index:, id: block["id"], name: block["name"])]
+        end
+
+        def delta_block(event)
+          delta = event.fetch("delta")
+          case delta["type"]
+          when "text_delta"
+            @text << delta.fetch("text")
+            [StreamEvent.build(:text_delta, text: delta.fetch("text"))]
+          when "thinking_delta"
+            @reasoning << delta.fetch("thinking")
+            [StreamEvent.build(:reasoning_delta, text: delta.fetch("thinking"))]
+          when "input_json_delta"
+            index = event.fetch("index")
+            arguments = delta.fetch("partial_json")
+            @tools.fetch(index)[:input] << arguments
+            [StreamEvent.build(:tool_call_delta, index:, arguments:)]
+          else []
+          end
+        end
+
+        def stop_block(event)
+          index = event.fetch("index")
+          tool = @tools[index]
+          return [] unless tool
+
+          use = Content::ToolUse.new(id: tool[:id], name: tool[:name], input: parse_input(tool[:input]))
+          [StreamEvent.build(:tool_call_stop, index:, tool_use: use)]
+        end
+
+        def parse_input(value) = value.empty? ? {} : JSON.parse(value)
+
+        def usage(value, previous: Usage.new)
+          value ||= {}
+          cache_read = value["cache_read_input_tokens"] || previous.cache_read_tokens
+          cache_write = value["cache_creation_input_tokens"] || previous.cache_write_tokens
+          input = value["input_tokens"] || previous.input_tokens
+          Usage.new(input_tokens: input, output_tokens: value["output_tokens"] || previous.output_tokens,
+            cache_read_tokens: cache_read, cache_write_tokens: cache_write)
+        end
+
+        def stop_reason(value)
+          case value
+          when "tool_use" then :tool_use
+          when "max_tokens" then :max_tokens
+          when "refusal" then :content_filter
+          else :end_turn
+          end
+        end
+      end
+    end
+  end
+end