scout-ai 1.0.0 → 1.1.0

data/lib/scout/llm/chat.rb

@@ -1,8 +1,13 @@
 require_relative 'utils'
 require_relative 'parse'
 require_relative 'tools'
+require 'shellwords'
 
 module LLM
+  def self.content_tokens(message)
+    Shellwords.split(message[:content].strip)
+  end
+
   def self.messages(question, role = nil)
     default_role = "user"
 
@@ -17,7 +22,7 @@ module LLM
     end
 
     messages = []
-    current_role = nil
+    current_role = default_role
     current_content = ""
     in_protected_block = false
     protected_block_type = nil
@@ -42,17 +47,6 @@ module LLM
           current_content << "\n" << line unless line.strip.empty?
         end
         next
-      elsif stripped.start_with?("---")
-        if in_protected_block
-          in_protected_block = false
-          protected_block_type = nil
-          current_content << "\n" << line unless line.strip.empty?
-        else
-          in_protected_block = true
-          protected_block_type = :square
-          current_content << "\n" << line unless line.strip.empty?
-        end
-        next
       elsif stripped.end_with?("]]") && in_protected_block && protected_block_type == :square
         in_protected_block = false
         protected_block_type = nil
@@ -114,8 +108,9 @@ module LLM
         role = $1
         inline_content = $2.strip
 
+        current_content = current_content.strip if current_content
         # Save current message if any
-        messages << { role: current_role, content: current_content.strip }
+        messages << { role: current_role, content: current_content }
 
         if inline_content.empty?
           # Block message
@@ -124,11 +119,15 @@ module LLM
         else
           # Inline message + next block is default role
           messages << { role: role, content: inline_content }
-          #current_role = default_role
+          current_role = 'user' if role == 'previous_response_id'
           current_content = ""
         end
       else
-        current_content << "\n" << line
+        if current_content.nil?
+          current_content = line
+        else
+          current_content << "\n" << line
+        end
       end
     end
 
@@ -138,34 +137,45 @@ module LLM
     messages
   end
 
+  def self.find_file(file, original = nil, caller_lib_dir = Path.caller_lib_dir(nil, 'chats'))
+    path = Scout.chats[file]
+    original = original.find if Path === original
+    if original
+      relative = File.join(File.dirname(original), file)
+      relative_lib = File.join(caller_lib_dir, file)
+    end
+
+    if Open.exist?(file)
+      file
+    elsif Open.remote?(file)
+      file
+    elsif relative && Open.exist?(relative)
+      relative
+    elsif relative_lib && Open.exist?(relative_lib)
+      relative_lib
+    elsif path.exists?
+      path
+    end
+  end
+
   def self.imports(messages, original = nil, caller_lib_dir = Path.caller_lib_dir(nil, 'chats'))
     messages.collect do |message|
-      if message[:role] == 'import' || message[:role] == 'continue'
+      if message[:role] == 'import' || message[:role] == 'continue' || message[:role] == 'last'
         file = message[:content].to_s.strip
-        path = Scout.chats[file]
-        original = original.find if Path === original
-        if original
-          relative = File.join(File.dirname(original), file)
-          relative_lib = File.join(caller_lib_dir, file)
-        end
+        found_file = find_file(file, original, caller_lib_dir)
+        raise "Import not found: #{file}" if found_file.nil?
+
+        new = LLM.messages Open.read(found_file)
 
-        new = if Open.exist?(file)
-                LLM.chat file
-              elsif relative && Open.exist?(relative)
-                LLM.chat relative
-              elsif relative_lib && Open.exist?(relative_lib)
-                LLM.chat relative_lib
-              elsif path.exists?
-                LLM.chat path
+        new = if message[:role] == 'continue'
+                [new.reject{|msg| msg[:content].nil? || msg[:content].strip.empty? }.last]
+              elsif message[:role] == 'last'
+                [LLM.purge(new).reject{|msg| msg[:content].empty?}.last]
               else
-                raise "Import not found: #{file}"
+                LLM.purge(new)
               end
 
-        if message[:role] == 'continue'
-          new.last
-        else
-          new
-        end
+        LLM.chat new, found_file
       else
         message
       end
@@ -175,25 +185,11 @@ module LLM
   def self.files(messages, original = nil, caller_lib_dir = Path.caller_lib_dir(nil, 'chats'))
     messages.collect do |message|
       if message[:role] == 'file' || message[:role] == 'directory'
-        file = message[:content].strip
-        path = Scout.chats[file]
-        original = original.find if Path === original
-        if original
-          relative = File.join(File.dirname(original), file)
-          relative_lib = File.join(caller_lib_dir, file)
-        end
+        file = message[:content].to_s.strip
+        found_file = find_file(file, original, caller_lib_dir)
+        raise "File not found: #{file}" if found_file.nil?
 
-        target = if Open.exist?(file)
-                   file
-                 elsif relative && Open.exist?(relative)
-                   relative
-                 elsif relative_lib && Open.exist?(relative_lib)
-                   relative_lib
-                 elsif path.exists?
-                   path
-                 else
-                   raise "File not found: #{file}"
-                 end
+        target = found_file
 
         if message[:role] == 'directory'
           Path.setup target
@@ -207,6 +203,13 @@ module LLM
           new = LLM.tag :file, Open.read(target), file
           {role: 'user', content: new}
         end
+      elsif message[:role] == 'pdf' || message[:role] == 'image'
+        file = message[:content].to_s.strip
+        found_file = find_file(file, original, caller_lib_dir)
+        raise "File not found: #{file}" if found_file.nil?
+
+        message[:content] = found_file
+        message
       else
         message
       end
@@ -216,7 +219,7 @@ module LLM
   def self.tasks(messages, original = nil)
     jobs =  []
     new = messages.collect do |message|
-      if message[:role] == 'task' || message[:role] == 'inline_task'
+      if message[:role] == 'task' || message[:role] == 'inline_task' || message[:role] == 'exec_task'
         info = message[:content].strip
 
         workflow, task  = info.split(" ").values_at 0, 1
@@ -224,14 +227,28 @@ module LLM
         options = IndiferentHash.parse_options info
         jobname = options.delete :jobname
 
-        job = Workflow.require_workflow(workflow).job(task, jobname, options)
+        if String === workflow
+          workflow = begin
+                       Kernel.const_get workflow
+                     rescue
+                       Workflow.require_workflow(workflow)
+                     end
+        end
+
+        job = workflow.job(task, jobname, options)
 
-        jobs << job
+        jobs << job unless message[:role] == 'exec_task'
 
-        if message[:role] == 'inline_task'
-          {role: 'inline_job', content: job.short_path}
+        if message[:role] == 'exec_task'
+          begin
+            {role: 'user', content: job.exec}
+          rescue
+            {role: 'exec_job', content: $!}
+          end
+        elsif message[:role] == 'inline_task'
+          {role: 'inline_job', content: job.path.find}
         else
-          {role: 'job', content: job.short_path}
+          {role: 'job', content: job.path.find}
         end
       else
         message
@@ -253,23 +270,31 @@ module LLM
         id = step.short_path[0..39]
         id = id.gsub('/','-')
 
-
         if message[:role] == 'inline_job'
-          {role: 'file', content: step.path.find}
+          path = step.path
+          path = path.find if Path === path
+          {role: 'file', content: step.path}
         else
+
+          function_name = step.full_task_name.sub('#', '-')
+          function_name = step.task_name
           tool_call = {
-            type: "function",
             function: {
-              name: step.full_task_name.sub('#', '-'),
-              arguments: step.provided_inputs.to_json
+              name: function_name,
+              arguments: step.provided_inputs
             },
             id: id,
           }
 
+          content = if step.done?
+                      Open.read(step.path)
+                    elsif step.error?
+                      step.exception
+                    end
+
           tool_output = {
-            tool_call_id: id,
-            role: "tool",
-            content: step.path.read
+            id: id,
+            content: content
           }
 
           [
@@ -287,7 +312,10 @@ module LLM
     new = []
 
     messages.reverse.each do |message|
-      if message[:role] == 'clear'
+      if message[:role].to_s == 'clear'
+        break
+      elsif message[:role].to_s == 'previous_response_id'
+        new << message
         break
       else
         new << message
@@ -299,7 +327,8 @@ module LLM
 
   def self.clean(messages)
     messages.reject do |message|
-      message[:content] && message[:content].empty?
+      ((String === message[:content]) && message[:content].empty?) ||
+        message[:role] == 'skip'
     end
   end
 
@@ -307,8 +336,8 @@ module LLM
     messages.collect{|msg| IndiferentHash.setup msg }
   end
 
-  def self.chat(file)
-    original = (String === file and Open.exists?(file)) ? file : Path.setup($0.dup)
+  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')
 
     if Array === file
@@ -336,13 +365,41 @@ module LLM
 
   def self.options(chat)
     options = IndiferentHash.setup({})
+    sticky_options = IndiferentHash.setup({})
     new = []
+
+    # Most options reset after an assistant reply, but not previous_response_id
     chat.each do |info|
       if Hash === info
         role = info[:role].to_s
-        if %w(endpoint format model backend persist).include? role.to_s
+        if %w(endpoint model backend persist agent).include? role.to_s
           options[role] = info[:content]
           next
+        elsif %w(previous_response_id).include? role.to_s
+          sticky_options[role] = info[:content]
+          next
+        elsif %w(format).include? role.to_s
+          format = info[:content]
+          if Path.is_filename?(format)
+            file = find_file(format)
+            if file
+              format = Open.json(file)
+            end
+          end
+          options[role] = format
+          next
+        end
+
+        if role.to_s == 'option'
+          key, _, value = info[:content].partition(" ")
+          options[key] = value
+          next
+        end
+
+        if role.to_s == 'sticky_option'
+          key, _, value = info[:content].partition(" ")
+          sticky_options[key] = value
+          next
         end
 
         if role == 'assistant'
@@ -352,14 +409,32 @@ module LLM
       new << info
     end
     chat.replace new
-    options
+    sticky_options.merge options
   end
 
   def self.tools(messages)
-    tool_definitions = {}
+    tool_definitions = IndiferentHash.setup({})
     new = messages.collect do |message|
-      if message[:role] == 'tool'
-        workflow_name, task_name, *inputs = message[:content].strip.split(/\s+/)
+      if message[:role] == 'mcp'
+        url, *tools = content_tokens(message)
+
+        if url == 'stdio'
+          command = tools.shift
+          mcp_tool_definitions = LLM.mcp_tools(url, command: command, url: nil, type: :stdio)
+        else
+          mcp_tool_definitions = LLM.mcp_tools(url)
+        end
+
+        if tools.any?
+          tools.each do |tool|
+            tool_definitions[tool] = mcp_tool_definitions[tool]
+          end
+        else
+          tool_definitions.merge!(mcp_tool_definitions)
+        end
+        next
+      elsif message[:role] == 'tool'
+        workflow_name, task_name, *inputs = content_tokens(message)
         inputs = nil if inputs.empty?
         inputs = [] if inputs == ['none'] || inputs == ['noinputs']
         if Open.remote? workflow_name
@@ -370,9 +445,24 @@ module LLM
         else
           workflow = Workflow.require_workflow workflow_name
         end
-        definition = LLM.task_tool_definition workflow, task_name, inputs
-        tool_definitions[task_name] = [workflow, definition]
+
+        if task_name
+          definition = LLM.task_tool_definition workflow, task_name, inputs
+          tool_definitions[task_name] = [workflow, definition]
+        else
+          tool_definitions.merge!(LLM.workflow_tools(workflow))
+        end
+        next
+      elsif message[:role] == 'kb'
+        knowledge_base_name, *databases = content_tokens(message)
+        databases = nil if databases.empty?
+        knowledge_base = KnowledgeBase.load knowledge_base_name
+
+        knowledge_base_definition = LLM.knowledge_base_tool_definition(knowledge_base, databases)
+        tool_definitions.merge!(knowledge_base_definition)
         next
+      elsif message[:role] == 'clear_tools'
+        tool_definitions = {}
       else
         message
       end
@@ -381,19 +471,19 @@ module LLM
     tool_definitions
   end
 
-  def self.associations(messages)
+  def self.associations(messages, kb = nil)
     tool_definitions = {}
-    kb = nil
     new = messages.collect do |message|
       if message[:role] == 'association'
-        name, path, *options = message[:content].strip.split(/\s+/)
+        name, path, *options = content_tokens(message)
 
         kb ||= KnowledgeBase.new Scout.var.Agent.Chat.knowledge_base
         kb.register name, Path.setup(path), IndiferentHash.parse_options(message[:content])
 
-        definition = LLM.association_tool_definition name
-        tool_definitions[name] = [kb, definition]
+        tool_definitions.merge!(LLM.knowledge_base_tool_definition( kb, [name]))
         next
+      elsif message[:role] == 'clear_associations'
+        tool_definitions = {}
       else
         message
       end
@@ -404,18 +494,29 @@ module LLM
 
   def self.print(chat)
     return chat if String  === chat
-    chat.collect do |message|
+    "\n" + chat.collect do |message|
       IndiferentHash.setup message
       case message[:content]
       when Hash, Array
         message[:role].to_s + ":\n\n" + message[:content].to_json
-      when nil
-        message[:role].to_s + ":\n\n" + message.to_json
+      when nil, ''
+        message[:role].to_s + ":"
       else
-        message[:role].to_s + ":\n\n" + message[:content].to_s
+        if %w(option previous_response_id function_call function_call_output).include? message[:role].to_s
+          message[:role].to_s + ": " + message[:content].to_s
+        else
+          message[:role].to_s + ":\n\n" + message[:content].to_s
+        end
       end
     end * "\n\n"
   end
+
+  def self.purge(chat)
+    chat.reject do |msg|
+      IndiferentHash.setup msg
+      msg[:role].to_s == 'previous_response_id'
+    end
+  end
 end
 
 module Chat
@@ -441,6 +542,10 @@ module Chat
     message(:import, file)
   end
 
+  def import_last(file)
+    message(:last, file)
+  end
+
   def file(file)
     message(:file, file)
   end
@@ -478,6 +583,11 @@ module Chat
     message(:job, step.path)
   end
 
+  def inline_job(step)
+    message(:inline_job, step.path)
+  end
+
+
   def association(name, path, options = {})
     options_str = IndiferentHash.print_options options
     content = [name, path, options_str]*" "
@@ -488,12 +598,20 @@ module Chat
     self.message role, LLM.tag(tag, content, name)
   end
 
+
   def ask(...)
     LLM.ask(LLM.chat(self), ...)
   end
 
   def chat(...)
-    self.push({role: :assistant, content: self.ask(...)})
+    response = ask(...)
+    if Array === response
+      current_chat.concat(response)
+      final(response)
+    else
+      current_chat.push({role: :assistant, content: response})
+      response
+    end
   end
 
   def json(...)
@@ -507,17 +625,15 @@ module Chat
     end
   end
 
-  def print
-    LLM.print LLM.chat(self)
-  end
-
-  def write(path, force = true)
-    path = path.to_s if Symbol === path
-    if not (Open.exists?(path) || Path === path || Path.located?(path))
-      path = Rbbt.chats.find[path]
+  def json_format(format, ...)
+    self.format format
+    output = ask(...)
+    obj = JSON.parse output
+    if (Hash === obj) and obj.keys == ['content']
+      obj['content']
+    else
+      obj
     end
-    return if Open.exists?(path) && ! force
-    Open.write path, self.print
   end
 
   def branch
@@ -525,7 +641,7 @@ module Chat
   end
 
   def option(name, value)
-    self.message name, value
+    self.message 'option', [name, value] * " "
   end
 
   def endpoint(value)
@@ -536,10 +652,62 @@ module Chat
     option :model, value
   end
 
+  def image(file)
+    self.message :image, file
+  end
+
+  # Reporting
+
+  def print
+    LLM.print LLM.chat(self)
+  end
+
+  def final
+    LLM.purge(self).last
+  end
+
+  def purge
+    Chat.setup(LLM.purge(self))
+  end
+
   def shed
-    self.annotate [self.last]
+    self.annotate [final]
+  end
+
+  def answer
+    final[:content]
+  end
+
+  # Write and save
+
+  def save(path, force = true)
+    path = path.to_s if Symbol === path
+    if not (Open.exists?(path) || Path === path || Path.located?(path))
+      path = Scout.chats.find[path]
+    end
+    return if Open.exists?(path) && ! force
+    Open.write path, LLM.print(self)
   end
-  
+
+  def write(path, force = true)
+    path = path.to_s if Symbol === path
+    if not (Open.exists?(path) || Path === path || Path.located?(path))
+      path = Scout.chats.find[path]
+    end
+    return if Open.exists?(path) && ! force
+    Open.write path, self.print
+  end
+
+  def write_answer(path, force = true)
+    path = path.to_s if Symbol === path
+    if not (Open.exists?(path) || Path === path || Path.located?(path))
+      path = Scout.chats.find[path]
+    end
+    return if Open.exists?(path) && ! force
+    Open.write path, self.answer
+  end
+
+  # Image
   def create_image(file, ...)
     base64_image = LLM.image(LLM.chat(self), ...)
     Open.write(file, Base64.decode(file_content), mode: 'wb')

data/lib/scout/llm/embed.rb

@@ -1,8 +1,4 @@
 require 'scout'
-require_relative 'backends/ollama'
-require_relative 'backends/openai'
-require_relative 'backends/openwebui'
-require_relative 'backends/relay'
 
 module LLM
   def self.embed(text, options = {})
@@ -17,12 +13,16 @@ module LLM
 
     case backend
     when :openai, "openai"
+      require_relative 'backends/openai'
       LLM::OpenAI.embed(text, options)
     when :ollama, "ollama"
+      require_relative 'backends/ollama'
       LLM::OLlama.embed(text, options)
     when :openwebui, "openwebui"
+      require_relative 'backends/openwebui'
       LLM::OpenWebUI.embed(text, options)
     when :relay, "relay"
+      require_relative 'backends/relay'
       LLM::Relay.embed(text, options)
     else
       raise "Unknown backend: #{backend}"

data/lib/scout/llm/mcp.rb

@@ -0,0 +1,28 @@
+require 'mcp'
+
+module Workflow
+  def mcp(*tasks)
+    tasks = tasks.flatten.compact
+    tasks = self.tasks.keys if tasks.empty?
+
+    tools = tasks.collect do |task,inputs=nil|
+      tool_definition = LLM.task_tool_definition(self, task, inputs)[:function]
+      description = tool_definition[:description]
+      input_schema = tool_definition[:parameters].slice(:properties, :required)
+      annotations = tool_definition.slice(:title)
+      annotations[:read_only_hint] = true
+      annotations[:destructive_hint] = false
+      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)
+      end
+    end
+
+    MCP::Server.new(
+      name: self.name,
+      version: "1.0.0",
+      tools: tools
+    )
+  end
+end

data/lib/scout/llm/parse.rb

@@ -1,3 +1,4 @@
+require 'scout/llm/utils'
 module LLM
   def self.process_inside(inside)
     header, content = inside.match(/([^\n]*)\n(.*)/).values_at 1, 2

data/lib/scout/llm/rag.rb

@@ -12,5 +12,14 @@ module LLM
       end
       t
     end
+
+    def self.load(path, dim)
+      require 'hnswlib'
+
+      u = Hnswlib::HierarchicalNSW.new(space: 'l2', dim: dim)
+      u.load_index(path)
+
+      u
+    end
   end
 end