scout-ai 1.0.0 → 1.1.0

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

@@ -5,23 +5,24 @@ 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] == 'function_call'
-          {role: 'assistant', tool_calls: [message[:content]]}
-        elsif message[:role] == 'function_call_output'
-          message[:content]
+        if message[:role] == 'image'
+          Log.warn "Endpoint 'openai' does not support images, try 'responses': #{message[:content]}"
+          next
         else
           message
         end
-      end.flatten
+      end.flatten.compact
     end
 
-    def self.process_response(response, &block)
+    def self.process_response(response, tools, &block)
       Log.debug "Respose: #{Log.fingerprint response}"
       raise Exception, response["error"] if response["error"]
 
@@ -30,7 +31,7 @@ module LLM
         response.dig("choices", 0, "message", "tool_calls")
 
       if tool_calls && tool_calls.any?
-        LLM.call_tools tool_calls, &block
+        LLM.process_calls(tools, tool_calls, &block)
       else
         [message]
       end
@@ -41,12 +42,10 @@ module LLM
 
       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
+      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')
@@ -59,8 +58,6 @@ module LLM
         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'}
@@ -70,39 +67,37 @@ module LLM
 
       parameters = options.merge(model: model)
 
-      if tools.any? || associations.any?
-        parameters[:tools] = []
-        parameters[:tools] += tools.values.collect{|a| a.last } if tools
-        parameters[:tools] += associations.values.collect{|a| a.last } if associations
-        if not block_given?
-          block = Proc.new do |name,parameters|
-            IndiferentHash.setup parameters
-            if tools[name]
-              workflow = tools[name].first
-              jobname = parameters.delete :jobname
-              workflow.job(name, jobname, parameters).run
-            else
-              kb = associations[name].first
-              entities, reverse = IndiferentHash.process_options parameters, :entities, :reverse
-              if reverse
-                kb.parents(name, entities)
-              else
-                kb.children(name, entities)
-              end
-            end
-          end
+      # 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
 
-      Log.low "Calling openai #{url}: #{Log.fingerprint parameters}}"
-      Log.debug LLM.print messages
+      tools.merge!(LLM.tools messages)
+      tools.merge!(LLM.associations messages)
+
+      if tools.any?
+        parameters[:tools] = LLM.tool_definitions_to_openai tools
+      end
+
+      messages = self.process_input messages
+
+      Log.debug "Calling openai #{url}: #{Log.fingerprint(parameters.except(:tools))}}"
+      Log.high "Tools: #{Log.fingerprint tools.keys}}" if tools
 
       parameters[:messages] = LLM.tools_to_openai messages
 
-      response = self.process_response client.chat(parameters: parameters), &block
+      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.except(:tool_choice).merge(return_messages: true, tools: parameters[:tools]), &block)
+              response + self.ask(messages + response, original_options.merge(tool_choice: tool_choice_next, return_messages: true, tools: tools ), &block)
             else
               response
             end

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

@@ -15,53 +15,61 @@ module LLM
         mime = "image/extension"
       end
 
-      base64_image = Base64.strict_encode64(file_content)
+      base64_string = Base64.strict_encode64(file_content)
 
-      "data:#{mime};base64,#{base64_image}"
+      "data:#{mime};base64,#{base64_string}"
     end
 
     def self.encode_pdf(path)
       file_content = File.binread(path)  # Replace with your file name
-      Base64.strict_encode64(file_content)
-    end
-    def self.tool_response(tool_call, &block)
-      tool_call_id = tool_call.dig("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
+      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)
+      last_id = nil
       messages.collect do |message|
         if message[:role] == 'function_call'
           info = JSON.parse(message[:content])
           IndiferentHash.setup info
-          id = info[:id].sub(/^fc_/, '')
+          name = info[:name] || IndiferentHash.dig(info,:function, :name)
+          IndiferentHash.setup info
+          id = last_id = info[:id] || "fc_#{rand(1000).to_s}"
+          id = id.sub(/^fc_/, '')
           IndiferentHash.setup({
             "type" => "function_call",
             "status" => "completed",
-            "name" => info[:name],
+            "name" => name,
             "arguments" => (info[:arguments] || {}).to_json,
-            "call_id"=>"call_#{id}",
+            "call_id"=>id,
           })
         elsif message[:role] == 'function_call_output'
           info = JSON.parse(message[:content])
           IndiferentHash.setup info
-          id = info[:id].sub(/^fc_/, '')
+          id = info[:id] || last_id
+          id = id.sub(/^fc_/, '')
           {                               # append result message
             "type" => "function_call_output",
             "output" => info[:content],
-            "call_id"=>"call_#{id}",
+            "call_id"=>id,
           }
         else
           message
@@ -69,7 +77,7 @@ module LLM
       end.flatten
     end
 
-    def self.process_response(response, &block)
+    def self.process_response(response, tools, &block)
       Log.debug "Respose: #{Log.fingerprint response}"
 
       response['output'].collect do |output|
@@ -81,11 +89,14 @@ module LLM
               IndiferentHash.setup({role: 'assistant', content: content['text']})
             end
           end
+        when 'reasoning'
+          next
         when 'function_call'
-          LLM.call_tools [output], &block
+          LLM.process_calls(tools, [output], &block)
         when 'web_search_call'
           next
         else
+          eee response
           eee output
           raise 
         end
@@ -99,6 +110,7 @@ module LLM
         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)
@@ -108,35 +120,91 @@ module LLM
             raise
           end
         elsif message[:role] == 'pdf'
-          path = message[:content]
+          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 }]}
+            {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"} }
+          {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
-      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,
+      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')
@@ -148,57 +216,32 @@ module LLM
         model ||= LLM.get_url_config(:model, url, :openai_ask, :ask, :openai, env: 'OPENAI_MODEL', default: "gpt-4.1")
       end
 
-      case format
-      when :json, :json_object, "json", "json_object"
-        options['text'] = {format: {type: 'json_object'}}
-      when String, Symbol
-        options['text'] = {format: {type: format}}
-      when Hash
-        if format.include?('format')
-          options['text'] = format
-        elsif format['type'] == 'json_schema'
-          options['text'] = {format: format}
-        else
-          options['text'] = {format: {name: "response_schema",
-                                      type: "json_schema",
-                                      additionalProperties: false,
-                                      required: format['properties'].keys,
-                                      schema: format,
-          }}
-        end
-      end if format
+      options['text'] = self.process_format format if format
 
       parameters = options.merge(model: model)
 
-      if tools.any? || associations.any?
-        parameters[:tools] ||= []
-        parameters[:tools] += tools.values.collect{|a| a.last } if tools
-        parameters[:tools] += associations.values.collect{|a| a.last } if associations
-        parameters[:tools] = parameters[:tools].collect{|tool|
-          function = tool.delete :function;
-          tool.merge function
-        }
-        if not block_given?
-          block = Proc.new do |name,parameters|
-            IndiferentHash.setup parameters
-            if tools[name]
-              workflow = tools[name].first
-              jobname = parameters.delete :jobname
-              workflow.job(name, jobname, parameters).run
-            else
-              kb = associations[name].first
-              entities, reverse = IndiferentHash.process_options parameters, :entities, :reverse
-              if reverse
-                kb.parents(name, entities)
-              else
-                kb.children(name, entities)
-              end
-            end
-          end
+      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
 
-      Log.low "Calling client with parameters #{Log.fingerprint parameters}\n#{LLM.print messages}"
+      tools.merge!(LLM.tools messages)
+      tools.merge!(LLM.associations messages)
+
+      if tools.any?
+        parameters[:tools] = LLM.tool_definitions_to_reponses tools
+      end
+
+      parameters['previous_response_id'] = previous_response_id if String === previous_response_id
+
+      Log.low "Calling responses #{url}: #{Log.fingerprint(parameters.except(:tools))}}"
+      Log.medium "Tools: #{Log.fingerprint tools.keys}}" if tools
 
       messages = self.process_input messages
       input = []
@@ -210,63 +253,73 @@ module LLM
           input << message
         end
       end
-      parameters[:input] = input
+
+      parameters[:input] = LLM.tools_to_openai input
 
       response = client.responses.create(parameters: parameters)
-      response = self.process_response response, &block
+
+      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'
-              response + self.ask(messages + response, original_options.except(:tool_choice).merge(return_messages: true, tools: parameters[:tools]), &block)
+              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
-        res
+        if res.last[:role] == :previous_response_id
+          res
+        else
+          res + [previous_response_message]
+        end
       else
-        res.last['content']
+        LLM.purge(res).last['content']
       end
     end
 
-  end
 
-  def self.image(question, options = {}, &block)
-    original_options = options.dup
+    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
+      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
+      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 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
+      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 = [] 
-    messages.each do |message|
-      parameters[:tools] ||= []
-      if message[:role].to_s == 'tool'
-        parameters[:tools] << message[:content]
-      else
+      messages = self.process_input messages
+      input = []
+      parameters = {}
+      messages.each do |message|
         input << message
       end
-    end
-    parameters[:prompt] = LLM.print(input) 
+      parameters[:prompt] = LLM.print(input)
 
-    response = client.images.generate(parameters: parameters)
+      response = client.images.generate(parameters: parameters)
 
-    response[0]['b64_json']
+      response
+    end
   end
 end