scout-ai 0.2.0 → 1.0.1

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

@@ -0,0 +1,74 @@
+module LLM
+  class Agent
+    def start_chat
+      @start_chat ||= Chat.setup([])
+    end
+
+    def start(chat=nil)
+      if chat
+        (@current_chat || start_chat).annotate chat unless Chat === chat
+        @current_chat = chat
+      else
+        @current_chat = start_chat.branch
+      end
+    end
+
+    def current_chat
+      @current_chat ||= start
+    end
+
+    def method_missing(name,...)
+      current_chat.send(name, ...)
+    end
+
+    def respond(...)
+      self.ask(current_chat, ...)
+    end
+
+    def chat(model = nil, options = {})
+      new = self.ask(current_chat, model, options.merge(return_messages: true))
+      current_chat.concat(new)
+      new.last['content']
+    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,39 @@
+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]
+        agent.user message
+        agent.chat
+      end
+
+      properties = {
+        message: {
+          "type": :string,
+          "description": "Message to pass to the agent"
+        }
+      }
+
+      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,14 +1,18 @@
 require_relative 'ask'
 
 module LLM
+  def self.agent(...)
+    LLM::Agent.new(...)
+  end
+
   class Agent
-    attr_accessor :system, :workflow, :knowledge_base
-    def initialize(system = nil, workflow: nil, knowledge_base: nil, model: nil, **kwargs)
-      @system = system
+    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
-      @model = model
-      @other_options = kwargs
+      @other_options = IndiferentHash.setup(kwargs.dup)
+      @start_chat = start_chat
     end
 
     def format_message(message, prefix = "user")
@@ -19,17 +23,17 @@ module LLM
 
     def system_prompt
       system = @system
+      system = [] if system.nil?
       system = [system] unless system.nil? || system.is_a?(Array)
+      system = [] if system.nil?
 
-      if @knowledge_base
+      if @knowledge_base and @knowledge_base.all_databases.any?
         system << <<-EOF
 You have access to the following databases associating entities:
         EOF
 
         knowledge_base.all_databases.each do |database|
-          system << <<-EOF.strip + (knowledge_base.undirected(database) ? ". Undirected" : "")
-* #{database}: #{knowledge_base.source(database)} => #{knowledge_base.target(database)}
-          EOF
+          system << knowledge_base.markdown(database)
         end
       end
 
@@ -45,34 +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)
+    def ask(messages, model = nil, options = {})
       messages = [messages] unless messages.is_a? Array
-      model ||= @model
-
-      tools = []
-      tools += LLM.workflow_tools(workflow) if workflow
-      tools += LLM.knowledge_base_tool_definition(knowledge_base) if knowledge_base
+      model ||= @model if model
 
-      LLM.ask prompt(messages), @other_options.merge(model: model, 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).target
+      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 = LLM.chat chat_path 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,33 +1,75 @@
 require 'scout'
-require_relative 'backends/openai'
-require_relative 'backends/ollama'
-require_relative 'backends/openwebui'
-require_relative 'backends/relay'
+require_relative 'chat'
 
 module LLM
   def self.ask(question, options = {}, &block)
-    endpoint = IndiferentHash.process_options options, :endpoint
+    messages = LLM.chat(question)
+    options = IndiferentHash.add_defaults LLM.options(messages), options
 
-    endpoint ||= Scout::Config.get :endpoint, :ask, :llm, env: 'ASK_ENDPOINT,LLM_ENDPOINT', default: :openai
+    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
 
-    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"
-      LLM::OpenAI.ask(question, options, &block)
-    when :ollama, "ollama"
-      LLM::OLlama.ask(question, options, &block)
-    when :openwebui, "openwebui"
-      LLM::OpenWebUI.ask(question, options, &block)
-    when :relay, "relay"
-      LLM::Relay.ask(question, options, &block)
-    else
-      raise "Unknown backend: #{backend}"
+    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
   end
 

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

@@ -0,0 +1,129 @@
+require 'scout'
+require 'aws-sdk-bedrockruntime'
+require_relative '../parse'
+require_relative '../tools'
+require_relative '../utils'
+
+module LLM
+  module Bedrock
+    def self.client(region, access_key, secret_key)
+
+      credentials = Aws::Credentials.new(access_key, secret_key) if access_key and secret_key
+      options = {}
+      options[:region] = region if region
+      options[:credentials] = credentials if credentials
+      Aws::BedrockRuntime::Client.new(options)
+    end
+
+    def self.messages_to_prompt(messages)
+      system = []
+      user = []
+      messages.each do |info|
+        role, content = info.values_at :role, :content
+        if role.to_s == 'system'
+          system << content
+        else
+          user << content
+        end
+      end
+      [system*"\n", user*"\n"]
+    end
+
+    def self.ask(question, options = {}, &block)
+      client, region, access_key, secret_key, type = IndiferentHash.process_options options, :client, :region, :access_key, :secret_key, :type
+
+      model_options = IndiferentHash.pull_keys options, :model
+      model = IndiferentHash.process_options model_options, :model
+
+      if client.nil?
+        region ||= Scout::Config.get(:region, :bedrock_ask, :ask, :bedrock, env: 'AWS_REGION')
+        access_key ||= LLM.get_url_config(:access_key, nil, :bedrock_ask, :ask, :bedrock, env: 'AWS_ACCESS_KEY_ID')
+        secret_key ||= LLM.get_url_config(:secret_key, nil, :bedrock_ask, :ask, :bedrock, env: 'AWS_SECRET_ACCESS_KEY')
+        client = self.client(region, access_key, secret_key)
+      end
+
+      model ||= Scout::Config.get(:model, :bedrock_ask, :ask, :bedrock, env: 'BEDROCK_MODEL_ID')
+      type ||= Scout::Config.get(:type, model, default: :messages)
+
+      role, previous_response_id, tools = IndiferentHash.process_options options, :role, :previous_response_id, :tools
+      messages = LLM.parse(question, role)
+
+      case type.to_sym 
+      when :messages
+        body = model_options.merge({
+          system: messages.select{|m| m[:role] == 'system'}.collect{|m| m[:content]}*"\n",
+          messages: messages.select{|m| m[:role] == 'user'}
+        })
+      when :prompt
+        system, user = messages_to_prompt messages
+        body = model_options.merge({
+          prompt: user
+        })
+      else
+        raise "Unkown type #{type}"
+      end
+
+      Log.debug "Calling bedrock with model: #{model} parameters: #{Log.fingerprint body}"
+
+      response = client.invoke_model(
+        model_id: model,
+        content_type: 'application/json',
+        body: body.to_json
+      )
+
+      result = JSON.parse(response.body.string)
+      Log.debug "Response: #{Log.fingerprint result}"
+      message = result
+      tool_calls = message.dig('content').select{|m| m['tool_calls']}
+
+      while tool_calls && tool_calls.any?
+        messages << message
+
+        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
+
+        body[:messages] = messages.compact
+        Log.debug "Calling bedrock with parameters: #{Log.fingerprint body}"
+        response = client.invoke_model(
+          model_id: model,
+          content_type: 'application/json',
+          body: body.to_json
+        )
+        result = JSON.parse(response.body.string)
+        Log.debug "Response: #{Log.fingerprint result}"
+
+        message = result
+        tool_calls = message.dig('content').select{|m| m['tool_calls']}
+      end
+
+      message.dig('content').collect{|m|
+        m['text']
+      } * "\n"
+    end
+
+    def self.embed(text, options = {})
+      client, region, access_key, secret_key, model = IndiferentHash.process_options options, :client, :region, :access_key, :secret_key, :model
+
+      if client.nil?
+        region ||= Scout::Config.get(:region, :bedrock_embed, :embed, :bedrock, env: 'AWS_REGION')
+        access_key ||= LLM.get_url_config(:access_key, nil, :bedrock_embed, :embed, :bedrock, env: 'AWS_ACCESS_KEY_ID')
+        secret_key ||= LLM.get_url_config(:secret_key, nil, :bedrock_embed, :embed, :bedrock, env: 'AWS_SECRET_ACCESS_KEY')
+        client = self.client(region, access_key, secret_key)
+      end
+
+      model ||= Scout::Config.get(:model, :bedrock_embed, :embed, :bedrock, env: 'BEDROCK_EMBED_MODEL_ID', default: 'amazon.titan-embed-text-v1')
+
+      response = client.invoke_model(
+        model_id: model,
+        content_type: 'application/json',
+        body: { inputText: text }.to_json
+      )
+
+      result = JSON.parse(response.body.string)
+      result['embedding']
+    end
+  end
+end