scout-ai 1.2.3 → 2.0.0

data/lib/scout/llm/backends/huggingface.rb

@@ -1,50 +1,220 @@
-require_relative '../chat'
+# query() calls ScoutPython.dict2hash, which is defined by the scout/python
+# support (scout-rig), not by this repo: require it up-front so the tool loop
+# path does not hit NameError.
+# ScoutCoder: 'scout/python' alone loads the module but PyCall::List (needed by
+# ScoutPython.py2ruby_a inside dict2hash) is only defined by pycall/list, so
+# require that too, otherwise the offline tool-loop path raises NameError.
+require 'scout/python'
+require 'pycall/list'
+require_relative 'default'
 
 module LLM
-  module Huggingface
+  module HuggingfaceMethods
+    MODEL_OPTION_KEYS = %i[
+      task checkpoint dir
+      chat_template chat_template_kwargs generation_kwargs
+      response_parser tool_argument
+      tokenizer_args tokenizer_options
+      training_args training_options
+      trust_remote_code torch_dtype device_map device
+    ]
+
+    def model_options(options = {})
+      options = IndiferentHash.setup(options.dup)
+      model_options = IndiferentHash.pull_keys(options, :model) || {}
+
+      MODEL_OPTION_KEYS.each do |key|
+        model_options[key] = options[key] if options.include?(key)
+      end
+
+      model_options[:model] ||= Scout::Config.get(:model, :huggingface, env: 'HUGGINGFACE_MODEL,HF_MODEL')
+      model_options
+    end
 
-    def self.model(model_options)
+    def model(model_options = {})
       require 'scout/model/python/huggingface'
       require 'scout/model/python/huggingface/causal'
 
-      model, task, checkpoint, dir = IndiferentHash.process_options model_options, :model, :task, :checkpoint, :dir
-      model ||= Scout::Config.get(:model, :huggingface, env: 'HUGGINGFACE_MODEL,HF_MODEL')
+      model_options = IndiferentHash.setup(model_options.dup)
+      model_options = IndiferentHash.add_defaults(model_options, task: 'CausalLM')
+
+      model_name = IndiferentHash.process_options(model_options, :model)
+      dir = model_options[:dir]
+
+      CausalModel.new model_name, dir, model_options
+    end
+
+    def prepare_client(options, messages = nil)
+      client = IndiferentHash.process_options(options, :client)
+
+      if client.nil?
+        model_options = self.model_options(options)
+        Log.debug "Client options: #{model_options.inspect}"
+
+        client = self.model(model_options)
+        options[:model] ||= model_options[:model]
+      else
+        Log.debug "Reusing client: #{Log.fingerprint client}"
+      end
+
+      client
+    end
+
+    def query(client, messages, tools = [], parameters = {})
+      formatted_tools = format_tool_definitions(tools)
+      parameters[:generation_kwargs] ||= IndiferentHash.pull_keys parameters, :generation_kwargs
+      parameters[:chat_template] ||= IndiferentHash.pull_keys parameters, :chat_template
+      parameters = parameters.keys_to_sym 
+      response = client.chat(messages, formatted_tools, parameters)
+      # ScoutCoder: ScoutPython.dict2hash only works on real PyCall dicts; fake
+      # clients in tests replay plain Ruby Hashes (which have no #get), so only
+      # convert when the object actually is a python wrapper.
+      response = ScoutPython.dict2hash(response) if defined?(PyCall) && PyCall === response
+      response = response.to_h if defined?(PyCall) && (PyCall::Dict === response rescue false)
+      IndiferentHash.setup({message: response})
+    rescue
+      Log.debug 'Input parameters: ' + "\n" + JSON.pretty_generate(parameters.except(:tools))
+      raise $!
+    end
+
+    def format_tool_definitions(tools)
+      return [] if tools.nil?
+
+      tools.values.collect do |obj, definition|
+        definition = obj if Hash === obj
+        definition = IndiferentHash.setup(definition)
+
+        definition = case definition[:function]
+                     when Hash
+                       definition
+                     else
+                       { type: :function, function: definition }
+                     end
+
+        definition[:function][:parameters].delete(:defaults) if definition.dig(:function, :parameters)
+
+        definition
+      end
+    end
+
+    def format_tool_call(message)
+      tool_call = IndiferentHash.setup(JSON.parse(message[:content]))
+      arguments = tool_call.delete('arguments') || tool_call.dig('function', 'arguments') || {}
+      arguments = JSON.parse(arguments) rescue arguments if String === arguments
+      id = tool_call.delete('call_id') || tool_call.delete('id')
+      name = tool_call.delete('name') || tool_call.dig('function', 'name')
+
+      {
+        role: 'assistant',
+        tool_calls: [IndiferentHash.setup({
+          type: 'function',
+          id: id,
+          function: {
+            name: name,
+            arguments: arguments
+          }
+        })]
+      }
+    end
+
+    def format_tool_output(message, last_id = nil)
+      info = IndiferentHash.setup(JSON.parse(message[:content]))
+      id = info.delete('call_id') || info.delete('id') || last_id
+      name = info.delete('name')
+      content = info.delete('content')
+
+      {
+        role: 'tool',
+        name: name,
+        content: content,
+        tool_call_id: id,
+      }.compact
+    end
+
+    def parse_tool_call(info)
+      info = IndiferentHash.setup(info)
+      function = IndiferentHash.setup(info[:function] || {})
+
+      arguments = function[:arguments] || info[:arguments] || info[:parameters] || {}
+      arguments = JSON.parse(arguments) rescue arguments if String === arguments
 
-      CausalModel.new model, dir, model_options
+      name = function[:name] || info[:name]
+      id = info[:id] || info[:call_id] || info[:tool_call_id] || (name.to_s + '_' + Misc.digest(arguments.to_json))
+
+      { arguments: arguments, id: id, name: name }
     end
 
-    def self.ask(question, options = {}, &block)
-      model_options = IndiferentHash.pull_keys options, :model
-      model_options = IndiferentHash.add_defaults model_options, :task => "CausalLM"
+    def process_response(messages, response, tools, options, &block)
+      message = response['message']
+      content = message['content']
+      
+      output = []
+      output << IndiferentHash.setup(role: :assistant, content: content) if String === content && !content.empty?
 
-      model = self.model model_options
+      tool_calls = Array(message[:tool_calls]).collect do |tool_call|
+        parse_tool_call(tool_call)
+      end.compact
 
-      messages = LLM.messages(question)
+      if tool_calls.any?
+        output.concat LLM.process_calls(tools, tool_calls, &block)
+      elsif output.empty?
+        output << IndiferentHash.setup(role: :assistant, content: '') if message.include?(:content)
+      end
 
-      system = []
-      prompt = []
-      messages.each do |message|
-        role, content = message.values_at :role, :content
-        if role == 'system'
-          system << content
-        else
-          prompt << content
+      output
+    end
+
+    def tools(messages, options)
+      tools = options.delete :tools
+
+      case tools
+      when Array
+        tools = tools.inject({}) do |acc, definition|
+          IndiferentHash.setup definition
+          name = definition.dig('name') || definition.dig('function', 'name')
+          acc.merge(name => definition)
         end
+      when nil
+        tools = {}
+      end
+
+      chat_messages = messages.reject do |message|
+        message[:role].to_s == 'tool' && (message.include?(:tool_call_id) || message.include?(:name))
       end
 
-      parameters = options.merge(messages: messages)
-      Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
+      tools.merge!(LLM.tools(chat_messages))
+      tools.merge!(LLM.associations(chat_messages))
+
+      Log.high "Tools: #{Log.fingerprint tools.keys}" if tools
 
-      model.eval(messages)
+      tools
     end
 
-    def self.embed(text, options = {})
-      model_options = IndiferentHash.pull_keys options, :model
-      model_options = IndiferentHash.add_defaults model_options, :task => "Embedding"
+    def reasoning(response, current_meta = nil)
+      response = IndiferentHash.setup(response)
+      message = IndiferentHash.setup(response[:message] || response)
+      reasoning_content = message[:thinking]
+      reasoning_content = reasoning_content.gsub("\n", ' ') if String === reasoning_content
+      Log.medium "Reasoning:\n" + Log.color(:cyan, reasoning_content) if reasoning_content
+      reasoning_content
+    end
 
-      model = self.model model_options
+    def embed(text, options = {})
+      model_options = self.model_options(options)
+      model_options[:task] = 'Embedding'
+      model = self.model(model_options)
 
       (Array === text) ? model.eval_list(text) : model.eval(text)
     end
   end
+
+  module Huggingface
+    TAG = 'huggingface'
+    DEFAULT_MODEL = nil
+
+    class << self
+      prepend HuggingfaceMethods
+      include Backend::ClassMethods
+    end
+  end
 end

data/lib/scout/llm/backends/ollama.rb

@@ -59,7 +59,6 @@ module LLM
     end
 
     def process_response(messages, responses, tools, options, &block)
-      Log.debug "Respose: #{Log.fingerprint responses}"
       output = responses.collect do |response|
 
         message = IndiferentHash.setup response['message']
@@ -115,6 +114,19 @@ module LLM
       info['role'] = 'tool'
       info
     end
+
+    # ScoutCoder: Backend::ClassMethods#ask assigns into the meta hash
+    # (meta['timestamp'] = ...) right after update_meta, so a backend override
+    # MUST return a Hash; returning nil crashes the request when log_response
+    # is on (the default). Ollama does not report OpenAI-style usage here, so an
+    # empty hash keeps the request working.
+    def update_meta(response, current_meta = nil)
+      {}
+    end
+
+    def reasoning(response, current_meta = nil)
+    end
+
   end
 
   module OLlama

data/lib/scout/llm/backends/openai.rb

@@ -82,8 +82,6 @@ module LLM
     end
 
     def process_response(messages, response, tools, options, &block)
-      Log.debug "Response: #{Log.fingerprint response}"
-
       raise Exception, response['error'] if response['error']
 
       message = response.dig('choices', 0, 'message')

data/lib/scout/llm/backends/openwebui.rb

@@ -17,20 +17,22 @@ module LLM
     include OpenAIMethods
 
     def client(options, messages = nil)
-      url, key, model = IndiferentHash.process_options options,
-        :url, :key, :model
+      url, key, model, request_timeout = IndiferentHash.process_options options,
+        :url, :key, :model, :request_timeout, 
+        request_timeout: 12000
 
       {
         base_url: url,
         key: key,
         model: model,
         method: :post,
+        request_timeout: request_timeout,
         action: 'chat/completions'
       }
     end
 
     def query(client, messages, tools = [], parameters = {})
-      base_url, key, model, method, action = IndiferentHash.process_options client.dup, :base_url, :key, :model, :method, :action
+      base_url, key, model, method, action, timeout = IndiferentHash.process_options client.dup, :base_url, :key, :model, :method, :action, :request_timeout
       url = File.join(base_url, action.to_s)
 
       parameters = parameters.dup
@@ -38,19 +40,24 @@ module LLM
       parameters[:tools] = format_tool_definitions(tools) if tools && tools.any?
       parameters[:messages] = messages
       parameters[:verify_ssl] = false
+      parameters[:timeout] = timeout.to_i if timeout
+      parameters[:read_timeout] = timeout.to_i if timeout
+      parameters[:open_timeout] = timeout.to_i if timeout
 
       headers = IndiferentHash.setup({ 'Authorization' => "Bearer #{key}", 'Content-Type' => 'application/json' })
-      response = case method.to_sym
-                 when :post
-                   RestClient.post(url, parameters.to_json, headers)
-                 else
-                   raise 'Get not supported'
-                 end
+      Misc.insist do
+        response = case method.to_sym
+                   when :post
+                     RestClient.post(url, parameters.to_json, headers)
+                   else
+                     raise 'Get not supported'
+                   end
 
-      if response.body.nil? || response.body == 'null'
-        raise "No response body: #{JSON.pretty_generate(response)}"
-      else
-        JSON.parse(response.body)
+        if response.body.nil? || response.body == 'null'
+          raise "No response body: #{JSON.pretty_generate(response)}"
+        else
+          JSON.parse(response.body)
+        end
       end
     end
 

data/lib/scout/llm/backends/relay.rb

@@ -3,33 +3,33 @@ require_relative '../chat'
 
 module LLM
 	module Relay
-    def self.upload(server, file)
-      id = Misc.digest(Open.read(file))
-      CMD.cmd("scp #{file} #{server}:.scout/var/ask/#{ id }.json")
-      id
-    end
+      def self.upload(server, file)
+        id = Misc.digest(Open.read(file))
+        CMD.cmd("scp #{file} #{server}:.scout/var/ask/#{ id }.json")
+        id
+      end
 
-    def self.gather(server, id)
-      TmpFile.with_file do |file|
-        begin
-          CMD.cmd("scp #{server}:.scout/var/ask/reply/#{ id }.json #{ file }")
-          JSON.parse(Open.read(file))
-        rescue
-          sleep 1
-          retry
+      def self.gather(server, id)
+        TmpFile.with_file do |file|
+          begin
+            CMD.cmd("scp #{server}:.scout/var/ask/reply/#{ id }.json #{ file }")
+            JSON.parse(Open.read(file))
+          rescue
+            sleep 1
+            retry
+          end
         end
       end
-    end
 
-    def self.ask(question, options = {}, &block)
-      server = IndiferentHash.process_options options, :server
-      server ||= Scout::Config.get :server, :ask_relay, :relay, :ask, env: 'ASK_ENDPOINT,LLM_ENDPOINT', default: :openai
+      def self.ask(question, options = {}, &block)
+        server = IndiferentHash.process_options options, :server
+        server ||= Scout::Config.get :server, :ask_relay, :relay, :ask, env: 'ASK_ENDPOINT,LLM_ENDPOINT', default: :openai
 
-      options[:question] = question
-      TmpFile.with_file(options.to_json) do |file|
-        id = upload(server, file)
-        gather(server, id)
+        options[:question] = question
+        TmpFile.with_file(options.to_json) do |file|
+          id = upload(server, file)
+          gather(server, id)
+        end
       end
     end
-  end
 end

data/lib/scout/llm/backends/responses.rb

@@ -11,7 +11,7 @@ module LLM
   end
 
   module Responses
-    TAG = 'openai'
+    TAG = 'responses'
     DEFAULT_MODEL = 'gpt-5-nano'
 
     class << self

data/lib/scout/llm/chat/agent_meta.rb

@@ -0,0 +1,264 @@
+module Chat
+  # Render the human readable message for a malformed or unusable agent_meta
+  # receipt.  This is a plain module function, not a dedicated error class: the
+  # raised exception is ScoutException and the structured facts (chat path,
+  # output address, call id, tool name, raw entry, reference) always travel in
+  # the on_error callback `reference` Hash built by Chat.agent_meta_error_reference.
+  def self.agent_meta_error_message(reason, chat_path: nil, output_address: nil, call_id: nil, tool_name: nil, reference: nil)
+    message = +"agent_meta receipt #{reason}"
+    message << " in chat #{chat_path}" if chat_path
+    message << " at output #{Array(output_address).inspect}" unless output_address.nil?
+    details = []
+    details << "call #{call_id}" if call_id
+    details << "tool #{tool_name}" if tool_name
+    message << " (#{details * ', '})" unless details.empty?
+    message << " reference #{reference}" if reference
+    message
+  end
+
+  # Delegated-agent inference evidence embedded in function_call_output
+  # envelopes.
+  #
+  # When a tool returns an LLM::Agent, LLM.process_calls embeds the child
+  # agent's inference evidence in the parent function_call_output JSON under
+  # the `meta` key.  These records are portable evidence of child inference
+  # events and child producer jobs; they are NOT ordinary parent-chat meta
+  # messages and must never be appended to the parent Chat (that would
+  # corrupt checkpoint bookkeeping).  Everything in this module is read-only
+  # provenance analysis: plain Arrays and Hashes in and out, no wrapper
+  # classes, no mutation of the inspected chat.
+  #
+  # Two receipt formats are accepted (the envelope is generic: any tool
+  # output may carry one, so nothing here special-cases a tool name such as
+  # `ask`):
+  #
+  #   meta (current):  {"meta": [{"pt": 10, "inference_id": "w1"}, ...]}
+  #     Entries are ALREADY-DESERIALIZED field Hashes (no role/content
+  #     wrapper, no re-parsing).  Evidence addresses use the [:meta, index]
+  #     suffix, mirroring the persisted key.  raw_message is nil.
+  #
+  #   agent_meta (legacy):  {"agent_meta": [{"role": "meta", "content": "pt=10 ..."}, ...]}
+  #     Serialized meta messages; each content String is parsed with
+  #     Chat.parse_meta.  Evidence addresses keep the [:agent_meta, index]
+  #     suffix and raw_message is {role: 'meta', content: <String>} so old
+  #     data stays addressable exactly as it always was.
+  #
+  # When both keys are present in one envelope the `meta` key wins (current
+  # writer emits exactly one of the two).
+
+  # One Hash per valid agent_meta entry found across the paired tool outputs
+  # of the chat.  Pairing is delegated to Chat.tool_calls; raw text is never
+  # scanned with regular expressions.
+  #
+  # Record shape:
+  #
+  #   {
+  #     origin: :agent_meta,
+  #     meta: <IndiferentHash of meta fields>,
+  #     source: <String path or nil>,
+  #     output_address: <as returned by Chat.tool_calls>,
+  #     evidence_address: <output_address + [:agent_meta, index]> (legacy
+  #                       entries; current-format entries use [:meta, index]),
+  #     call_id: ...,
+  #     tool_name: ...,
+  #     agent_meta_index: ...,
+  #     raw_message: {role: "meta", content: "..."} (legacy; nil for
+  #                  current-format entries, which are born deserialized)
+  #   }
+  #
+  # Malformed data is skipped.  When the caller supplies an Array through the
+  # `warnings` keyword, each malformed item appends one warning Hash:
+  #
+  #   {
+  #     origin: :agent_meta,
+  #     reason: :not_an_array | :not_a_hash | :invalid_role |
+  #             :invalid_content | :unparseable_meta | :empty_meta,
+  #     source:, output_address:, evidence_address:,
+  #     call_id:, tool_name:,
+  #     agent_meta_index: (nil when the whole receipt value is malformed),
+  #     evidence_address: (nil when the index is unknown),
+  #     raw_entry: <the malformed item as found>
+  #   }
+  #
+  # :empty_meta applies to current-format entries (deserialized field Hash
+  # with no fields).  Malformed receipt data is never silently reinterpreted
+  # as provenance.
+  def self.agent_meta_evidence(chat, source: nil, warnings: nil)
+    tool_calls(chat, source: source).flat_map do |call|
+      output_info = call[:output_info]
+      next [] unless Hash === output_info
+
+      # Key presence, not truthiness: an explicit `meta: false` or
+      # `agent_meta: nil` is a present-but-malformed receipt and must warn,
+      # while an absent key simply has no receipt at all.
+      has_meta = output_info.key?('meta') || output_info.key?(:meta)
+      has_agent_meta = output_info.key?('agent_meta') || output_info.key?(:agent_meta)
+      next [] unless has_meta || has_agent_meta
+
+      # Current writer emits exactly one of the two; when both are present
+      # the current `meta` key wins and the legacy one is ignored.
+      format = has_meta ? :meta : :agent_meta
+      agent_meta = output_info['meta']
+      agent_meta = output_info[:meta] if agent_meta.nil? && output_info.key?(:meta)
+      agent_meta = output_info['agent_meta'] if format == :agent_meta && agent_meta.nil?
+      agent_meta = output_info[:agent_meta] if format == :agent_meta && agent_meta.nil?
+
+      add_warning = lambda do |reason, index, raw_entry|
+        return unless Array === warnings
+        output_address = call[:output_address]
+        evidence_address = if index.nil?
+                             nil
+                           elsif Array === output_address
+                             output_address + [format, index]
+                           else
+                             [output_address, format, index]
+                           end
+        warnings << {
+          origin: :agent_meta,
+          reason: reason,
+          source: source ? source.to_s : nil,
+          output_address: output_address,
+          evidence_address: evidence_address,
+          call_id: call[:call_id],
+          tool_name: call[:name],
+          agent_meta_index: index,
+          raw_entry: raw_entry
+        }
+        nil
+      end
+
+      unless Array === agent_meta
+        add_warning.call(:not_an_array, nil, agent_meta)
+        next []
+      end
+
+      agent_meta.each_with_index.collect do |entry, index|
+        unless Hash === entry
+          add_warning.call(:not_a_hash, index, entry)
+          next nil
+        end
+
+        meta, raw_message =
+          if format == :meta
+            # Current format: entries are already-deserialized field Hashes.
+            # No role/content wrapper and no re-parse; an entry with no
+            # fields carries no evidence and is warned about.
+            fields = IndiferentHash.setup(entry.dup)
+            [fields, nil]
+          else
+            # Legacy format: serialized {role: 'meta', content: 'k=v ...'}
+            # meta messages.
+            role = entry['role'] || entry[:role]
+            content = entry['content'] || entry[:content]
+
+            if role.to_s != 'meta'
+              add_warning.call(:invalid_role, index, entry)
+              next nil
+            end
+
+            unless String === content
+              add_warning.call(:invalid_content, index, entry)
+              next nil
+            end
+
+            [parse_meta(content), { role: role, content: content }]
+          end
+
+        if meta.empty?
+          reason = format == :meta ? :empty_meta : :unparseable_meta
+          add_warning.call(reason, index, entry)
+          next nil
+        end
+
+        output_address = call[:output_address]
+        # Without a source, Chat.tool_calls reports a bare message index; the
+        # receipt address keeps the key-mirroring suffix so it stays truthful
+        # to the persisted envelope ([:meta, index] for current data,
+        # [:agent_meta, index] for legacy data).
+        evidence_address = if Array === output_address
+                             output_address + [format, index]
+                           else
+                             [output_address, format, index]
+                           end
+        {
+          origin: :agent_meta,
+          meta: meta,
+          source: source ? source.to_s : nil,
+          output_address: output_address,
+          evidence_address: evidence_address,
+          call_id: call[:call_id],
+          tool_name: call[:name],
+          agent_meta_index: index,
+          raw_message: raw_message
+        }
+      end.compact
+    end
+  end
+
+  # All meta evidence for a chat, with a shared `origin` field:
+  #
+  #   * :chat_meta   - normal persisted `meta:` messages of this chat
+  #                    (meta, source, meta_address in [source, index] form,
+  #                    message: the raw message);
+  #   * :agent_meta  - receipt entries from function_call_output envelopes,
+  #                    appended after the local records (see
+  #                    Chat.agent_meta_evidence).
+  #
+  # This is an analysis view only.  Chat#meta, chat.role_messages(:meta), and
+  # Chat.token_totals([chat]) keep describing the local Chat and do not absorb
+  # delegated receipts.
+  #
+  # Validation asymmetry, intentional: ordinary persisted `meta:` messages are
+  # historical data with no enforced schema, so they stay permissive here (a
+  # record is included even when Chat.parse_meta yields an empty Hash) exactly
+  # as Chat.trace_chats and Chat.token_totals have always treated them.  A
+  # receipt instead has a narrow, generated schema, so malformed receipt
+  # entries are skipped with a warning instead of being silently trusted.
+  def self.meta_evidence(chat, source: nil, warnings: nil)
+    local = chat.each_with_index.select do |message, _index|
+      message[:role].to_s == 'meta'
+    end.collect do |message, index|
+      {
+        origin: :chat_meta,
+        meta: parse_meta(message[:content].to_s),
+        source: source ? source.to_s : nil,
+        meta_address: source ? [source.to_s, index] : index,
+        message: message
+      }
+    end
+
+    local + agent_meta_evidence(chat, source: source, warnings: warnings)
+  end
+
+  # agent_meta entries that carry a producer job reference (`job=`).  Each
+  # returned record is the full evidence record with the reference added at
+  # the top level as `job:`, so both the reference value and its evidence
+  # location stay together.  Job projection metas are producer references,
+  # not token events.
+  def self.agent_meta_job_references(chat, source: nil, warnings: nil)
+    agent_meta_evidence(chat, source: source, warnings: warnings)
+      .select { |record| record[:meta][:job] }
+      .collect { |record| record.merge(job: record[:meta][:job]) }
+  end
+
+  # Uniform `reference` Hash handed to on_error for agent_meta provenance
+  # problems.  Keys are always present; unavailable facts are nil.  It retains
+  # the original reference/raw entry, the reason, the output and evidence
+  # addresses, the receipt entry index, the call id and tool name when known,
+  # and the chat path.
+  def self.agent_meta_error_reference(reason:, source:, output_address: nil, evidence_address: nil,
+                                      call_id: nil, tool_name: nil, agent_meta_index: nil,
+                                      raw_entry: nil, reference: nil)
+    {
+      reason: reason,
+      source: source ? source.to_s : nil,
+      output_address: output_address,
+      evidence_address: evidence_address,
+      call_id: call_id,
+      tool_name: tool_name,
+      agent_meta_index: agent_meta_index,
+      raw_entry: raw_entry,
+      reference: reference
+    }
+  end
+end