smith-agents 0.11.0 → 0.12.1

data/lib/smith/pricing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "pricing/catalog_validation"
+
 module Smith
   module Pricing
     # Compute provider cost for a single agent call. Two pricing shapes
@@ -18,6 +20,18 @@ module Smith
     #     long-context premium pricing (Gemini 2.5 Pro: $1.25/$10 below
     #     200K input tokens, $2.50/$15 above).
     #
+    # Both shapes accept two optional rates beside input and output:
+    # `:cache_read_cost_per_token` and `:cache_write_cost_per_token`, for
+    # input read from or written to a prompt cache, which providers report
+    # apart from uncached input. An entry may also carry `:batch_discount`,
+    # the fraction a provider's batch API takes off (0.5 for half price),
+    # applied to the whole cost of a call made in `mode: :batch`. These are
+    # configured per catalog: a missing cache rate prices those tokens at 0,
+    # and a missing batch discount is 0, so a batch call costs the full
+    # rate. Tiers are
+    # chosen on the call's total input, uncached plus cache read plus cache
+    # write, since that is what long-context premiums are measured against.
+    #
     # Catalog keys are normalized once per assigned catalog object:
     #   ["provider", "model"] / [:provider, :model]  -> provider-qualified
     #   "provider/model" (first slash splits)        -> provider-qualified
@@ -25,21 +39,58 @@ module Smith
     #
     # Lookup policy: a provider-qualified lookup reads only qualified
     # entries and NEVER prices from a legacy model-only rate; unpriced
-    # usage stays visibly unpriced (nil cost). This method never raises,
+    # usage stays visibly unpriced (nil cost). A count that is not a
+    # non-negative Integer prices as 0. This method never raises,
     # so accounting paths cannot mask a provider error with a pricing
     # configuration error. The legacy-only-key policy is enforced at
     # catalog admission time via `validate_catalog!`.
-    def self.compute_cost(model:, input_tokens:, output_tokens:, provider: nil)
+    # rubocop:disable Metrics/ParameterLists
+    def self.compute_cost(model:, input_tokens:, output_tokens:, provider: nil, cache_read_tokens: 0,
+                          cache_write_tokens: 0, mode: :sync)
+      counts = [input_tokens, output_tokens, cache_read_tokens, cache_write_tokens].map { |count| token_count(count) }
+      rates = rates_for(model, provider, counts[0] + counts[2] + counts[3])
+      return nil unless rates
+
+      apply_mode(priced_tokens(rates, *counts), rates.fetch(:entry), mode)
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    # True when the call's cache tokens were priced at 0 because its rates
+    # have no cache rate for them; false when they were priced, absent, or
+    # the call is unpriced altogether.
+    def self.cache_unpriced?(model:, input_tokens:, provider: nil, cache_read_tokens: 0, cache_write_tokens: 0)
+      read = token_count(cache_read_tokens)
+      write = token_count(cache_write_tokens)
+      rates = rates_for(model, provider, token_count(input_tokens) + read + write)
+      return false unless rates
+
+      (read.positive? && rates[:cache_read].nil?) || (write.positive? && rates[:cache_write].nil?)
+    end
+
+    # A count that is not a non-negative Integer prices as 0, so accounting
+    # never raises on a provider's missing or malformed count.
+    def self.token_count(count)
+      count.is_a?(Integer) && count.positive? ? count : 0
+    end
+
+    def self.rates_for(model, provider, total_input_tokens)
       catalog = Smith.config.pricing
       return nil unless catalog.is_a?(Hash)
 
       entry = lookup_entry(normalized_index(catalog), model, provider)
-      return nil unless entry
+      resolve_rates(entry, total_input_tokens) if entry.is_a?(Hash)
+    end
+
+    def self.priced_tokens(rates, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens)
+      (input_tokens * rates[:input]) + (output_tokens * rates[:output]) +
+        (cache_read_tokens * (rates[:cache_read] || 0)) + (cache_write_tokens * (rates[:cache_write] || 0))
+    end
 
-      input_rate, output_rate = resolve_rates(entry, input_tokens)
-      return nil unless input_rate
+    def self.apply_mode(cost, entry, mode)
+      return cost unless mode == :batch
 
-      (input_tokens * input_rate) + (output_tokens * output_rate)
+      discount = value_at(entry, :batch_discount)
+      discount.is_a?(Numeric) ? cost * (1 - discount) : cost
     end
 
     def self.lookup_entry(index, model, provider)
@@ -52,42 +103,18 @@ module Smith
     # is assigned (`config.pricing = Smith::Pricing.validate_catalog!(catalog)`)
     # so misconfiguration fails at configuration time instead of inside
     # an in-flight accounting path. Rejects legacy model-only keys,
-    # unrecognized key shapes, non-Hash entries, and keys that collide
-    # after normalization. Returns the catalog for assignment chaining.
+    # unrecognized key shapes, non-Hash entries, keys that collide after
+    # normalization, optional rates that are not non-negative Integers or
+    # Floats, and a batch discount out of range or inside a tier. Returns
+    # the catalog for assignment chaining.
     def self.validate_catalog!(catalog = Smith.config.pricing)
-      return catalog if catalog.nil?
-      raise Smith::PricingConfigurationError, "pricing catalog must be a Hash" unless catalog.is_a?(Hash)
-
-      catalog.each_with_object({}) do |(key, entry), seen|
-        provider, model = validated_key!(key)
-        validate_entry!(key, entry)
-        reject_collision!(seen, key, provider, model)
-      end
-      catalog
+      CatalogValidation.validate!(catalog)
     end
 
-    def self.validated_key!(key)
-      provider, model = canonical_key(key)
-      raise Smith::PricingConfigurationError, "unrecognized pricing catalog key #{key.inspect}" unless model
-      return [provider, model] if provider
-
-      raise Smith::PricingConfigurationError, "pricing for #{model} must use a provider-qualified catalog key"
-    end
-
-    def self.validate_entry!(key, entry)
-      return if entry.is_a?(Hash)
-
-      raise Smith::PricingConfigurationError, "pricing entry for #{key.inspect} must be a Hash"
-    end
-
-    def self.reject_collision!(seen, key, provider, model)
-      previous = seen[[provider, model]]
-      if previous
-        raise Smith::PricingConfigurationError,
-              "pricing catalog keys #{previous.inspect} and #{key.inspect} collide as #{provider}/#{model}"
-      end
-
-      seen[[provider, model]] = key
+    # A catalog key read as a Symbol or a String, as a catalog loaded from
+    # JSON or YAML has.
+    def self.value_at(source, name)
+      source.key?(name) ? source[name] : source[name.to_s]
     end
 
     # The catalog is treated as immutable once assigned: normalization
@@ -148,39 +175,43 @@ module Smith
       text unless text.nil? || text.empty?
     end
 
-    # Returns [input_rate, output_rate] or nil if no applicable rate.
-    # Tiered shape is recognized by the presence of a :tiers key; flat
-    # shape is the legacy default.
-    def self.resolve_rates(entry, input_tokens)
-      tiers = entry[:tiers] || entry["tiers"]
-      if tiers.is_a?(Array) && !tiers.empty?
-        resolve_tiered(tiers, input_tokens)
-      else
-        flat = [entry[:input_cost_per_token], entry[:output_cost_per_token]]
-        return nil unless flat.all?(Numeric)
-
-        flat
-      end
+    # Returns { input:, output:, cache_read:, cache_write:, entry: } or nil
+    # if no applicable input and output rate. Tiered shape is recognized by
+    # the presence of a :tiers key; flat shape is the legacy default. A tier
+    # without its own cache rate uses the entry's.
+    def self.resolve_rates(entry, total_input_tokens)
+      tiers = value_at(entry, :tiers)
+      rates = if tiers.is_a?(Array) && !tiers.empty?
+                tier = tiers.find { |candidate| candidate.is_a?(Hash) && tier_applies?(candidate, total_input_tokens) }
+                tier && rates_from(tier, defaults: entry)
+              else
+                rates_from(entry)
+              end
+      rates&.merge(entry:)
     end
 
-    def self.resolve_tiered(tiers, input_tokens)
-      tier = tiers.find { |candidate| tier_applies?(candidate, input_tokens) }
-      return nil unless tier
+    def self.rates_from(source, defaults: nil)
+      rates = %i[input output cache_read cache_write].to_h { |name| [name, rate_at(source, defaults, name)] }
+      rates if rates[:input] && rates[:output]
+    end
 
-      rates = [
-        tier[:input_cost_per_token] || tier["input_cost_per_token"],
-        tier[:output_cost_per_token] || tier["output_cost_per_token"]
-      ]
-      rates if rates.all?(Numeric)
+    # A tier's own rate, else, for a cache rate, the entry's.
+    def self.rate_at(source, defaults, name)
+      rate = value_at(source, :"#{name}_cost_per_token")
+      rate = value_at(defaults, :"#{name}_cost_per_token") if rate.nil? && defaults && CACHE_RATES.include?(name)
+      rate if rate.is_a?(Numeric)
     end
 
     def self.tier_applies?(tier, input_tokens)
-      maximum = tier[:max_input_tokens] || tier["max_input_tokens"]
+      maximum = value_at(tier, :max_input_tokens)
       maximum.nil? || input_tokens <= maximum
     end
 
-    private_class_method :lookup_entry, :validated_key!, :validate_entry!, :reject_collision!,
-                         :normalized_index, :build_normalized_index, :canonical_key, :array_key,
-                         :text_key, :scalar_key, :resolve_rates, :resolve_tiered, :tier_applies?
+    CACHE_RATES = %i[cache_read cache_write].freeze
+    private_constant :CACHE_RATES
+
+    private_class_method :rate_at, :lookup_entry, :normalized_index, :build_normalized_index, :canonical_key,
+                         :array_key, :text_key, :scalar_key, :resolve_rates, :rates_from, :tier_applies?,
+                         :priced_tokens, :apply_mode, :token_count, :rates_for, :value_at
   end
 end

data/lib/smith/providers/anthropic/batches.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "json"
+require "ruby_llm"
+
+module Smith
+  module Providers
+    module Anthropic
+      # Anthropic's Message Batches API, over RubyLLM's configured Anthropic
+      # connection (its key and base URL), for the host to submit the
+      # requests Smith's batch queue took, read a batch's status, collect its
+      # results and cancel it. Smith calls none of these: the host schedules
+      # them, then resumes each run with the results of its wait.
+      #
+      #   batches = Smith::Providers::Anthropic::Batches.new
+      #   batch_id = batches.submit(queued)   # [{ custom_id:, request: }, ...], as enqueued
+      #   batches.status(batch_id)            # => { status: "in_progress" | "canceling" | "ended", counts: {...} }
+      #   batches.results(batch_id) { |custom_id, result| ... }
+      #
+      # A batch takes at most 100,000 requests and 256 MB, and every request
+      # in it the same per-call headers (a beta feature's, say), which never
+      # override the connection's own (its key and API version). The
+      # connection makes no retries of its own, so a submit is never sent
+      # twice; the host's schedule tries again.
+      class Batches
+        PATH = "v1/messages/batches"
+        MAX_REQUESTS = 100_000
+        MAX_BYTES = 256 * 1024 * 1024
+        BATCH_ID = /\A[A-Za-z0-9_-]{1,128}\z/
+
+        def initialize(config: RubyLLM.config)
+          config = config.dup
+          config.max_retries = 0
+          @connection = RubyLLM::Providers::Anthropic.new(config).connection
+        end
+
+        # Submits the requests; returns the batch id.
+        def submit(requests)
+          entries = Array(requests).map { |entry| entry.transform_keys(&:to_sym) }
+          body = { requests: entries.map { |entry| { custom_id: entry.fetch(:custom_id), params: params(entry) } } }
+          check_batch!(entries, body)
+          headers = shared_headers(entries)
+          @connection.post(PATH, body) { |request| add_headers(request.headers, headers) }.body.fetch("id")
+        end
+
+        # The batch's processing status ("in_progress", "canceling" or
+        # "ended") and its request counts.
+        def status(batch_id)
+          body = @connection.get("#{PATH}/#{id!(batch_id)}").body
+          { status: body.fetch("processing_status"), counts: body["request_counts"], ended_at: body["ended_at"],
+            expires_at: body["expires_at"] }
+        end
+
+        # Yields each result of an ended batch as [custom_id, result].
+        def results(batch_id)
+          return enum_for(:results, batch_id) unless block_given?
+
+          body = @connection.get("#{PATH}/#{id!(batch_id)}/results").body
+          entries(body).each { |entry| yield entry.fetch("custom_id"), entry.fetch("result") }
+          nil
+        end
+
+        # Asks the provider to stop the batch; returns its status.
+        def cancel(batch_id)
+          @connection.post("#{PATH}/#{id!(batch_id)}/cancel", {}).body.fetch("processing_status")
+        end
+
+        private
+
+        def params(entry)
+          request = entry.fetch(:request).transform_keys(&:to_s)
+          raise ArgumentError, "a request for #{request["provider"]} cannot go in an Anthropic batch" unless
+            request["provider"] == "anthropic"
+
+          request.fetch("params")
+        end
+
+        def check_batch!(entries, body)
+          unless entries.length.between?(1, MAX_REQUESTS)
+            raise ArgumentError, "a batch takes 1 to #{MAX_REQUESTS} requests, not #{entries.length}"
+          end
+          return if JSON.generate(body).bytesize <= MAX_BYTES
+
+          raise ArgumentError, "a batch takes at most #{MAX_BYTES} bytes; split the requests"
+        end
+
+        def shared_headers(entries)
+          headers = entries.map { |entry| entry.fetch(:request).transform_keys(&:to_s).fetch("headers", {}).to_h }.uniq
+          raise ArgumentError, "the requests of one batch must share their headers" if headers.length > 1
+
+          headers.first
+        end
+
+        # The requests' own headers, under the connection's (its key and API
+        # version win).
+        def add_headers(request_headers, headers)
+          headers.each { |name, value| request_headers[name] = value unless request_headers.key?(name) }
+        end
+
+        def id!(batch_id)
+          return batch_id if batch_id.is_a?(String) && BATCH_ID.match?(batch_id)
+
+          raise ArgumentError, "not a batch id: #{batch_id.inspect}"
+        end
+
+        # The results file: one JSON object per line.
+        def entries(body)
+          return body if body.is_a?(Array)
+          return [body] if body.is_a?(Hash)
+
+          body.to_s.each_line.filter_map { |line| JSON.parse(line) unless line.strip.empty? }
+        end
+      end
+    end
+  end
+end

data/lib/smith/providers/batch_exchange.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module Smith
+  module Providers
+    # Where batch mode meets RubyLLM: a provider's synchronous response
+    # (`sync_response`), which a call reaches with the exact payload and
+    # per-call headers it would post. While a batch step captures, the
+    # payload is thrown out as the batch request before anything is sent;
+    # while it delivers, the batch result is parsed by the provider's own
+    # parser instead of a response from the wire. A call that renders
+    # another request than the one sent (its digest differs: a date in its
+    # prompt, data read afresh) takes the result all the same and the
+    # delivery says so, unless its step declares another `on_request_change`
+    # (then BatchRequestChanged, before the result is read). Only the call's
+    # own provider object is affected, so any other RubyLLM call (a tool's)
+    # goes over the wire as ever.
+    module BatchExchange
+      HELD = :smith_batch_exchange
+      CAPTURED = :smith_batch_request
+      private_constant :HELD
+
+      # A capture notes its request's hold (RequestHolds) when its step has
+      # a host's budget ledger (`holding`).
+      Exchange = Struct.new(:provider, :result, :digest, :changed, :on_change, :holding, :hold)
+      # What a provider's response parser reads.
+      Response = Struct.new(:body)
+
+      module_function
+
+      # Runs the block with `result` (a batch result) answering its call,
+      # whose request was the one with `digest`; returns the block's value
+      # and whether the call rendered another request. Unless `on_change` is
+      # :keep, a call that renders another request raises
+      # BatchRequestChanged instead of taking the result.
+      def deliver(provider, result, digest, on_change: :keep, &)
+        exchange = Exchange.new(provider, result, digest, false, on_change)
+        [within(exchange, &), exchange.changed]
+      end
+
+      def within(exchange)
+        outer = Fiber[HELD]
+        Fiber[HELD] = exchange
+        yield
+      ensure
+        Fiber[HELD] = outer
+      end
+
+      def exchange_for(provider)
+        exchange = Fiber[HELD]
+        exchange if exchange&.provider.equal?(provider)
+      end
+
+      # Prepended on RubyLLM::Provider.
+      module Hook
+        private
+
+        def sync_response(connection, payload, additional_headers = {})
+          exchange = BatchExchange.exchange_for(self)
+          return super unless exchange
+
+          unless exchange.result
+            throw(CAPTURED, Smith::Batch.request(provider: slug, params: payload, headers: additional_headers))
+          end
+
+          exchange.changed = Smith::Batch.changed?(exchange.digest, payload, additional_headers)
+          raise Smith::BatchRequestChanged if exchange.changed && exchange.on_change != :keep
+
+          parse_completion_response(Response.new(Smith::Batch.message!(exchange.result).to_h))
+        end
+      end
+    end
+  end
+end
+
+RubyLLM::Provider.prepend(Smith::Providers::BatchExchange::Hook)

data/lib/smith/providers/openai/responses.rb

@@ -51,21 +51,11 @@ module Smith
         # vendored helpers, POSTs via the provider's Faraday connection,
         # parses the response back into a RubyLLM::Message.
         #
-        # Streaming is intentionally NOT supported in this initial vendor
-        # because Smith's workflow execution path doesn't use it.
-        # Block-given calls raise NotImplementedError with a clear
-        # message so the host can either disable streaming or fall back
-        # to `openai_api_mode = :off`.
+        # This path does not stream (the stream_response port from PR #770
+        # is not vendored): a call given a block completes, then passes the
+        # block the reply's whole text as one chunk.
         def self.complete(provider, messages, tools:, temperature:, model:, params: {}, headers: {},
-                          schema: nil, thinking: nil, tool_prefs: nil, &block)
-          if block
-            raise NotImplementedError,
-                  "Smith::Providers::OpenAI::Responses does not yet support streaming. " \
-                  "Streaming over /v1/responses needs a separate stream_response port from PR #770. " \
-                  "Workaround: pass no block (sync only), or set Smith.config.openai_api_mode = :off " \
-                  "to route via chat-completions with graceful tool-dropping."
-          end
-
+                          schema: nil, thinking: nil, tool_prefs: nil, &)
           payload = render_response_payload(
             messages,
             tools: tools,
@@ -86,7 +76,15 @@ module Smith
             merged_headers.each { |k, v| req.headers[k] = v }
           end
 
-          parse_response_response(http_response, provider: provider)
+          with_whole_chunk(parse_response_response(http_response, provider: provider), &)
+        end
+
+        # SMITH-AUTHORED: a block gets the reply's whole text as one chunk.
+        def self.with_whole_chunk(message)
+          text = message&.content
+          yield ::RubyLLM::Chunk.new(role: :assistant, content: text, model_id: message.model_id) if
+            block_given? && text.is_a?(String) && !text.empty?
+          message
         end
 
         # rubocop:disable Metrics/ParameterLists
@@ -141,11 +139,9 @@ module Smith
             content: response_output_text(data),
             thinking: ::RubyLLM::Thinking.build(text: response_reasoning_text(outputs)),
             tool_calls: ToolsExtensions.parse_response_tool_calls(outputs),
-            input_tokens: usage["input_tokens"],
-            output_tokens: usage["output_tokens"],
-            cached_tokens: usage.dig("input_tokens_details", "cached_tokens"),
-            cache_creation_tokens: usage.dig("input_tokens_details", "cache_write_tokens") || 0,
-            thinking_tokens: usage.dig("output_tokens_details", "reasoning_tokens"),
+            # SMITH-AUTHORED: every usage count from response_usage (see the
+            # SMITH-AUTHORED helpers below and UPSTREAM_PROPOSAL.md).
+            **response_usage(usage),
             model_id: data["model"],
             raw: response
           )
@@ -286,6 +282,7 @@ module Smith
         end
 
         # ---- SMITH-AUTHORED helpers (inlined from PR #770 chat.rb) -------
+
         #
         # Upstream PR #770 keeps these on the chat module (which is mixed
         # into the provider class so they're available as instance methods
@@ -294,6 +291,34 @@ module Smith
         # inlined as class methods with the provider passed in where
         # @config access is needed.
 
+        # SMITH-AUTHORED, not from PR #770. The Responses API counts cached
+        # and cache-written input inside `input_tokens`; RubyLLM reports
+        # every other provider's input with those taken out, and Smith totals
+        # and prices the cache counts beside it, so the same is done here.
+        # Cache counts that are not non-negative Integers are dropped, and
+        # counts larger than the reported input are capped to it, so the
+        # input total the provider reported is kept.
+        def self.response_usage(usage)
+          details = usage["input_tokens_details"].is_a?(Hash) ? usage["input_tokens_details"] : {}
+          input, cached, written = uncached_input(
+            usage["input_tokens"], usage_count(details["cached_tokens"]), usage_count(details["cache_write_tokens"])
+          )
+          { input_tokens: input, output_tokens: usage["output_tokens"], cached_tokens: cached,
+            cache_creation_tokens: written, thinking_tokens: usage.dig("output_tokens_details", "reasoning_tokens") }
+        end
+
+        def self.uncached_input(input, cached, written)
+          return [input, cached, written] unless input.is_a?(Integer)
+
+          cached &&= [cached, input].min
+          written &&= [written, input - cached.to_i].min
+          [input - cached.to_i - written.to_i, cached, written]
+        end
+
+        def self.usage_count(value)
+          value if value.is_a?(Integer) && value >= 0
+        end
+
         def self.format_role(role, provider: nil)
           case role
           when :system

data/lib/smith/providers/output_limit.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Smith
+  module Providers
+    # A provider's own parameter for the most tokens a response may hold,
+    # merged into the request when an agent retries a cut-off response
+    # (`on_truncation retry_with: { max_tokens: n }`). A provider not listed
+    # here is not retried.
+    module OutputLimit
+      PROVIDERS = %w[anthropic openai gemini vertexai bedrock].freeze
+      PARAM_PATHS = {
+        "anthropic" => [%i[max_tokens]],
+        "openai" => [%i[max_output_tokens], %i[max_completion_tokens], %i[max_tokens]],
+        "gemini" => [%i[generationConfig maxOutputTokens]],
+        "vertexai" => [%i[generationConfig maxOutputTokens]],
+        "bedrock" => [%i[inferenceConfig maxTokens]]
+      }.freeze
+      ANTHROPIC_DEFAULT = 4096
+
+      module_function
+
+      def supported?(provider) = PROVIDERS.include?(provider.to_s)
+
+      # `chat_params` tells the OpenAI paths apart: Smith routes a chat
+      # whose params carry `openai_api_mode: :responses` to the Responses
+      # API, and a chat that already sets the older `max_tokens` keeps it.
+      def params(provider, chat_params, max_tokens)
+        case provider.to_s
+        when "anthropic" then { max_tokens: }
+        when "openai" then { openai_key(chat_params) => max_tokens }
+        when "gemini", "vertexai" then { generationConfig: { maxOutputTokens: max_tokens } }
+        when "bedrock" then { inferenceConfig: { maxTokens: max_tokens } }
+        end
+      end
+
+      # The limit a request already had: the agent's own parameter, else for
+      # Anthropic the model's maximum as RubyLLM sends it; nil when unknown.
+      def current(provider, chat_params, model_reference)
+        set = PARAM_PATHS.fetch(provider.to_s, []).filter_map { |path| lookup(chat_params, path) }.first
+        return set if set.is_a?(Integer)
+
+        anthropic_default(model_reference.model_id) if provider.to_s == "anthropic"
+      end
+
+      def openai_key(chat_params)
+        return :max_output_tokens if responses?(chat_params)
+
+        lookup(chat_params, %i[max_tokens]) ? :max_tokens : :max_completion_tokens
+      end
+
+      def responses?(chat_params) = lookup(chat_params, %i[openai_api_mode]).to_s == "responses"
+
+      def lookup(params, path)
+        path.reduce(params) do |level, key|
+          break unless level.is_a?(Hash)
+
+          level.key?(key) ? level[key] : level[key.to_s]
+        end
+      end
+
+      def anthropic_default(model_id)
+        ::RubyLLM.models.find(model_id.to_s, "anthropic").max_tokens || ANTHROPIC_DEFAULT
+      rescue StandardError
+        ANTHROPIC_DEFAULT
+      end
+    end
+  end
+end