scout-ai 0.2.0 → 1.0.1

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

@@ -1,17 +1,18 @@
 require_relative '../parse'
 require_relative '../tools'
+require_relative '../chat'
 
 module LLM
   module Huggingface
 
     def self.model(model_options)
-      require 'rbbt-util'
-      require 'rbbt/vector/model/huggingface'
+      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')
 
-      HuggingfaceModel.new task, model, dir, model_options
+      CausalModel.new model, dir, model_options
     end
 
     def self.ask(question, options = {}, &block)
@@ -20,7 +21,7 @@ module LLM
 
       model = self.model model_options
 
-      messages = LLM.parse(question)
+      messages = LLM.messages(question)
 
       system = []
       prompt = []
@@ -36,23 +37,7 @@ module LLM
       parameters = options.merge(messages: messages)
       Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
 
-      response = model.eval(messages)
-      message = response[-1]
-      while message["role"] == "assistant" && message["tool_calls"]
-        messages << message
-
-        message["tool_calls"].each do |tool_call|
-          response_message = LLM.tool_response(tool_call, &block)
-          messages << response_message
-        end
-
-        parameters[:messages] = messages
-        Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
-        response = model.eval(parameters)
-        message = response[-1]
-      end
-
-      message["content"]
+      model.eval(messages)
     end
 
     def self.embed(text, options = {})

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

@@ -2,6 +2,7 @@ require 'ollama-ai'
 require_relative '../parse'
 require_relative '../tools'
 require_relative '../utils'
+require_relative '../chat'
 
 module LLM
   module OLlama
@@ -15,9 +16,32 @@ module LLM
       )
     end
 
+
+    def self.process_response(responses, tools, &block)
+      responses.collect do |response|
+        Log.debug "Respose: #{Log.fingerprint response}"
+
+        message = response['message']
+        tool_calls = response.dig("tool_calls") ||
+          response.dig("message", "tool_calls")
+
+        if tool_calls && tool_calls.any?
+          LLM.process_calls tools, tool_calls, &block
+        else
+          [message]
+        end
+      end.flatten
+    end
+
     def self.ask(question, options = {}, &block)
+      original_options = options.dup
 
-      client, url, key, model = IndiferentHash.process_options options, :client, :url, :key, :model
+      messages = LLM.chat(question)
+      options = options.merge LLM.options messages
+
+      client, url, key, model, return_messages, format, stream, previous_response_id, tools = IndiferentHash.process_options options,
+        :client, :url, :key, :model, :return_messages, :format, :stream, :previous_response_id, :tools,
+        stream: false
 
       if client.nil?
         url ||= Scout::Config.get(:url, :ollama_ask, :ask, :ollama, env: 'OLLAMA_URL', default: "http://localhost:11434")
@@ -30,51 +54,54 @@ module LLM
         model ||= LLM.get_url_config(:model, url, :ollama_ask, :ask, :ollama, env: 'OLLAMA_MODEL', default: "mistral")
       end
 
-      mode  = IndiferentHash.process_options options, :mode
 
-      messages = LLM.parse(question)
+      case format.to_sym
+      when :json, :json_object
+        options[:response_format] = {type: 'json_object'}
+      else
+        options[:response_format] = {type: format}
+      end if format
 
-      system = []
-      prompt = []
-      messages.each do |message|
-        role, content = message.values_at :role, :content
-        if role == 'system'
-          system << content
-        else
-          prompt << content
+      parameters = options.merge(model: model)
+
+      # Process 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
 
-      case mode
-      when :chat, 'chat'
-        parameters = options.merge(model: model, messages: messages)
-        Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
+      tools.merge!(LLM.tools messages)
+      tools.merge!(LLM.associations messages)
 
-        response = client.chat(parameters)
-        response.collect do |choice|
-          message=choice['message']
-          while message["role"] == "assistant" && message["tool_calls"]
-            messages << message
+      if tools.any?
+        parameters[:tools] = tools.values.collect{|obj,definition| Hash === obj ? obj : definition}
+      end
 
-            message["tool_calls"].each do |tool_call|
-              response_message = LLM.tool_response(tool_call, &block)
-              messages << response_message
-            end
+      Log.low "Calling client with parameters #{Log.fingerprint parameters}\n#{LLM.print messages}"
+
+      parameters[:messages] = LLM.tools_to_ollama messages
 
-            parameters[:messages] = messages
-            Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
-            response = client.chat(parameters)
+      parameters[:stream] = stream
 
-            message = response[0]['message']
-          end
+      response = self.process_response client.chat(parameters), tools, &block
+
+      res = if response.last[:role] == 'function_call_output' 
+              response + self.ask(messages + response, original_options.except(:tool_choice).merge(return_messages: true, tools: tools), &block)
+            else
+              response
+            end
 
-          message["content"]
-        end * ""
+      if return_messages
+        res
       else
-        parameters = options.merge(model: model, prompt: prompt * "\n", system: system*"\n")
-        Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
-        response = client.generate(parameters)
-        response.collect{|e| e['response']} * ""
+        res.last['content']
       end
     end
 

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

@@ -1,19 +1,51 @@
 require 'scout'
 require 'openai'
-require_relative '../parse'
-require_relative '../tools'
-require_relative '../utils'
+require_relative '../chat'
 
 module LLM
   module OpenAI
 
-    def self.client(url, key, log_errors = false)
-      Object::OpenAI::Client.new(access_token:key, log_errors: log_errors, uri_base: url)
+    def self.client(url = nil, key = nil, log_errors = false, request_timeout: 1200)
+      url ||= Scout::Config.get(:url, :openai_ask, :ask, :openai, env: 'OPENAI_URL')
+      key ||= LLM.get_url_config(:key, url, :openai_ask, :ask, :openai, env: 'OPENAI_KEY')
+      Object::OpenAI::Client.new(access_token:key, log_errors: log_errors, uri_base: url, request_timeout: request_timeout)
+    end
+
+    def self.process_input(messages)
+      messages.collect do |message|
+        if message[:role] == 'image'
+          Log.warn "Endpoint 'openai' does not support images, try 'responses': #{message[:content]}"
+          next
+        else
+          message
+        end
+      end.flatten.compact
+    end
+
+    def self.process_response(response, tools, &block)
+      Log.debug "Respose: #{Log.fingerprint response}"
+      raise Exception, response["error"] if response["error"]
+
+      message = response.dig("choices", 0, "message")
+      tool_calls = response.dig("choices", 0, "tool_calls") ||
+        response.dig("choices", 0, "message", "tool_calls")
+
+      if tool_calls && tool_calls.any?
+        LLM.process_calls(tools, tool_calls, &block)
+      else
+        [message]
+      end
     end
 
     def self.ask(question, options = {}, &block)
+      original_options = options.dup
 
-      client, url, key, model, log_errors = IndiferentHash.process_options options, :client, :url, :key, :model, :log_errors
+      messages = LLM.chat(question)
+      options = options.merge LLM.options messages
+
+      client, url, key, model, log_errors, return_messages, format, tool_choice_next, previous_response_id, tools, = IndiferentHash.process_options options,
+        :client, :url, :key, :model, :log_errors, :return_messages, :format, :tool_choice_next, :previous_response_id, :tools,
+        log_errors: true, tool_choice_next: :none
 
       if client.nil?
         url ||= Scout::Config.get(:url, :openai_ask, :ask, :openai, env: 'OPENAI_URL')
@@ -23,45 +55,57 @@ module LLM
 
       if model.nil?
         url ||= Scout::Config.get(:url, :openai_ask, :ask, :openai, env: 'OPENAI_URL')
-        model ||= LLM.get_url_config(:model, url, :openai_ask, :ask, :openai, env: 'OPENAI_MODEL', default: "gpt-3.5-turbo")
+        model ||= LLM.get_url_config(:model, url, :openai_ask, :ask, :openai, env: 'OPENAI_MODEL', default: "gpt-4.1")
       end
 
-      role = IndiferentHash.process_options options, :role
+      case format.to_sym
+      when :json, :json_object
+        options[:response_format] = {type: 'json_object'}
+      else
+        options[:response_format] = {type: format}
+      end if format
 
-      messages = LLM.parse(question, role)
+      parameters = options.merge(model: model)
 
-      parameters = options.merge(model: model, messages: messages)
+      # Process tools
 
-      Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
+      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
 
-      response = client.chat(parameters: parameters)
-      Log.debug "Respose: #{Log.fingerprint response}"
-      message = response.dig("choices", 0, "message")
-      tool_calls = response.dig("choices", 0, "tool_calls") ||
-        response.dig("choices", 0, "message", "tool_calls")
+      tools.merge!(LLM.tools messages)
+      tools.merge!(LLM.associations messages)
 
-      parameters.delete :tool_choice
+      if tools.any?
+        parameters[:tools] = tools.values.collect{|obj,definition| Hash === obj ? obj : definition}
+      end
 
-      while tool_calls && tool_calls.any?
-        messages << message
+      messages = self.process_input messages
 
-        cpus = Scout::Config.get :cpus, :tool_calling, default: 3
-        tool_calls.each do |tool_call|
-          response_message = LLM.tool_response(tool_call, &block)
-          messages << response_message
-        end
+      Log.low "Calling openai #{url}: #{Log.fingerprint parameters}}"
 
-        parameters[:messages] = messages.compact
-        Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
-        response = client.chat( parameters: parameters)
-        Log.debug "Respose: #{Log.fingerprint response}"
+      parameters[:messages] = LLM.tools_to_openai messages
 
-        message = response.dig("choices", 0, "message")
-        tool_calls = response.dig("choices", 0, "tool_calls") ||
-          response.dig("choices", 0, "message", "tool_calls")
-      end
+      response = self.process_response client.chat(parameters: parameters), tools, &block
+
+      res = if response.last[:role] == 'function_call_output' 
+              response + self.ask(messages + response, original_options.merge(tool_choice: tool_choice_next, return_messages: true, tools: tools ), &block)
+            else
+              response
+            end
 
-      message.dig("content")
+      if return_messages
+        res
+      else
+        res.last['content']
+      end
     end
 
     def self.embed(text, options = {})

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

@@ -31,7 +31,7 @@ module LLM
       model ||= LLM.get_url_config(:model, url, :openai_ask, :ask, :openai, env: 'OPENWEBUI_MODEL')
 
       role = IndiferentHash.process_options options, :role
-      messages = LLM.parse(question, role)
+      messages = LLM.messages(question, role)
 
       parameters = options.merge(model: model, messages: messages)
 

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

@@ -24,9 +24,10 @@ module LLM
     end
 
     def self.ask(question, options = {}, &block)
-      options[:question] = question
+      server = IndiferentHash.process_options options, :server
+      server ||= Scout::Config.get :server, :ask_relay, :relay, :ask, env: 'ASK_ENDPOINT,LLM_ENDPOINT', default: :openai
 
-      server = Scout::Config.get(:server, :relay, default: "localhost")
+      options[:question] = question
       TmpFile.with_file(options.to_json) do |file|
         id = upload(server, file)
         gather(server, id)

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

@@ -0,0 +1,320 @@
+require_relative 'openai'
+
+module LLM
+  module Responses
+    def self.encode_image(path)
+      path = path.find if Path === path
+      file_content = File.binread(path)  # Replace with your file name
+
+      case extension = path.split('.').last.downcase
+      when 'jpg', 'jpeg'
+        mime = "image/jpeg"
+      when 'png'
+        mime = "image/png"
+      else
+        mime = "image/extension"
+      end
+
+      base64_string = Base64.strict_encode64(file_content)
+
+      "data:#{mime};base64,#{base64_string}"
+    end
+
+    def self.encode_pdf(path)
+      file_content = File.binread(path)  # Replace with your file name
+      base64_string = Base64.strict_encode64(file_content)
+
+      "data:application/pdf;base64,#{base64_string}"
+    end
+
+    #def self.tool_response(tool_call, &block)
+    #  tool_call_id = tool_call.dig("call_id").sub(/^fc_/, '')
+    #  function_name = tool_call.dig("function", "name")
+    #  function_arguments = tool_call.dig("function", "arguments")
+    #  function_arguments = JSON.parse(function_arguments, { symbolize_names: true }) if String === function_arguments
+    #  IndiferentHash.setup function_arguments
+    #  function_response = block.call function_name, function_arguments
+
+    #  content = case function_response
+    #            when nil
+    #              "success"
+    #            else
+    #              function_response
+    #            end
+    #  content = content.to_s if Numeric === content
+    #end
+
+    def self.tools_to_responses(messages)
+      messages.collect do |message|
+        if message[:role] == 'function_call'
+          info = JSON.parse(message[:content])
+          IndiferentHash.setup info
+          name = info[:name] || IndiferentHash.dig(info,:function, :name)
+          IndiferentHash.setup info
+          id = info[:id].sub(/^fc_/, '')
+          IndiferentHash.setup({
+            "type" => "function_call",
+            "status" => "completed",
+            "name" => name,
+            "arguments" => (info[:arguments] || {}).to_json,
+            "call_id"=>id,
+          })
+        elsif message[:role] == 'function_call_output'
+          info = JSON.parse(message[:content])
+          IndiferentHash.setup info
+          id = info[:id].sub(/^fc_/, '')
+          {                               # append result message
+            "type" => "function_call_output",
+            "output" => info[:content],
+            "call_id"=>id,
+          }
+        else
+          message
+        end
+      end.flatten
+    end
+
+    def self.process_response(response, tools, &block)
+      Log.debug "Respose: #{Log.fingerprint response}"
+
+      response['output'].collect do |output|
+        case output['type']
+        when 'message'
+          output['content'].collect do |content|
+            case content['type']
+            when 'output_text'
+              IndiferentHash.setup({role: 'assistant', content: content['text']})
+            end
+          end
+        when 'reasoning'
+          next
+        when 'function_call'
+          LLM.process_calls(tools, [output], &block)
+        when 'web_search_call'
+          next
+        else
+          eee response
+          eee output
+          raise 
+        end
+      end.compact.flatten
+    end
+
+    def self.process_input(messages)
+      messages = self.tools_to_responses messages
+
+      messages.collect do |message|
+        IndiferentHash.setup(message)
+        if message[:role] == 'image'
+          path = message[:content]
+          path = LLM.find_file path
+          if Open.remote?(path) 
+            {role: :user, content: {type: :input_image, image_url: path }}
+          elsif Open.exists?(path)
+            path = self.encode_image(path)
+            {role: :user, content: [{type: :input_image, image_url: path }]}
+          else
+            raise
+          end
+        elsif message[:role] == 'pdf'
+          path = original_path = message[:content]
+          if Open.remote?(path) 
+            {role: :user, content: {type: :input_file, file_url: path }}
+          elsif Open.exists?(path)
+            data = self.encode_pdf(path)
+            {role: :user, content: [{type: :input_file, file_data: data, filename: File.basename(path) }]}
+          else
+            raise
+          end
+        elsif message[:role] == 'websearch'
+          {role: :tool, content: {type: "web_search_preview"} }
+        else
+          message
+        end
+      end.flatten
+    end
+
+    def self.process_format(format)
+      case format
+      when :json, :json_object, "json", "json_object"
+        {format: {type: 'json_object'}}
+      when String, Symbol
+        {format: {type: format}}
+      when Hash
+        IndiferentHash.setup format
+
+        if format.include?('format')
+          format
+        elsif format['type'] == 'json_schema'
+          {format: format}
+        else
+
+          if ! format.include?('properties')
+            format = IndiferentHash.setup({properties: format})
+          end
+
+          properties = format['properties']
+          new_properties = {}
+          properties.each do |name,info|
+            case info
+            when Symbol, String
+              new_properties[name] = {type: info}
+            when Array
+              new_properties[name] = {type: info[0], description: info[1], default: info[2]}
+            else
+              new_properties[name] = info
+            end
+          end
+          format['properties'] = new_properties
+
+          required = format['properties'].reject{|p,i| i[:default] }.collect{|p,i| p }
+
+          name = format.include?('name') ? format.delete('name') : 'response'
+
+          format['type'] ||= 'object'
+          format[:additionalProperties] = required.empty? ? {type: :string} : false
+          format[:required] = required
+          {format: {name: name,
+                    type: "json_schema",
+                    schema: format,
+          }}
+        end
+      end
+    end
+
+    def self.ask(question, options = {}, &block)
+      original_options = options.dup
+
+      messages = LLM.chat(question)
+      options = options.merge LLM.options messages
+
+      client, url, key, model, log_errors, return_messages, format, websearch, previous_response_id, tools, = IndiferentHash.process_options options,
+        :client, :url, :key, :model, :log_errors, :return_messages, :format, :websearch, :previous_response_id, :tools,
+        log_errors: true
+
+      reasoning_options = IndiferentHash.pull_keys options, :reasoning
+      options[:reasoning] = reasoning_options if reasoning_options.any?
+
+      text_options = IndiferentHash.pull_keys options, :text
+      options[:text] = text_options if text_options.any?
+
+      if websearch
+        messages << {role: 'websearch', content: true}
+      end
+
+      if client.nil?
+        url ||= Scout::Config.get(:url, :openai_ask, :ask, :openai, env: 'OPENAI_URL')
+        key ||= LLM.get_url_config(:key, url, :openai_ask, :ask, :openai, env: 'OPENAI_KEY')
+        client = LLM::OpenAI.client url, key, log_errors
+      end
+
+      if model.nil?
+        url ||= Scout::Config.get(:url, :openai_ask, :ask, :openai, env: 'OPENAI_URL')
+        model ||= LLM.get_url_config(:model, url, :openai_ask, :ask, :openai, env: 'OPENAI_MODEL', default: "gpt-4.1")
+      end
+
+      options['text'] = self.process_format format if format
+
+      parameters = options.merge(model: model)
+
+      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
+
+      tools.merge!(LLM.tools messages)
+      tools.merge!(LLM.associations messages)
+
+      if tools.any?
+        parameters[:tools] = tools.values.collect{|obj,definition| Hash === obj ? obj : definition}
+      end
+
+      parameters['previous_response_id'] = previous_response_id if String === previous_response_id
+      Log.low "Calling client with parameters #{Log.fingerprint parameters}\n#{LLM.print messages}"
+
+      messages = self.process_input messages
+      input = []
+      messages.each do |message|
+        parameters[:tools] ||= []
+        if message[:role].to_s == 'tool'
+          parameters[:tools] << message[:content]
+        else
+          input << message
+        end
+      end
+
+      parameters[:input] = LLM.tools_to_openai input
+
+      response = client.responses.create(parameters: parameters)
+
+      Thread.current["previous_response_id"] = previous_response_id = response['id']
+      previous_response_message = {role: :previous_response_id, content: previous_response_id}
+
+      response = self.process_response response, tools, &block
+
+      res = if response.last[:role] == 'function_call_output'
+              case previous_response_id
+              when String
+                response + self.ask(response, original_options.except(:tool_choice).merge(return_messages: true, tools: tools, previous_response_id: previous_response_id), &block)
+              else
+                response + self.ask(messages + response, original_options.except(:tool_choice).merge(return_messages: true, tools: tools), &block)
+              end
+            else
+              response
+            end
+
+      if return_messages
+        if res.last[:role] == :previous_response_id
+          res
+        else
+          res + [previous_response_message]
+        end
+      else
+        LLM.purge(res).last['content']
+      end
+    end
+
+
+    def self.image(question, options = {}, &block)
+      original_options = options.dup
+
+      messages = LLM.chat(question)
+      options = options.merge LLM.options messages
+      tools = LLM.tools messages
+      associations = LLM.associations messages
+
+      client, url, key, model, log_errors, return_messages, format = IndiferentHash.process_options options,
+        :client, :url, :key, :model, :log_errors, :return_messages, :format,
+        log_errors: true
+
+      if client.nil?
+        url ||= Scout::Config.get(:url, :openai_ask, :ask, :openai, env: 'OPENAI_URL')
+        key ||= LLM.get_url_config(:key, url, :openai_ask, :ask, :openai, env: 'OPENAI_KEY')
+        client = LLM::OpenAI.client url, key, log_errors
+      end
+
+      if model.nil?
+        url ||= Scout::Config.get(:url, :openai_ask, :ask, :openai, env: 'OPENAI_URL')
+        model ||= LLM.get_url_config(:model, url, :openai_ask, :ask, :openai, env: 'OPENAI_MODEL', default: "gpt-image-1")
+      end
+
+      messages = self.process_input messages
+      input = []
+      parameters = {}
+      messages.each do |message|
+        input << message
+      end
+      parameters[:prompt] = LLM.print(input)
+
+      response = client.images.generate(parameters: parameters)
+
+      response
+    end
+  end
+end