scout-ai 1.2.3 → 2.0.0

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

@@ -0,0 +1,76 @@
+require 'json'
+
+module Chat
+  def self.parse_tool_message(message)
+    JSON.parse(message[:content].to_s)
+  rescue JSON::ParserError, TypeError
+    nil
+  end
+
+  # Pair tool calls with their outputs within one persisted chat. This reports
+  # structural facts only; use tool_call_status for the common interpretation
+  # of exception and exit-status outputs.
+  def self.tool_calls(chat, source: nil)
+    calls = []
+    outputs = Hash.new { |hash, key| hash[key] = [] }
+
+    chat.each_with_index do |message, index|
+      role = message[:role].to_s
+      next unless %w[function_call mcp_call function_call_output].include?(role)
+      info = parse_tool_message(message)
+      next unless Hash === info
+
+      call_id = info['id'] || info['call_id'] || info['tool_call_id']
+      address = source ? [source.to_s, index] : index
+
+      if role == 'function_call_output'
+        outputs[call_id] << { address: address, index: index, message: message, info: info } if call_id
+      else
+        calls << {
+          call_id: call_id,
+          name: info['name'] || info.dig('function', 'name'),
+          arguments: info['arguments'] || info.dig('function', 'arguments'),
+          role: role.to_sym,
+          call_address: address,
+          call_index: index,
+          call_message: message,
+          call_info: info
+        }
+      end
+    end
+
+    calls.collect do |call|
+      output = call[:call_id] && outputs[call[:call_id]].shift
+      call.merge(
+        output_address: output && output[:address],
+        output_index: output && output[:index],
+        output_message: output && output[:message],
+        output_info: output && output[:info],
+        output: output && output[:info]['content']
+      )
+    end
+  end
+
+  # Common, deliberately separate interpretation of a paired tool output.
+  # Missing output is unknown, JSON exceptions fail, and command-style JSON
+  # results fail when exit_status is non-zero.
+  def self.tool_call_status(call)
+    return { success: nil, reason: :missing_output } unless call[:output_info]
+
+    content = call[:output]
+    parsed = begin
+               JSON.parse(content.to_s)
+             rescue JSON::ParserError, TypeError
+               nil
+             end
+
+    if Hash === parsed && parsed['exception']
+      { success: false, reason: :exception, exception: parsed['exception'] }
+    elsif Hash === parsed && parsed.include?('exit_status')
+      status = parsed['exit_status'].to_i
+      { success: status == 0, reason: :exit_status, exit_status: status }
+    else
+      { success: true, reason: :output }
+    end
+  end
+end

data/lib/scout/llm/chat.rb

@@ -4,6 +4,11 @@ require_relative 'tools'
 require_relative 'chat/annotation'
 require_relative 'chat/parse'
 require_relative 'chat/process'
+require_relative 'chat/persist'
+require_relative 'chat/prompt'
+require_relative 'chat/provenance'
+require_relative 'chat/tool_calls'
+require_relative 'chat/agent_meta'
 
 module LLM
   def self.messages(question, role = nil)
@@ -21,10 +26,21 @@ module LLM
 
     Chat.parse question
   end
+
   def self.chat(file = [], original = nil)
     original ||= (String === file and Open.exists?(file)) ? file : Path.setup($0.dup)
     caller_lib_dir = Path.caller_lib_dir(nil, 'chats')
 
+    # ScoutCoder: anchor point for per-project library stores. The chat file
+    # is the object of the ask, so its libdir — not the framework's stack —
+    # defines "the project this chat belongs to". Guard against marker climbs
+    # that overshoot to nil/''/'/', and never clobber an explicit value: ENV
+    # propagates into job subprocesses (bwrap) while Dir.pwd under exec is the
+    # workflow's own directory, so ENV is the only reliable channel.
+    if ENV['SCOUT_CHAT_DIR'].to_s.empty? && caller_lib_dir && ! ['', '/'].include?(caller_lib_dir)
+      ENV['SCOUT_CHAT_DIR'] = Path.caller_lib_dir(original)
+    end
+
     if Path.is_filename? file
       messages = self.messages Open.read(file), file
     else
@@ -35,8 +51,9 @@ module LLM
     messages = Chat.imports messages, original, caller_lib_dir
 
     messages = Chat.clear messages
-    messages = Chat.clean messages
+    messages = Chat.clean messages, :skip
 
+    messages = Chat.config messages
     messages = Chat.tasks messages
     messages = Chat.jobs messages
     messages = Chat.files messages, original, caller_lib_dir
@@ -64,4 +81,3 @@ module LLM
     Chat.purge(...)
   end
 end
-

data/lib/scout/llm/embed.rb

@@ -3,13 +3,13 @@ require 'scout'
 module LLM
   def self.embed(text, options = {})
     endpoint = IndiferentHash.process_options options, :endpoint
-    endpoint ||= Scout::Config.get :endpoint, :embed, :llm, env: 'EMBED_ENDPOINT,LLM_ENDPOINT', default: :openai
+    endpoint ||= Scout::Config.get :endpoint, :embed, :llm, env: 'EMBED_ENDPOINT,LLM_ENDPOINT', default: :embed
     if endpoint && Scout.etc.AI[endpoint].exists?
       options = IndiferentHash.add_defaults options, Scout.etc.AI[endpoint].yaml
     end
 
     backend = IndiferentHash.process_options options, :backend
-    backend ||= Scout::Config.get :backend, :embed, :llm, env: 'EMBED_BACKEND,LLM_BACKEND', default: :openai
+    backend ||= Scout::Config.get :backend, :embed, :llm, env: 'EMBED_BACKEND,LLM_BACKEND', default: :embed
 
     case backend
     when :openai, "openai"
@@ -24,11 +24,19 @@ module LLM
     when :openwebui, "openwebui"
       require_relative 'backends/openwebui'
       LLM::OpenWebUI.embed(text, options)
+    when :huggingface, "huggingface"
+      require_relative 'backends/huggingface'
+      LLM::Huggingface.embed(text, options)
     when :relay, "relay"
       require_relative 'backends/relay'
       LLM::Relay.embed(text, options)
     else
-      raise "Unknown backend: #{backend}"
+      # Fall back to the runtime backend registry (mirrors LLM.ask) so
+      # test-only or plugin backends registered with LLM.register_backend
+      # work for embeddings too, instead of only for ask.
+      mod = LLM::BACKENDS[backend]
+      raise "Unknown backend: #{backend}" if mod.nil?
+      mod.embed(text, options)
     end
   end
 end

data/lib/scout/llm/image.rb

@@ -0,0 +1,86 @@
+module LLM
+
+  def self.image(question, options = {}, &block)
+    messages = LLM.chat(question)
+    options = IndiferentHash.add_defaults LLM.options(messages), options
+
+    endpoint, persist = IndiferentHash.process_options options, :endpoint, :persist, persist: true
+
+    endpoint ||= Scout::Config.get :endpoint, :image, :ask, :llm, env: 'IMAGE_ENDPOINT,ASK_ENDPOINT,LLM_ENDPOINT,ENDPOINT,LLM,ASK,IMAGE'
+    if endpoint && Scout.etc.AI[endpoint].find_with_extension(:yaml).exists?
+      options = IndiferentHash.add_defaults options, Scout.etc.AI[endpoint].yaml
+    elsif endpoint && endpoint != ""
+      raise "Endpoint not found #{endpoint}"
+    end
+
+    agent_name = IndiferentHash.process_options options, :agent
+    agent_name = nil if %(none false nil).include?(agent_name.to_s)
+    if agent_name
+      options[:endpoint] ||= endpoint
+      agent = LLM::Agent.load_agent agent_name
+      agent.follow messages
+      res = agent.ask options
+      return res
+    end
+
+    meta = Chat.meta(messages)
+    options[:current_meta] = meta if meta and meta.any?
+
+    if options[:backend].to_s == 'responses' && options[:previous_response].to_s != 'false'
+      messages = Chat.clear(messages, 'previous_response_id')
+    else
+      messages = Chat.clean(messages, 'previous_response_id')
+      options.delete :previous_response_id
+    end
+
+    Log.high Log.color :green, "Asking #{endpoint || options[:endpoint] || 'client'}: #{options[:previous_response_id]}\n" + Chat.print_brief(messages)
+    tools = options[:tools]
+    Log.medium "Tools: #{Log.fingerprint tools.keys}" if tools
+    Log.debug "#{Log.fingerprint tools}}" if tools
+
+    res = Persist.persist(endpoint, :json, prefix: "LLM image", other: options.merge(messages: messages), persist: persist, dir: Scout.var.cache.ask) do
+      backend = IndiferentHash.process_options options, :backend
+      backend ||= Scout::Config.get :backend, :ask, :llm, env: 'ASK_BACKEND,LLM_BACKEND', default: :responses
+
+      case backend
+      when :openai, "openai"
+        require_relative 'backends/openai'
+        LLM::OpenAI.image(messages, options, &block)
+      when :anthropic, "anthropic"
+        require_relative 'backends/anthropic'
+        LLM::Anthropic.image(messages, options, &block)
+      when :responses, "responses"
+        require_relative 'backends/responses'
+        LLM::Responses.image(messages, options, &block)
+      when :ollama, "ollama"
+        require_relative 'backends/ollama'
+        LLM::OLlama.image(messages, options, &block)
+      when :vllm, "vllm"
+        require_relative 'backends/vllm'
+        LLM::VLLM.image(messages, options, &block)
+      when :openwebui, "openwebui"
+        require_relative 'backends/openwebui'
+        LLM::OpenWebUI.image(messages, options, &block)
+      when :huggingface, "huggingface"
+        require_relative 'backends/huggingface'
+        LLM::Huggingface.image(messages, options, &block)
+      when :relay, "relay"
+        require_relative 'backends/relay'
+        LLM::Relay.image(messages, options, &block)
+      when :bedrock, "bedrock"
+        require_relative 'backends/bedrock'
+        LLM::Bedrock.image(messages, options, &block)
+      else
+        mod = BACKENDS[backend]
+        raise "Unknown backend: #{backend}" if mod.nil?
+        mod.ask(messages, options, &block)
+      end
+    end
+
+    Chat.setup res if Array === res
+
+    Log.high Log.color :blue, "Response:\n" + Chat.print_brief(res, %w(meta assistant)) if Array === res
+
+    res
+  end
+end

data/lib/scout/llm/mcp.rb

@@ -15,14 +15,22 @@ module Workflow
       annotations[:idempotent_hint] = true
       annotations[:open_world_hint] = false
       MCP::Tool.define(name:task, description: description, input_schema: input_schema, annotations:annotations) do |parameters,context|
-        self.job(name, parameters)
+        self.job(name, parameters).run
       end
     end
 
+    version = "1.0.0"
     MCP::Server.new(
       name: self.name,
-      version: "1.0.0",
+      version: version,
       tools: tools
     )
   end
+
+  def mcp_stdio(*tasks)
+    server = mcp(*tasks)
+    transport = MCP::Server::Transports::StdioTransport.new(server)
+    server.transport = transport
+    transport.open
+  end
 end

data/lib/scout/llm/rag.rb

@@ -22,11 +22,11 @@ module LLM
       u
     end
 
-    def self.top(texts, prompt, num = 10)
-      data = texts.collect{|text| LLM.embed(text) }
+    def self.top(texts, prompt, num = 10, ...)
+      data = texts.collect{|text| LLM.embed(text, ...) }
 
       i = LLM::RAG.index(data)
-      pos, scores = i.search_knn LLM.embed(prompt), num
+      pos, scores = i.search_knn LLM.embed(prompt, ...), num
 
       texts.values_at *pos.reverse
     end

data/lib/scout/llm/tools/call.rb

@@ -1,3 +1,11 @@
+# LLM::Agent is referenced below in content dispatch, but the require chain
+# chat -> tools -> tools/call does not pull in scout/llm/agent (agent.rb
+# requires ask.rb, which requires chat.rb, so loading agent from chat would
+# be circular). Load it lazily on first use instead of at file load time.
+module LLM
+  require 'scout/llm/agent' unless defined?(LLM::Agent)
+end
+
 module LLM
   @max_content_length = Scout::Config.get(:max_content_length, :llm_tools, :tools, :llm, :ask, default: 100_000)
   self.singleton_class.attr_accessor :max_content_length
@@ -17,10 +25,31 @@ module LLM
     [tool_call_id, function_name, function_arguments]
   end
 
+  # Normalize serialized meta messages (the chat-message shape
+  # {role: 'meta', content: 'k=v k=v ...'}) into the receipt format: an Array
+  # of DESERIALIZED field Hashes, as emitted under the `meta` key of
+  # function_call_output envelopes.
+  #
+  # Non-Hash entries, non-meta roles, non-String contents and entries that
+  # parse to no fields at all are dropped.  The reader side keeps the full
+  # malformed-entry warning taxonomy; the writer side simply never emits an
+  # entry that carries no evidence.
+  def self.meta_receipt_from_messages(messages)
+    Array(messages).collect do |msg|
+      next nil unless Hash === msg
+      role = msg[:role] || msg['role']
+      content = msg[:content] || msg['content']
+      next nil unless role.to_s == 'meta' && String === content
+      fields = Chat.parse_meta(content)
+      fields.empty? ? nil : fields
+    end.compact
+  end
+
   def self.process_calls(tools, calls, &block)
     max_content_length = LLM.max_content_length
     IndiferentHash.setup tools
 
+    start_timestamp = Chat.timestamp
     tool_call_content = calls.collect do |tool_call|
       tool_call = IndiferentHash.setup tool_call
       tool_call_id, function_name, function_arguments = call_id_name_and_arguments(tool_call)
@@ -40,6 +69,13 @@ module LLM
       function_response = case obj
                           when Proc
                             obj.call function_name, function_arguments
+                          when String
+                            if Kernel.const_defined? obj
+                              wt = Kernel.const_get obj
+                            else
+                              wf = Workflow.require_workflow obj
+                            end
+                            call_workflow(wf, function_name, function_arguments)
                           when Workflow
                             call_workflow(obj, function_name, function_arguments)
                           when KnowledgeBase
@@ -57,12 +93,28 @@ module LLM
                   function_response
                 when String
                   function_response
+                when IO
+                  function_response.read
+                when TSV::Dumper
+                  function_response.read
+                when LLM::Agent
+                  function_response
                 when nil
                   "success"
                 when Exception
-                  {exception: function_response.message, stack: function_response.backtrace }.to_json
+                  function_response
+                when Hash
+                  IndiferentHash.setup(function_response)
                 else
-                  function_response.to_json
+                  begin
+                    function_response.to_json
+                  rescue Exception => e
+                    begin
+                      function_response.to_s
+                    rescue
+                      {exception: e.message, stack: e.backtrace }.to_json
+                    end
+                  end
                 end
 
       content = content.to_s if Numeric === content
@@ -90,29 +142,103 @@ module LLM
       end
     end
 
+    agents = tool_call_content.collect{|p| p.last }.select{|c| LLM::Agent === c }
+
+    agent_answers = TSV.setup({}, key_field: 'Pos', fields: ['Content', 'Job path'], type: :list)
+
+    if agents.any?
+      cpus = Scout::Config.get(:cpus, :agent_ask, :agents, env: 'ASK_AGENTS', default: 3)
+      Open.traverse (0..agents.length-1).to_a, cpus: cpus, bar: 'Asking agents', type: :list, into: agent_answers do |i|
+        agent = agents[i]
+        res = agent.chat return_messages: true
+        path = Step === agent.job ? agent.job.path : nil
+        [i, [res, path]]
+      end
+    end
+
     tool_call_content.collect do |function_name,function_arguments,tool_call_id,tool_call,content|
+      error = false
+      stack = nil
+      meta = []
       if Step === content
         step = content
         if content.done?
-          content = content.load.to_json if content.done?
+          content = content.load
         elsif content.error? && content.exception
-          content = {exception: content.exception.message, stack: content.exception.backtrace }.to_json
+          error = :error
+          content = if String === content.exception
+                      {exception: content.exception}.to_json
+                    else
+                      content = {exception: content.exception.message, exception_line: content.exception.backtrace&.first}.to_json
+                    end
         else
           begin
-            content = content.run.to_json
-          rescue
-            content = {exception: $!.message, stack: $!.backtrace }.to_json
+            content = content.run
+          rescue Exception
+            error = :error
+            stack = $!.backtrace
+            content = {exception: $!.message, exception_line: $!.backtrace&.first}.to_json
           end
         end
+      elsif LLM::Agent === content
+        res, path = agent_answers[agents.index(content)]
+
+        begin
+          Chat.allow_read_job Step.load(path) 
+        rescue
+        end if path
+
+        content.current_chat.follow(res)
+        # Receipt format: the child agent's meta messages are DESERIALIZED
+        # into plain field Hashes and emitted under the `meta` key (the
+        # legacy serialized `agent_meta` array is no longer written).
+        # Entries that parse to no fields are dropped: a receipt entry
+        # exists to carry evidence fields, and an empty one carries none.
+        meta = LLM.meta_receipt_from_messages(Chat.find_role(res, :meta))
+        content = content.answer
+      elsif Exception === content
+        error = :error
+        stack = content.backtrace
+        content = {exception: content.message, exception_line: content.backtrace&.first}.to_json
       else
         step = nil
       end
 
+      content = case content
+                when Hash
+                  # ScoutCoder: When the response of the function contains a
+                  # Hash with only two keys, content and meta or content and
+                  # agent_meta treat it as content with inference meta. Extract
+                  # accordingly.
+                  content = IndiferentHash.setup(content)
+                  keys = content.keys.collect{|k| k.to_s }
+                  if keys.sort == %w(meta content)
+                    # New inbound shape: `meta` is already the deserialized
+                    # receipt array; pass it through verbatim.
+                    meta, content = content.values_at :meta, :content
+                    content
+                  elsif keys.sort == %w(agent_meta content)
+                    # Legacy inbound shape: serialized meta messages;
+                    # normalize them into the new deserialized form.
+                    meta = LLM.meta_receipt_from_messages(content[:agent_meta])
+                    content = content[:content]
+                  else
+                    content.to_json
+                  end
+                when TSV
+                  content.to_s
+                when String
+                  content
+                else
+                  content.to_json
+                end
+
       if (String === content) && content.length > max_content_length
-        exception_msg = "Function #{function_name} #{tool_call_id} (#{Log.fingerprint function_arguments}) returned #{content.length} characters, which is more than the maximum of #{max_content_length}. To protect the model context window this result was not returned."
-        exception_msg += " The results is made available at '#{step.path}'." if step
+        exception_msg = "Function #{function_name} #{tool_call_id} (#{Log.fingerprint function_arguments}) was executed successfully, but it returned #{content.length} characters, which is more than the maximum of #{max_content_length}. To protect the model context window this result was not returned. Here is a fingerprint of the content #{Log.fingerprint(content)}."
+        exception_msg += " The results was persisted at '#{step.path}'." if step
         Log.high exception_msg
         content = {exception: exception_msg, stack: caller}.to_json
+        error = :truncated
       end
 
       Log.high "Called #{function_name} #{tool_call_id} (#{Log.fingerprint function_arguments}): " + Log.fingerprint(content)
@@ -120,13 +246,36 @@ module LLM
       response_message = {
         name: function_name,
         content: content,
-        id: tool_call_id
+        id: tool_call_id,
       }
 
+      response_message[:error] = error if error
+      response_message[:stack] = stack if stack
+      meta = [meta] if Hash === meta
+      response_message[:meta] = meta if meta && meta.any?
+
+      if step
+        response_message.merge!(
+          step: step.short_path,
+          start_timestamp: start_timestamp,
+          timestamp: Chat.timestamp
+        )
+      else
+        response_message.merge!(
+          start_timestamp: start_timestamp,
+          timestamp: Chat.timestamp
+        )
+      end
+
 
+      json_content = begin
+                       response_message.to_json
+                     rescue
+                       "Error turning content into JSON (#{$!.message}): #{Log.fingerprint response_message}"
+                     end
       [ 
         tool_call,
-        IndiferentHash.setup({role: "function_call_output", content: response_message.to_json})
+        IndiferentHash.setup({role: "function_call_output", content: json_content})
       ]
     end.flatten
   end

data/lib/scout/llm/tools/knowledge_base.rb

@@ -85,7 +85,7 @@ Returns a list in the format source~target.
 
     if fields.length > 1
       description = <<-EOF
-Return details of association as a dictionary object.
+Return details of a given list of association pairs as a dictionary object. Use the function #{database} to find the associations pairs. 
 Each key is an association and the value is an array with the values of the different fields you asked for, or for all fields otherwise.
 The fields are: #{fields * ', '}.
 Multiple values may be present and use the charater ";" to separate them.

data/lib/scout/llm/tools/workflow.rb

@@ -1,5 +1,15 @@
 require 'scout/workflow'
 module LLM
+  def self.scout_to_tool_input_type(type)
+    type = :text if type == :chat
+    type = :string if type == :text
+    type = :string if type == :select
+    type = :string if type == :path
+    type = :number if type == :float
+    type = :array if type.to_s.end_with?('_array')
+    type
+  end
+
   def self.task_tool_definition(workflow, task_name, inputs = nil)
     task_info = workflow.task_info(task_name)
     return nil if task_info.nil?
@@ -19,20 +29,18 @@ module LLM
 
     end
 
+
     properties = task_info[:inputs].inject({}) do |acc,input|
       next acc if names and not names.include?(input)
       type = task_info[:input_types][input]
       description = task_info[:input_descriptions][input]
 
-      type = :string if type == :text
-      type = :string if type == :select
-      type = :string if type == :path
-      type = :number if type == :float
+      type = scout_to_tool_input_type(type) 
       type = :array if type.to_s.end_with?('_array')
 
       acc[input] = {
-        "type": type,
-        "description": description || ''
+        type: type,
+        description: description || ''
       }
 
       if type == :array
@@ -49,6 +57,13 @@ module LLM
       acc
     end
 
+    if not workflow.exec_exports.include?(task_name.to_sym)
+      properties[:return_path] = {
+        type: 'boolean',
+        description: 'Instead of the result of the job, return the path where it is persisted'
+      }
+    end
+
     required_inputs = task_info[:inputs].select do |input|
       next if names and not names.include?(input.to_sym)
       task_info[:input_options].include?(input) && task_info[:input_options][input][:required]
@@ -89,20 +104,21 @@ module LLM
 
   def self.call_workflow(workflow, task_name, parameters={})
     parameters = {} if parameters.nil?
-    jobname = parameters.delete :jobname
+    jobname, return_path, exec_type, allow_recursive = IndiferentHash.process_options parameters, :jobname, :return_path, :exec_type, :allow_recursive
     begin
-      exec_type = parameters[:exec_type]
       job = workflow.job(task_name.to_sym, jobname, parameters)
-      if workflow.exec_exports.include?(task_name.to_sym) || parameters[:exec_type].to_s == 'exec'
+      if workflow.exec_exports.include?(task_name.to_sym) || exec_type.to_s == 'exec'
         job.exec
       else
-        raise ScoutException, 'Potential recursive call' if parameters[:allow_recursive] != 'true' &&
-          (job.running? and job.info[:pid] == Process.pid)
-
-        #Workflow.produce(job)
-        #job.join
-        #job.load
-        job
+        if return_path
+          job.run(true)
+          Chat.allow_read_job job
+          job.path
+        else
+          raise ScoutException, 'Potential recursive call' if allow_recursive != 'true' &&
+            (job.running? and job.info[:pid] == Process.pid)
+          job
+        end
       end
     rescue ScoutException
       return $!

data/lib/scout/model/python/huggingface/causal.rb

@@ -7,11 +7,12 @@ class CausalModel < HuggingfaceModel
     self.eval do |messages,list|
       model, tokenizer = @state
       ScoutPython.call_method(
-        "scout_ai.huggingface.eval", :eval_causal_lm_chat, 
-        model, tokenizer, messages, 
+        "scout_ai.huggingface.eval", :eval_causal_lm_chat,
+        model, tokenizer, messages,
         options[:chat_template],
-        options[:chat_template_kwargs], 
-        options[:generation_kwargs]
+        options[:chat_template_kwargs],
+        options[:generation_kwargs],
+        options[:tool_argument]
       )
     end
 
@@ -20,10 +21,27 @@ class CausalModel < HuggingfaceModel
       model, tokenizer = @state
 
       ScoutPython.call_method(
-        "scout_ai.huggingface.rlhf", :train_rlhf, 
+        "scout_ai.huggingface.rlhf", :train_rlhf,
         self.state_file, tokenizer, pairs, labels, options[:rlhf_config]
       )
       load_state
     end
   end
+
+  def chat(messages, tools = nil, runtime_options = {})
+    init unless @state
+    model, tokenizer = @state
+
+    runtime_options = IndiferentHash.setup(runtime_options)
+
+    ScoutPython.call_method(
+      "scout_ai.huggingface.eval", :eval_causal_lm_response,
+      model, tokenizer, messages, tools,
+      runtime_options[:chat_template] || options[:chat_template],
+      runtime_options[:chat_template_kwargs] || options[:chat_template_kwargs],
+      runtime_options[:generation_kwargs] || options[:generation_kwargs],
+      runtime_options[:tool_argument] || options[:tool_argument],
+      runtime_options[:response_parser] || options[:response_parser]
+    )
+  end
 end

data/lib/scout/model/python/huggingface.rb

@@ -34,7 +34,8 @@ class HuggingfaceModel < TorchModel
                                        self.options.except(
                                          :training_args, :tokenizer_args, 
                                          :task, :checkpoint, :class_labels, 
-                                         :model_options, :return_logits
+                                         :model_options, :return_logits, :chat_template,
+                                         :chat_template_kwargs, :generation_kwargs
                                        ))))
 
       tokenizer_checkpoint = self.options[:tokenizer_args][:checkpoint] || checkpoint