scout-ai 1.0.0 → 1.1.0

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

@@ -1,7 +1,7 @@
 module LLM
   class Agent
     def start_chat
-      @start_chat ||= Chat.setup []
+      @start_chat ||= Chat.setup([])
     end
 
     def start(chat=nil)
@@ -9,6 +9,8 @@ module LLM
         (@current_chat || start_chat).annotate chat unless Chat === chat
         @current_chat = chat
       else
+        start_chat = self.start_chat
+        Chat.setup(start_chat) unless Chat === start_chat
         @current_chat = start_chat.branch
       end
     end
@@ -20,5 +22,50 @@ module LLM
     def method_missing(name,...)
       current_chat.send(name, ...)
     end
+
+    def respond(...)
+      self.ask(current_chat, ...)
+    end
+
+
+    def chat(model = nil, options = {})
+      response = ask(current_chat, model, options.merge(return_messages: true))
+      if Array === response
+        current_chat.concat(response)
+        current_chat.answer
+      else
+        current_chat.push({role: :assistant, content: response})
+        response
+      end
+    end
+
+
+    def json(...)
+      current_chat.format :json
+      output = ask(current_chat, ...)
+      obj = JSON.parse output
+      if (Hash === obj) and obj.keys == ['content']
+        obj['content']
+      else
+        obj
+      end
+    end
+
+    def json_format(format, ...)
+      current_chat.format format
+      output = ask(current_chat, ...)
+      obj = JSON.parse output
+      if (Hash === obj) and obj.keys == ['content']
+        obj['content']
+      else
+        obj
+      end
+    end
+
+    def get_previous_response_id
+      msg = current_chat.reverse.find{|msg| msg[:role].to_sym == :previous_response_id }
+      msg.nil? ? nil : msg['content']
+    end
+
   end
 end

data/lib/scout/llm/agent/delegate.rb

@@ -0,0 +1,51 @@
+module LLM
+  class Agent
+
+    def delegate(agent, name, description, &block)
+      @other_options[:tools] ||= {}
+      task_name = "hand_off_to_#{name}"
+
+      block ||= Proc.new do |name, parameters|
+        message = parameters[:message]
+        new_conversation = parameters[:new_conversation]
+        Log.medium "Delegated to #{agent}: " + Log.fingerprint(message)
+        if new_conversation
+          agent.start
+        else
+          agent.purge
+        end
+        agent.user message
+        agent.chat
+      end
+
+      properties = {
+        message: {
+          "type": :string,
+          "description": "Message to pass to the agent"
+        },
+        new_conversation: {
+          "type": :boolean,
+          "description": "Erase conversation history and start a new conversation with this message",
+          "default": false
+        }
+      }
+
+      required_inputs = [:message]
+
+      function = {
+        name: task_name,
+        description: description,
+        parameters: {
+          type: "object",
+          properties: properties,
+          required: required_inputs
+        }
+      }
+
+      definition = IndiferentHash.setup function.merge(type: 'function', function: function)
+
+
+      @other_options[:tools][task_name] = [block, definition]
+    end
+  end
+end

data/lib/scout/llm/agent/iterate.rb

@@ -0,0 +1,44 @@
+module LLM
+  class Agent
+
+    def iterate(prompt = nil, &block)
+      self.endpoint :responses
+      self.user prompt if prompt
+
+      obj = self.json_format({
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "type": "object",
+        "properties": {
+          "content": {
+            "type": "array",
+            "items": { "type": "string" }
+          }
+        },
+        "required": ["content"],
+        "additionalProperties": false
+      })
+
+      self.option :format, :text
+
+      list = Hash === obj ? obj['content'] : obj
+
+      list.each &block
+    end
+
+    def iterate_dictionary(prompt = nil, &block)
+      self.endpoint :responses
+      self.user prompt if prompt
+
+      dict = self.json_format({
+        name: 'dictionary',
+        type: 'object',
+        properties: {},
+        additionalProperties: {type: :string}
+      })
+
+      self.option :format, :text
+
+      dict.each &block
+    end
+  end
+end

data/lib/scout/llm/agent.rb

@@ -1,12 +1,17 @@
 require_relative 'ask'
 
 module LLM
+  def self.agent(...)
+    LLM::Agent.new(...)
+  end
+
   class Agent
-    attr_accessor :workflow, :knowledge_base, :start_chat
+    attr_accessor :workflow, :knowledge_base, :start_chat, :process_exception, :other_options
     def initialize(workflow: nil, knowledge_base: nil, start_chat: nil, **kwargs)
       @workflow = workflow
+      @workflow = Workflow.require_workflow @workflow if String === @workflow
       @knowledge_base = knowledge_base
-      @other_options = kwargs
+      @other_options = IndiferentHash.setup(kwargs.dup)
       @start_chat = start_chat
     end
 
@@ -44,35 +49,51 @@ You have access to the following databases associating entities:
     end
 
     # function: takes an array of messages and calls LLM.ask with them
-    def ask(messages, model = nil, options = {})
+    def ask(messages, options = {})
       messages = [messages] unless messages.is_a? Array
       model ||= @model if model
 
-      tools = []
-      tools += LLM.workflow_tools(workflow) if workflow
-      tools += LLM.knowledge_base_tool_definition(knowledge_base) if knowledge_base and knowledge_base.all_databases.any?
-
-      LLM.ask prompt(messages), @other_options.merge(log_errors: true, tools: tools) do |name,parameters|
-        case name
-        when 'children'
-          parameters = IndiferentHash.setup(parameters)
-          database, entities = parameters.values_at "database", "entities"
-          Log.high "Finding #{entities} children in #{database}"
-          knowledge_base.children(database, entities)
+      tools = options[:tools] || {}
+      tools = tools.merge @other_options[:tools] if @other_options[:tools]
+      options[:tools] = tools
+      begin
+        if workflow || knowledge_base
+          tools.merge!(LLM.workflow_tools(workflow)) if workflow
+          tools.merge!(LLM.knowledge_base_tool_definition(knowledge_base)) if knowledge_base and knowledge_base.all_databases.any?
+          options[:tools] = tools
+          LLM.ask messages, @other_options.merge(log_errors: true).merge(options)
         else
-          if workflow
-            begin
-              Log.high "Calling #{workflow}##{name} with #{Log.fingerprint parameters}"
-              workflow.job(name, parameters).run
-            rescue
-              $!.message
-            end
+          LLM.ask messages, @other_options.merge(log_errors: true).merge(options)
+        end
+      rescue
+        exception = $!
+        if Proc === self.process_exception
+          try_again = self.process_exception.call exception
+          if try_again
+            retry
           else
-            raise "What?"
+            raise exception
           end
+        else
+          raise exception
         end
       end
     end
+
+    def self.load_from_path(path, workflow: nil, knowledge_base: nil, chat: nil)
+      workflow_path = path['workflow.rb'].find
+      knowledge_base_path = path['knowledge_base']
+      chat_path = path['start_chat']
+
+      workflow = Workflow.require_workflow workflow_path if workflow_path.exists?
+      knowledge_base = KnowledgeBase.new knowledge_base_path if knowledge_base_path.exists?
+      chat = Chat.setup LLM.chat(chat_path.find) if chat_path.exists?
+
+      LLM::Agent.new workflow: workflow, knowledge_base: knowledge_base, start_chat: chat
+    end
   end
 end
+
 require_relative 'agent/chat'
+require_relative 'agent/iterate'
+require_relative 'agent/delegate'

data/lib/scout/llm/ask.rb

@@ -1,44 +1,84 @@
 require 'scout'
-require_relative 'backends/openai'
-require_relative 'backends/ollama'
-require_relative 'backends/openwebui'
-require_relative 'backends/bedrock'
-require_relative 'backends/relay'
-require_relative 'backends/responses'
+require_relative 'chat'
 
 module LLM
   def self.ask(question, options = {}, &block)
     messages = LLM.chat(question)
     options = IndiferentHash.add_defaults LLM.options(messages), options
 
+    agent = IndiferentHash.process_options options, :agent
+
+    if agent
+      agent_file = Scout.workflows[agent]
+
+      agent_file = Scout.chats[agent] unless agent_file.exists?
+
+      agent_file = agent_file.find_with_extension('rb') unless agent_file.exists?
+
+
+      if agent_file.exists?
+        if agent_file.directory?
+          if agent_file.agent.find_with_extension('rb').exists?
+            agent = load agent_file.agent.find_with_extension('rb')
+          else
+            agent = LLM::Agent.load_from_path agent_file
+          end
+        else
+          agent = load agent_file
+        end
+      else
+        raise "Agent not found: #{agent}"
+      end
+      return agent.ask(question, options)
+    end
+
     endpoint, persist = IndiferentHash.process_options options, :endpoint, :persist, persist: true
 
     endpoint ||= Scout::Config.get :endpoint, :ask, :llm, env: 'ASK_ENDPOINT,LLM_ENDPOINT'
     if endpoint && Scout.etc.AI[endpoint].exists?
       options = IndiferentHash.add_defaults options, Scout.etc.AI[endpoint].yaml
+    elsif endpoint && endpoint != ""
+      raise "Endpoint not found #{endpoint}"
     end
 
-    Persist.persist(endpoint, :json, prefix: "LLM ask", other: options.merge(messages: messages), persist: persist) do
+    Log.high Log.color :green, "Asking #{endpoint || 'client'}:\n" + LLM.print(messages) 
+    tools = options[:tools]
+    Log.high "Tools: #{Log.fingerprint tools.keys}}" if tools
+
+    res = Persist.persist(endpoint, :json, prefix: "LLM ask", other: options.merge(messages: messages), persist: persist) do
       backend = IndiferentHash.process_options options, :backend
       backend ||= Scout::Config.get :backend, :ask, :llm, env: 'ASK_BACKEND,LLM_BACKEND', default: :openai
 
       case backend
       when :openai, "openai"
+        require_relative 'backends/openai'
         LLM::OpenAI.ask(messages, options, &block)
+      when :anthropic, "anthropic"
+        require_relative 'backends/anthropic'
+        LLM::Anthropic.ask(messages, options, &block)
       when :responses, "responses"
+        require_relative 'backends/responses'
         LLM::Responses.ask(messages, options, &block)
       when :ollama, "ollama"
+        require_relative 'backends/ollama'
         LLM::OLlama.ask(messages, options, &block)
       when :openwebui, "openwebui"
+        require_relative 'backends/openwebui'
         LLM::OpenWebUI.ask(messages, options, &block)
       when :relay, "relay"
+        require_relative 'backends/relay'
         LLM::Relay.ask(messages, options, &block)
       when :bedrock, "bedrock"
+        require_relative 'backends/bedrock'
         LLM::Bedrock.ask(messages, options, &block)
       else
         raise "Unknown backend: #{backend}"
       end
     end
+
+    Log.high Log.color :blue, "Response:\n" + LLM.print(res) 
+
+    res
   end
 
   def self.workflow_ask(workflow, question, options = {})

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

@@ -0,0 +1,147 @@
+require 'scout'
+require 'anthropic'
+require_relative '../chat'
+
+module LLM
+  module Anthropic
+
+    def self.client(url = nil, key = nil, log_errors = false, request_timeout: 1200)
+      url ||= Scout::Config.get(:url, :openai_ask, :ask, :anthropic, env: 'ANTHROPIC_URL')
+      key ||= LLM.get_url_config(:key, url, :openai_ask, :ask, :anthropic, env: 'ANTHROPIC_KEY')
+      Object::Anthropic::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 'anthropic' 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}"
+
+      response['content'].collect do |output|
+        case output['type']
+        when 'text'
+          IndiferentHash.setup({role: :assistant, content: output['text']})
+        when 'reasoning'
+          next
+        when 'tool_use'
+          LLM.process_calls(tools, [output], &block)
+        when 'web_search_call'
+          next
+        else
+          eee response
+          eee output
+          raise 
+        end
+      end.compact.flatten
+    end
+
+
+    def self.ask(question, options = {}, &block)
+      original_options = options.dup
+
+      messages = LLM.chat(question)
+      options = options.merge LLM.options messages
+
+      options = IndiferentHash.add_defaults options, max_tokens: 1000
+
+      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, :anthropic, env: 'ANTHROPIC_URL')
+        key ||= LLM.get_url_config(:key, url, :openai_ask, :ask, :anthropic, env: 'ANTHROPIC_KEY')
+        client = self.client url, key, log_errors
+      end
+
+      if model.nil?
+        url ||= Scout::Config.get(:url, :openai_ask, :ask, :anthropic, env: 'ANTHROPIC_URL')
+        model ||= LLM.get_url_config(:model, url, :openai_ask, :ask, :anthropic, env: 'ANTHROPIC_MODEL', default: "claude-sonnet-4-20250514")
+      end
+
+      case format.to_sym
+      when :json, :json_object
+        options[:response_format] = {type: 'json_object'}
+      else
+        options[:response_format] = {type: format}
+      end if format
+
+      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
+
+      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[:tools] = parameters[:tools].collect do |info|
+        IndiferentHash.setup(info)
+        info[:type] = 'custom' if info[:type] == 'function'
+        info[:input_schema] = info.delete('parameters') if info["parameters"]
+        info
+      end if parameters[:tools]
+
+      messages = self.process_input messages
+
+      Log.low "Calling anthropic #{url}: #{Log.fingerprint parameters}}"
+
+      parameters[:messages] = LLM.tools_to_anthropic messages
+
+      response = self.process_response client.messages(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)
+              response + self.ask(messages + response, original_options.merge(return_messages: true, tools: tools ), &block)
+            else
+              response
+            end
+
+      if return_messages
+        res
+      else
+        res.last['content']
+      end
+    end
+
+    def self.embed(text, options = {})
+
+      client, url, key, model, log_errors = IndiferentHash.process_options options, :client, :url, :key, :model, :log_errors
+
+      if client.nil?
+        url ||= Scout::Config.get(:url, :openai_embed, :embed, :anthropic, env: 'ANTHROPIC_URL')
+        key ||= LLM.get_url_config(:key, url, :openai_embed, :embed, :anthropic, env: 'ANTHROPIC_KEY')
+        client = self.client url, key, log_errors
+      end
+
+      if model.nil?
+        url ||= Scout::Config.get(:url, :openai_embed, :embed, :anthropic, env: 'ANTHROPIC_URL')
+        model ||= LLM.get_url_config(:model, url, :openai_embed, :embed, :anthropic, env: 'ANTHROPIC_MODEL', default: "gpt-3.5-turbo")
+      end
+
+      response = client.embeddings(parameters: {input: text, model: model})
+      response.dig('data', 0, 'embedding')
+    end
+  end
+end

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

@@ -45,7 +45,7 @@ module LLM
       model ||= Scout::Config.get(:model, :bedrock_ask, :ask, :bedrock, env: 'BEDROCK_MODEL_ID')
       type ||= Scout::Config.get(:type, model, default: :messages)
 
-      role = IndiferentHash.process_options options, :role
+      role, previous_response_id, tools = IndiferentHash.process_options options, :role, :previous_response_id, :tools
       messages = LLM.parse(question, role)
 
       case type.to_sym 

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

@@ -17,7 +17,7 @@ module LLM
     end
 
 
-    def self.process_response(responses, &block)
+    def self.process_response(responses, tools, &block)
       responses.collect do |response|
         Log.debug "Respose: #{Log.fingerprint response}"
 
@@ -26,7 +26,7 @@ module LLM
           response.dig("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
@@ -38,11 +38,9 @@ module LLM
 
       messages = LLM.chat(question)
       options = options.merge LLM.options messages
-      tools = LLM.tools messages
-      associations = LLM.associations messages
 
-      client, url, key, model, return_messages, format, stream = IndiferentHash.process_options options,
-        :client, :url, :key, :model, :return_messages, :format, :stream,
+      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?
@@ -66,40 +64,39 @@ 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
+
+      tools.merge!(LLM.tools messages)
+      tools.merge!(LLM.associations messages)
+
+      if tools.any?
+        parameters[:tools] = LLM.tool_definitions_to_ollama tools
       end
 
-      Log.low "Calling client with parameters #{Log.fingerprint parameters}\n#{LLM.print messages}"
+      Log.low "Calling ollama #{url}: #{Log.fingerprint(parameters.except(:tools))}}"
+      Log.medium "Tools: #{Log.fingerprint tools.keys}}" if tools
 
       parameters[:messages] = LLM.tools_to_ollama messages
 
       parameters[:stream] = stream
 
-      response = self.process_response client.chat(parameters), &block
+      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: parameters[:tools]), &block)
+              #response + self.ask(messages + response, original_options.except(:tool_choice).merge(return_messages: true, tools: tools), &block)
+              # This version seems to keep the original message from getting forgotten
+              response + self.ask(response + messages, original_options.except(:tool_choice).merge(return_messages: true, tools: tools), &block)
             else
               response
             end