phronomy 0.16.0 → 0.17.0

data/lib/phronomy/agent/context/knowledge/base.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Agent
-    module Context
-      module Knowledge
-        # Abstract base class for all KnowledgeSource implementations.
-        #
-        # Subclasses must implement #fetch(query:) and return an Array of chunk Hashes.
-        # Each chunk Hash must contain:
-        #   :content [String]  the text to inject into the context
-        #   :type    [Symbol]  semantic tag (e.g. :static, :rag, :entity)
-        class Base
-          # Retrieve knowledge chunks relevant to the given query.
-          #
-          # @param query              [String, nil]                    the current user input used to select relevant chunks
-          # @param cancellation_token [Phronomy::Concurrency::CancellationToken, nil] optional token; raises CancellationError when cancelled
-          # @return [Array<Hash>] array of { content: String, type: Symbol }
-          # @api public
-          def fetch(query: nil, cancellation_token: nil)
-            cancellation_token&.raise_if_cancelled!
-            raise NotImplementedError, "#{self.class}#fetch is not implemented"
-          end
-
-          # Submits a {#fetch} call to {BlockingAdapterPool} and returns a
-          # {BlockingAdapterPool::PendingOperation}.
-          # Callers can fan out multiple fetches in parallel and await them all.
-          #
-          # @param query              [String, nil]
-          # @param cancellation_token [Phronomy::Concurrency::CancellationToken, nil]
-          # @param timeout            [Numeric, nil] seconds before the operation is abandoned
-          # @return [BlockingAdapterPool::PendingOperation]
-          # @api public
-          def fetch_async(query: nil, cancellation_token: nil, timeout: nil)
-            Phronomy::Runtime.instance.blocking_io.submit(
-              timeout: timeout,
-              cancellation_token: cancellation_token
-            ) do
-              fetch(query: query, cancellation_token: cancellation_token)
-            end
-          end
-
-          # Returns true when this source's content is considered static (i.e. does
-          # not change between agent invocations). Static sources are eligible for
-          # fingerprint-based caching in ContextVersionCache.
-          #
-          # Override in subclasses that return fixed content.
-          #
-          # @return [Boolean]
-          # @api public
-          def static?
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/phronomy/agent/context/knowledge/entity_knowledge.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Agent
-    module Context
-      module Knowledge
-        # A KnowledgeSource that extracts named-entity facts from conversation history.
-        #
-        # This is the knowledge-injection counterpart of the old EntityMemory.
-        # It scans saved user messages with a regex heuristic (no LLM call) and
-        # returns the discovered facts as a single knowledge chunk tagged :entity.
-        #
-        # EntityKnowledge is stateful: it accumulates extracted facts via #update(messages:)
-        # which should be called each time new messages are saved.
-        #
-        # Supported extraction patterns (case-insensitive):
-        #   "my name is Alice"          → { name: "Alice" }
-        #   "I am Alice"                → { identity: "Alice" }
-        #   "I'm a software engineer"   → { occupation: "software engineer" }
-        #   "I work at / for Acme"      → { workplace: "Acme" }
-        #   "I live in Tokyo"           → { location: "Tokyo" }
-        #   "I'm from Tokyo"            → { location: "Tokyo" }
-        #   "I like / love Ruby"        → { preference: "Ruby" }
-        #
-        # @example
-        #   ks = Phronomy::Agent::Context::Knowledge::EntityKnowledge.new
-        #   ks.update(messages: chat_messages)
-        #   agent = MyAgent.new
-        #   agent.add_knowledge_source(ks)
-        #   agent.invoke("What is my name?")
-        class EntityKnowledge < Base
-          PATTERNS = [
-            [:name, /\bmy name is\s+([A-Za-z][A-Za-z0-9 \-']*)/i],
-            [:identity, /\bI\s+am\s+([A-Z][A-Za-z0-9 \-']+)/],
-            [:occupation, /\bI(?:'m| am) a(?:n)?\s+([A-Za-z][A-Za-z0-9 \-']*)/i],
-            [:workplace, /\bI (?:work|worked) (?:at|for|in)\s+([A-Za-z0-9][A-Za-z0-9 \-'.&,]*)/i],
-            [:location, /\bI live in\s+([A-Za-z][A-Za-z0-9 \-']*)/i],
-            [:location, /\bI(?:'m| am) from\s+([A-Za-z][A-Za-z0-9 \-']*)/i],
-            [:preference, /\bI (?:like|love|enjoy)\s+([A-Za-z][A-Za-z0-9 \-']*)/i]
-          ].freeze
-
-          def initialize
-            @entities = {}
-          end
-
-          # Scan messages and accumulate entity facts.
-          # Call this after saving a new set of messages (e.g. from a ConversationManager save hook).
-          #
-          # @param messages [Array] message objects responding to #role and #content
-          # @api public
-          def update(messages:)
-            messages.each do |msg|
-              next unless msg.role.to_sym == :user
-
-              extract(msg.content.to_s).each { |key, value| @entities[key] = value }
-            end
-          end
-
-          # Returns a single chunk containing all known entity facts in XML context format.
-          # Returns an empty array when no entities have been discovered.
-          #
-          # @param query              [String, nil]                    unused — entity knowledge is always fully injected
-          # @param cancellation_token [Phronomy::Concurrency::CancellationToken, nil] optional; raises CancellationError when cancelled
-          # @return [Array<Hash>]
-          # @api public
-          def fetch(query: nil, cancellation_token: nil)
-            cancellation_token&.raise_if_cancelled!
-            return [] if @entities.empty?
-
-            lines = @entities.map { |key, value| "- #{key}: #{value}" }.join("\n")
-            content = <<~CONTENT.chomp
-              Known facts about the user:
-              #{lines}
-            CONTENT
-            [{content: content, type: :entity}]
-          end
-
-          # Returns the current entity store (primarily for testing).
-          #
-          # @return [Hash]
-          # @api public
-          def entities
-            @entities.dup
-          end
-
-          private
-
-          def extract(text)
-            found = {}
-            PATTERNS.each do |key, pattern|
-              if (match = text.match(pattern))
-                value = match[1].strip.sub(/[.!?]\s+.*$/, "").gsub(/[.,;!?]+$/, "")
-                found[key] = value unless value.empty?
-              end
-            end
-            found
-          end
-        end
-      end
-    end
-  end
-end

data/lib/phronomy/agent/context/knowledge/static_knowledge.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Agent
-    module Context
-      module Knowledge
-        # A KnowledgeSource backed by fixed text provided at construction time.
-        #
-        # Useful for injecting static documents, policy files, or configuration
-        # knowledge that does not change per request.
-        #
-        # @example
-        #   ks = Phronomy::Agent::Context::Knowledge::StaticKnowledge.new(
-        #     "Our refund policy: ...",
-        #     type: :policy
-        #   )
-        #   agent = MyAgent.new
-        #   agent.add_knowledge_source(ks)
-        #   agent.invoke("What is the refund policy?")
-        class StaticKnowledge < Base
-          # @param text   [String] the static knowledge text to inject
-          # @param type   [Symbol] semantic tag for the chunk (default :static)
-          # @param source [String, nil] label identifying where this knowledge came from
-          #   (e.g. a filename). Included in the context XML tag and exposed to the LLM
-          #   so that agents can produce grounded citations.
-          # @api public
-          def initialize(text, type: :static, source: nil)
-            @text = text.to_s
-            @type = type
-            @source = source
-          end
-
-          # Returns the fixed text as a single chunk, regardless of query.
-          #
-          # @param query              [String, nil]                    ignored for static knowledge
-          # @param cancellation_token [Phronomy::Concurrency::CancellationToken, nil] optional; raises CancellationError when cancelled
-          # @return [Array<Hash>]
-          # @api public
-          def fetch(query: nil, cancellation_token: nil)
-            cancellation_token&.raise_if_cancelled!
-            return [] if @text.empty?
-
-            chunk = {content: @text, type: @type}
-            chunk[:source] = @source if @source
-            [chunk]
-          end
-
-          # Static knowledge content never changes between invocations.
-          # @return [true]
-          # @api public
-          def static?
-            true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/phronomy/agent/fsm_runtime_adapter.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Agent
-    # Adapts the current AgentInvocation FSM to the ideal manifest-first model.
-    # Every LLM Call receives a freshly fixed Manifest. Persistence and
-    # projection preparation run on BlockingAdapterPool, never on EventLoop.
-    module FsmRuntimeAdapter
-      private
-
-      def filtering_input_action(_agent, invocation)
-        invocation.input = invocation.config.fetch(:phronomy_filtered_input)
-        invocation
-      end
-
-      def building_context_action(agent, invocation)
-        projection = invocation.config.fetch(:phronomy_runtime_projection)
-        invocation.chat = agent.send(:build_chat, model_config: projection.model_config)
-        agent.send(
-          :_apply_context_to_chat,
-          invocation.chat,
-          {
-            system: projection.system,
-            messages: projection.messages,
-            tool_classes: projection.tool_classes,
-            model_config: projection.model_config
-          }
-        )
-        install_tool_interceptors(invocation.chat, invocation)
-        invocation
-      end
-
-      def calling_llm_action(agent, runtime, invocation)
-        prepare_and_start_llm_call(
-          agent,
-          runtime,
-          invocation,
-          streaming: false
-        )
-        invocation
-      end
-
-      def calling_llm_stream_action(agent, runtime, invocation)
-        prepare_and_start_llm_call(
-          agent,
-          runtime,
-          invocation,
-          streaming: true
-        )
-        invocation
-      end
-
-      def prepare_and_start_llm_call(agent, runtime, invocation, streaming:)
-        activation = invocation.config.fetch(:phronomy_activation)
-        if invocation.user_message_sent
-          preparation = runtime.blocking_io.submit do
-            activation.coordinator.prepare_next_llm_call(activation)
-          end
-          preparation.on_complete do |projection, error|
-            if error
-              post_preparation_failure(runtime, invocation, error, streaming: streaming)
-            else
-              start_provider_call(
-                agent,
-                runtime,
-                invocation,
-                activation,
-                projection,
-                streaming: streaming,
-                replace_messages: true
-              )
-            end
-          end
-        else
-          start_provider_call(
-            agent,
-            runtime,
-            invocation,
-            activation,
-            activation.runtime_projection,
-            streaming: streaming,
-            replace_messages: false
-          )
-        end
-      end
-
-      def start_provider_call(
-        agent,
-        runtime,
-        invocation,
-        activation,
-        projection,
-        streaming:,
-        replace_messages:
-      )
-        call_started = false
-        agent.send(
-          :check_cancellation!,
-          invocation.config,
-          "invocation cancelled before LLM call"
-        )
-        if replace_messages
-          invocation.chat = agent.send(:build_chat, model_config: projection.model_config)
-          agent.send(
-            :_apply_context_to_chat,
-            invocation.chat,
-            {
-              system: projection.system,
-              messages: projection.messages,
-              tool_classes: projection.tool_classes,
-              model_config: projection.model_config
-            }
-          )
-          install_tool_interceptors(invocation.chat, invocation)
-          invocation.config[:phronomy_runtime_projection] = projection
-        end
-
-        call_context = activation.begin_llm_call(projection)
-        call_started = true
-        invocation.begin_llm_call!(call_context.fetch(:llm_call_id))
-        message = projection.ask_message
-
-        operation = if streaming
-          Phronomy.configuration.llm_adapter.stream_async(
-            invocation.chat,
-            message,
-            config: invocation.config
-          ) do |chunk|
-            agent.send(
-              :check_cancellation!,
-              invocation.config,
-              "invocation cancelled during streaming"
-            )
-            post_to_invocation!(
-              runtime,
-              invocation.id,
-              :llm_stream_chunk,
-              {content: chunk.content}
-            )
-          end
-        else
-          Phronomy.configuration.llm_adapter.complete_async(
-            invocation.chat,
-            message,
-            config: invocation.config
-          )
-        end
-        observe_manifest_call(
-          operation,
-          activation,
-          invocation,
-          runtime: runtime,
-          streaming: streaming
-        )
-      rescue => error
-        if call_started
-          activation.record_llm_result(
-            response: canonical_response_for(nil, error),
-            error: error,
-            streaming: streaming
-          )
-        end
-        post_llm_result(runtime, invocation, nil, error, streaming: streaming)
-      end
-
-      def observe_manifest_call(operation, activation, invocation, runtime:, streaming:)
-        operation.on_complete do |response, error|
-          activation.record_llm_result(
-            response: canonical_response_for(response, error),
-            error: error,
-            streaming: streaming
-          )
-          post_llm_result(
-            runtime,
-            invocation,
-            response,
-            error,
-            streaming: streaming
-          )
-        end
-      end
-
-      def canonical_response_for(response, error)
-        if error.is_a?(ToolCallIntercepted)
-          error.assistant_outcome || ProviderCallOutcome.capture(response)
-        else
-          ProviderCallOutcome.capture(response)
-        end
-      end
-
-      def post_preparation_failure(runtime, invocation, error, streaming:)
-        post_llm_result(runtime, invocation, nil, error, streaming: streaming)
-      end
-
-      def post_llm_result(runtime, invocation, response, error, streaming:)
-        result = LLMOperationResult.new(
-          response: response,
-          error: error,
-          streaming: streaming
-        )
-        event_type = if error && !error.is_a?(ToolCallIntercepted)
-          :llm_failed
-        else
-          :llm_completed
-        end
-        post_to_invocation!(runtime, invocation.id, event_type, result)
-      end
-    end
-  end
-end

data/lib/phronomy/knowledge_source.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  # KnowledgeSource provides the interface for supplying context region 3 (Knowledge)
-  # to the Context::Assembler.
-  #
-  # Each implementation returns an array of knowledge chunks via #fetch(query:).
-  # Each chunk is a Hash with :content (String) and :type (Symbol) keys.
-  # The Assembler wraps each chunk in an XML context tag before injecting it.
-  module KnowledgeSource
-  end
-end

data/lib/phronomy/llm_context_window/assembler.rb

@@ -1,191 +0,0 @@
-# frozen_string_literal: true
-
-require "cgi"
-
-module Phronomy
-  module LlmContextWindow
-    # Assembler collects all four context regions and produces the final
-    # {system:, messages:, tool_classes:} hash consumed by Agent::Base.
-    #
-    # Regions:
-    #   1. Instruction  — system prompt text set via #add_instruction
-    #   2. Capability   — tool classes registered via #add_capability
-    #   3. Knowledge    — external facts injected via #add_knowledge (generates XML tags)
-    #   4. Conversation — historical messages added via #add_messages
-    #
-    # Token budgeting:
-    #   When a budget is given, Assembler validates that the supplied conversation
-    #   messages fit after instruction, knowledge, and capability costs are
-    #   accounted for. It does not prune messages; Manifest-first Context Policy
-    #   is responsible for context selection.
-    #   Knowledge chunks are always included in full (they are assumed to be
-    #   pre-screened by the caller). When no budget is given all messages are
-    #   passed through unchanged.
-    #
-    # @example
-    #   assembler = Phronomy::LlmContextWindow::Assembler.new(budget: budget)
-    #   assembler.add_instruction("You are a helpful assistant.")
-    #   assembler.add_knowledge("The user lives in Tokyo.", type: :entity, trusted: false)
-    #   assembler.add_messages(manager.load(thread_id: "t1", query: user_input))
-    #   context = assembler.build
-    #   # => { system: "You are ...\n<context ...>...</context>", messages: [...] }
-    class Assembler
-      # Builds a single XML context tag string.
-      # Exposed as a class method so callers (e.g. Agent::Base) can build
-      # static knowledge XML tags independently of an Assembler instance.
-      #
-      # @param text    [String]
-      # @param type    [Symbol, String]
-      # @param trusted [Boolean]
-      # @return [String]
-      # @api private
-      # mutant:disable - text.to_str and plain text (no to_s) are genuine equivalents when text is a String; type.to_str is genuine equivalent when type is a String
-      def self.xml_tag(text, type:, trusted: false)
-        "<context type=\"#{CGI.escapeHTML(type.to_s)}\" trusted=\"#{trusted}\">\n#{CGI.escapeHTML(text.to_s)}\n</context>"
-      end
-
-      # @param budget [Phronomy::LlmContextWindow::TokenBudget, nil]
-      #   when nil no budget validation is performed
-      # @api private
-      # mutant:disable - @instruction = nil deletion is a genuine equivalent (uninitialized Ruby instance variables return nil)
-      def initialize(budget: nil)
-        @budget = budget
-        @instruction = nil
-        @tool_classes = []
-        @knowledge_chunks = []
-        @messages = []
-      end
-
-      # Register tool classes (Region 2).
-      # Estimates their token cost and deducts it from the budget so that
-      # budget estimation accounts for tool definition overhead.
-      #
-      # @param tool_classes [Array<Class, Object>] tool classes or instances
-      # @return [self]
-      # @api private
-      def add_capability(tool_classes)
-        @tool_classes = Array(tool_classes)
-        self
-      end
-
-      # Set the system instruction text (Region 1).
-      # Calling this multiple times replaces the previous value.
-      #
-      # @param text [String]
-      # @return [self]
-      # @api private
-      # mutant:disable - text.to_str and plain text (no .to_s) are genuine equivalents when callers always pass a String
-      def add_instruction(text)
-        @instruction = text.to_s
-        self
-      end
-
-      # Append a knowledge chunk (Region 3).
-      # The chunk is wrapped in an XML context tag automatically.
-      #
-      # @param text    [String]
-      # @param type    [Symbol, String]  semantic label for the context tag (e.g. :entity, :rag, :static)
-      # @param trusted [Boolean]         false (default) indicates externally sourced data
-      # @param source  [String, nil]     optional source label (e.g. filename); included in the
-      #   XML tag so the LLM can produce grounded citations. Omitted when nil.
-      # @return [self]
-      # @api private
-      # mutant:disable - {text:} (shorthand, no .to_s) and text.to_str are genuine equivalents when text is a String; {type:} shorthand is genuine equivalent because xml_context_tag always calls .to_s on chunk[:type]
-      def add_knowledge(text, type:, trusted: false, source: nil)
-        @knowledge_chunks << {text: text.to_s, type: type.to_s, trusted: trusted, source: source}
-        self
-      end
-
-      # Set conversation messages (Region 4). Replaces any previously set messages.
-      #
-      # @param messages [Array] message-like objects with #role and #content
-      # @return [self]
-      # @api private
-      # mutant:disable - @messages = messages (no Array()) is a genuine equivalent when callers always pass an Array
-      def add_messages(messages)
-        @messages = Array(messages)
-        self
-      end
-
-      # Returns the number of tokens available for conversation messages after
-      # accounting for instruction, knowledge, and capability overhead.
-      # Returns +nil+ when no budget is configured.
-      #
-      # @return [Integer, nil]
-      # @api private
-      def available_for_messages
-        return nil unless @budget
-        knowledge_text = @knowledge_chunks.map { |c| xml_context_tag(c) }.join("\n\n")
-        system_parts = [@instruction, knowledge_text.empty? ? nil : knowledge_text].compact
-        system_text = system_parts.join("\n\n")
-        used = TokenEstimator.estimate(system_text) + estimate_capability_tokens
-        @budget.available(used: used)
-      end
-
-      # Assemble the context.
-      #
-      # @return [Hash{Symbol => Object}]
-      #   :system      [String, nil]  combined system prompt (instruction + knowledge XML tags)
-      #   :messages    [Array]        conversation messages, trimmed to budget if set
-      #   :tool_classes [Array]       tool classes/instances to register with the chat
-      # @api private
-      # Raises {Phronomy::ContextLengthError} when a budget is set and the
-      # conversation messages do not fit within the remaining token allowance.
-      # No automatic trimming is performed — callers must pre-process messages
-      # before passing them to the Assembler.
-      #
-      # mutant:disable - multiple genuine equivalent mutations: map{}.join("\n\n") → map{} is genuine; `unless knowledge_text.empty?` vs ternary is genuine; `{ system: unless system_text.empty? }` vs ternary is genuine; `messages:` shorthand vs `messages: messages` is genuine
-      def build
-        knowledge_text = @knowledge_chunks.map { |c| xml_context_tag(c) }.join("\n\n")
-        system_parts = [@instruction, knowledge_text.empty? ? nil : knowledge_text].compact
-        system_text = system_parts.join("\n\n")
-
-        if @budget && @messages.any?
-          capability_tokens = estimate_capability_tokens
-          used = TokenEstimator.estimate(system_text) + capability_tokens
-          remaining = @budget.available(used: used)
-          msg_tokens = @messages.sum { |m| TokenEstimator.estimate(m.content.to_s) }
-          if msg_tokens > remaining
-            raise Phronomy::ContextLengthError,
-              "Context exceeds token budget: messages require #{msg_tokens} tokens but " \
-              "only #{remaining} available (context_window=#{@budget.context_window}, " \
-              "used_by_system=#{used}). Use the Context Policy path to manage message budget."
-          end
-        end
-
-        {
-          system: system_text.empty? ? nil : system_text,
-          messages: @messages,
-          tool_classes: @tool_classes
-        }
-      end
-
-      private
-
-      # Estimates the token cost of all registered tool classes.
-      # Uses each tool's description and parameter names as a proxy for its
-      # JSON Schema size. This is a deliberate simplification — exact token
-      # counts require provider-specific schema serialization which lives in
-      # RubyLLM. The estimate errs on the side of being slightly conservative
-      # so that the conversation budget is not over-allocated.
-      def estimate_capability_tokens
-        @tool_classes.sum do |tc|
-          # Instantiated tool objects (e.g. Phronomy::Tools::Mcp instances) may not be a Class.
-          next 0 unless tc.is_a?(Class) && tc.respond_to?(:description)
-
-          text = [tc.description.to_s]
-          if tc.respond_to?(:parameters)
-            tc.parameters.each_key { |k| text << k.to_s }
-          end
-          TokenEstimator.estimate(text.join(" "))
-        end
-      end
-
-      # mutant:disable - multiple genuine equivalent mutations: chunk.fetch(key) vs chunk[key] (key always present); chunk[:text] no .to_s / .to_str are genuine (stored as String); chunk[:type] no .to_s / .to_str are genuine (stored as String); chunk[:source] no .to_s / .to_str are genuine (truthy branch, always String); src_attr chunk.fetch(:source) is genuine (source key always present)
-      def xml_context_tag(chunk)
-        src_attr = chunk[:source] ? " source=\"#{CGI.escapeHTML(chunk[:source].to_s)}\"" : ""
-        "<context type=\"#{CGI.escapeHTML(chunk[:type].to_s)}\"#{src_attr} trusted=\"#{chunk[:trusted]}\">\n#{CGI.escapeHTML(chunk[:text].to_s)}\n</context>"
-      end
-    end
-  end
-end

data/lib/phronomy/llm_context_window/context_version_cache.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module LlmContextWindow
-    # Caches the assembled static system prompt text keyed by a SHA-256
-    # fingerprint of the agent's instructions + static knowledge content.
-    # Each instance is owned by one thread (stored in +Thread.current+).
-    class ContextVersionCache
-      # @return [String, nil] last stored fingerprint
-      attr_reader :fingerprint
-
-      # @return [String, nil] cached system prompt text
-      attr_reader :system_text
-
-      # @return [Integer] estimated token count of #system_text
-      attr_reader :system_tokens
-
-      def initialize
-        @fingerprint = nil
-        @system_text = nil
-        @system_tokens = 0
-      end
-
-      # Returns true when the given fingerprint matches the stored one.
-      #
-      # @param fingerprint [String] SHA-256 hex digest to compare
-      # @return [Boolean]
-      # @api private
-      def valid?(fingerprint)
-        !@fingerprint.nil? && !@system_text.nil? && @fingerprint == fingerprint
-      end
-
-      # Update the cache with a new fingerprint and system text.
-      #
-      # @param fingerprint  [String] new SHA-256 hex digest
-      # @param system_text  [String] fully assembled system prompt text
-      # @api private
-      def update(fingerprint:, system_text:)
-        @fingerprint = fingerprint
-        @system_text = system_text.to_s
-        @system_tokens = TokenEstimator.estimate(@system_text)
-      end
-
-      # Clear all cached values (used for testing and forced invalidation).
-      def reset
-        @fingerprint = nil
-        @system_text = nil
-        @system_tokens = 0
-      end
-    end
-  end
-end