nano-bots 0.1.1 → 1.0.1

data/components/providers/openai.rb

@@ -2,9 +2,14 @@
 
 require 'openai'
 
-require_relative './base'
+require_relative 'base'
 require_relative '../crypto'
 
+require_relative '../../logic/providers/openai/tools'
+require_relative '../../controllers/interfaces/tools'
+
+require_relative 'openai/tools'
+
 module NanoBot
   module Components
     module Providers
@@ -32,17 +37,16 @@ module NanoBot
           @client = ::OpenAI::Client.new(uri_base:, access_token: @credentials[:'access-token'])
         end
 
-        def stream(input)
-          provider = @settings.key?(:stream) ? @settings[:stream] : true
-          interface = input[:interface].key?(:stream) ? input[:interface][:stream] : true
-
-          provider && interface
-        end
-
-        def evaluate(input, &block)
+        def evaluate(input, streaming, cartridge, &feedback)
           messages = input[:history].map do |event|
-            { role: event[:who] == 'user' ? 'user' : 'assistant',
-              content: event[:message] }
+            if event[:message].nil? && event[:meta] && event[:meta][:tool_calls]
+              { role: 'assistant', content: nil, tool_calls: event[:meta][:tool_calls] }
+            elsif event[:who] == 'tool'
+              { role: event[:who], content: event[:message].to_s,
+                tool_call_id: event[:meta][:id], name: event[:meta][:name] }
+            else
+              { role: event[:who] == 'user' ? 'user' : 'assistant', content: event[:message] }
+            end
           end
 
           %i[instruction backdrop directive].each do |key|
@@ -62,26 +66,105 @@ module NanoBot
 
           payload.delete(:logit_bias) if payload.key?(:logit_bias) && payload[:logit_bias].nil?
 
-          if stream(input)
+          payload[:tools] = input[:tools].map { |raw| NanoBot::Logic::OpenAI::Tools.adapt(raw) } if input[:tools]
+
+          if streaming
             content = ''
+            tools = []
 
             payload[:stream] = proc do |chunk, _bytesize|
-              partial = chunk.dig('choices', 0, 'delta', 'content')
-              if partial
-                content += partial
-                block.call({ who: 'AI', message: partial }, false)
+              partial_content = chunk.dig('choices', 0, 'delta', 'content')
+              partial_tools = chunk.dig('choices', 0, 'delta', 'tool_calls')
+
+              if partial_tools
+                partial_tools.each do |partial_tool|
+                  tools[partial_tool['index']] = {} if tools[partial_tool['index']].nil?
+
+                  partial_tool.keys.reject { |key| ['index'].include?(key) }.each do |key|
+                    target = tools[partial_tool['index']]
+
+                    if partial_tool[key].is_a?(Hash)
+                      target[key] = {} if target[key].nil?
+                      partial_tool[key].each_key do |sub_key|
+                        target[key][sub_key] = '' if target[key][sub_key].nil?
+
+                        target[key][sub_key] += partial_tool[key][sub_key]
+                      end
+                    else
+                      target[key] = '' if target[key].nil?
+
+                      target[key] += partial_tool[key]
+                    end
+                  end
+                end
               end
 
-              block.call({ who: 'AI', message: content }, true) if chunk.dig('choices', 0, 'finish_reason')
+              if partial_content
+                content += partial_content
+                feedback.call(
+                  { should_be_stored: false,
+                    interaction: { who: 'AI', message: partial_content } }
+                )
+              end
+
+              if chunk.dig('choices', 0, 'finish_reason')
+                if tools&.size&.positive?
+                  feedback.call(
+                    { should_be_stored: true,
+                      needs_another_round: true,
+                      interaction: { who: 'AI', message: nil, meta: { tool_calls: tools } } }
+                  )
+                  Tools.apply(cartridge, input[:tools], tools, feedback).each do |interaction|
+                    feedback.call({ should_be_stored: true, needs_another_round: true, interaction: })
+                  end
+                end
+
+                feedback.call(
+                  { should_be_stored: !(content.nil? || content == ''),
+                    interaction: content.nil? || content == '' ? nil : { who: 'AI', message: content },
+                    finished: true }
+                )
+              end
             end
 
-            @client.chat(parameters: payload)
+            begin
+              @client.chat(parameters: payload)
+            rescue StandardError => e
+              raise e.class, e.response[:body] if e.response && e.response[:body]
+
+              raise e
+            end
           else
-            result = @client.chat(parameters: payload)
+            begin
+              result = @client.chat(parameters: payload)
+            rescue StandardError => e
+              raise e.class, e.response[:body] if e.response && e.response[:body]
+
+              raise e
+            end
 
             raise StandardError, result['error'] if result['error']
 
-            block.call({ who: 'AI', message: result.dig('choices', 0, 'message', 'content') }, true)
+            tools = result.dig('choices', 0, 'message', 'tool_calls')
+
+            if tools&.size&.positive?
+              feedback.call(
+                { should_be_stored: true,
+                  needs_another_round: true,
+                  interaction: { who: 'AI', message: nil, meta: { tool_calls: tools } } }
+              )
+              Tools.apply(cartridge, input[:tools], tools, feedback).each do |interaction|
+                feedback.call({ should_be_stored: true, needs_another_round: true, interaction: })
+              end
+            end
+
+            content = result.dig('choices', 0, 'message', 'content')
+
+            feedback.call(
+              { should_be_stored: !(content.nil? || content == ''),
+                interaction: content.nil? || content == '' ? nil : { who: 'AI', message: content },
+                finished: true }
+            )
           end
         end
 

data/components/storage.rb

@@ -3,7 +3,7 @@
 require 'babosa'
 
 require_relative '../logic/helpers/hash'
-require_relative './crypto'
+require_relative 'crypto'
 
 module NanoBot
   module Components

data/components/stream.rb

@@ -7,7 +7,12 @@ module NanoBot
     class Stream < StringIO
       def write(*args)
         if @callback
-          @accumulated += args.first
+          begin
+            @accumulated += args.first
+          rescue StandardError => _e
+            @accumulated = "#{@accumulated.force_encoding('UTF-8')}#{args.first.force_encoding('UTF-8')}"
+          end
+
           @callback.call(@accumulated, args.first, false)
         end
         super

data/controllers/cartridges.rb

@@ -23,7 +23,7 @@ module NanoBot
 
         files.values.uniq.map do |file|
           cartridge = Logic::Helpers::Hash.symbolize_keys(
-            YAML.safe_load(File.read(file[:path]), permitted_classes: [Symbol])
+            YAML.safe_load_file(file[:path], permitted_classes: [Symbol])
           ).merge({
                     system: {
                       id: file[:path].to_s.sub(/^#{Regexp.escape(file[:base])}/, '').sub(%r{^/}, '').sub(/\.[^.]+\z/,

data/controllers/instance.rb

@@ -6,9 +6,9 @@ require_relative '../logic/helpers/hash'
 require_relative '../components/provider'
 require_relative '../components/storage'
 require_relative '../components/stream'
-require_relative './interfaces/repl'
-require_relative './interfaces/eval'
-require_relative './session'
+require_relative 'interfaces/repl'
+require_relative 'interfaces/eval'
+require_relative 'session'
 
 module NanoBot
   module Controllers
@@ -83,7 +83,7 @@ module NanoBot
             raise StandardError, "Cartridge file not found: \"#{path}\""
           end
 
-          @cartridge = YAML.safe_load(File.read(elected_path), permitted_classes: [Symbol])
+          @cartridge = YAML.safe_load_file(elected_path, permitted_classes: [Symbol])
         end
 
         @safe_cartridge = Marshal.load(Marshal.dump(@cartridge))

data/controllers/interfaces/cli.rb

@@ -81,7 +81,7 @@ module NanoBot
           when 'cartridge'
             puts YAML.dump(bot.cartridge)
           else
-            raise "TODO: [#{params[:command]}]"
+            raise "Command not found: [#{params[:command]}]"
           end
         end
       end

data/controllers/interfaces/tools.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+
+require_relative '../../logic/cartridge/tools'
+require_relative '../../logic/cartridge/safety'
+require_relative '../../components/embedding'
+
+module NanoBot
+  module Controllers
+    module Interfaces
+      module Tool
+        def self.confirming(session, cartridge, mode, feedback)
+          yeses = Logic::Cartridge::Safety.yeses(cartridge)
+          default_answer = Logic::Cartridge::Safety.default_answer(cartridge)
+          dispatch_feedback(session, cartridge, mode, feedback)
+          session.flush
+          answer = $stdin.gets.chomp.to_s.downcase.strip
+          answer = default_answer if answer == ''
+          session.print("\n")
+          yeses.include?(answer)
+        end
+
+        def self.adapt(feedback, adapter, cartridge)
+          call = {
+            parameters: %w[id name parameters parameters-as-json output],
+            values: [
+              feedback[:id], feedback[:name], feedback[:parameters],
+              feedback[:parameters].to_json,
+              feedback[:output]
+            ],
+            safety: { sandboxed: Logic::Cartridge::Safety.sandboxed?(cartridge) }
+          }
+
+          raise StandardError, 'conflicting adapters' if %i[fennel lua clojure].count { |key| !adapter[key].nil? } > 1
+
+          if adapter[:fennel]
+            call[:source] = adapter[:fennel]
+            Components::Embedding.fennel(**call)
+          elsif adapter[:clojure]
+            call[:source] = adapter[:clojure]
+            Components::Embedding.clojure(**call)
+          elsif adapter[:lua]
+            call[:parameters] = %w[id name parameters parameters_as_json output]
+            call[:source] = adapter[:lua]
+            Components::Embedding.lua(**call)
+          else
+            raise 'missing handler for adapter'
+          end
+        end
+
+        def self.dispatch_feedback(session, cartridge, mode, feedback)
+          enabled = Logic::Cartridge::Tools.feedback?(cartridge, mode.to_sym, feedback[:action].to_sym)
+
+          enabled = true if feedback[:action].to_sym == :confirming
+
+          return unless enabled
+
+          color = Logic::Cartridge::Tools.fetch_from_interface(
+            cartridge, mode.to_sym, feedback[:action].to_sym, [:color]
+          )
+
+          adapter = Tool.adapter(cartridge, mode, feedback)
+
+          if %i[fennel lua clojure].any? { |key| !adapter[key].nil? }
+            message = adapt(feedback, adapter, cartridge)
+          else
+            message = "#{feedback[:name]} #{feedback[:parameters].to_json}"
+
+            message += "\n#{feedback[:output]}" if feedback[:action].to_sym == :responding
+          end
+
+          message = "#{adapter[:prefix]}#{message}#{adapter[:suffix]}"
+
+          session.print(color.nil? ? message : Rainbow(message).send(color))
+        end
+
+        def self.adapter(cartridge, mode, feedback)
+          prefix = Logic::Cartridge::Tools.fetch_from_interface(
+            cartridge, mode.to_sym, feedback[:action].to_sym, [:prefix]
+          )
+
+          suffix = Logic::Cartridge::Tools.fetch_from_interface(
+            cartridge, mode.to_sym, feedback[:action].to_sym, [:suffix]
+          )
+
+          fennel = Logic::Cartridge::Tools.fetch_from_interface(
+            cartridge, mode.to_sym, feedback[:action].to_sym, %i[adapter fennel]
+          )
+
+          lua = Logic::Cartridge::Tools.fetch_from_interface(
+            cartridge, mode.to_sym, feedback[:action].to_sym, %i[adapter lua]
+          )
+
+          clojure = Logic::Cartridge::Tools.fetch_from_interface(
+            cartridge, mode.to_sym, feedback[:action].to_sym, %i[adapter clojure]
+          )
+
+          { prefix:, suffix:, fennel:, lua:, clojure: }
+        end
+      end
+    end
+  end
+end

data/controllers/security.rb

@@ -18,11 +18,10 @@ module NanoBot
         password = 'UNSAFE' unless password && password != ''
 
         {
-          encryption: (
+          encryption:
             Components::Crypto.encrypt('SAFE') != 'SAFE' &&
-            Components::Crypto.encrypt('SAFE') != Components::Crypto.encrypt('SAFE') &&
-            Components::Crypto.decrypt(Components::Crypto.encrypt('SAFE')) == 'SAFE'
-          ),
+              Components::Crypto.encrypt('SAFE') != Components::Crypto.encrypt('SAFE') &&
+              Components::Crypto.decrypt(Components::Crypto.encrypt('SAFE')) == 'SAFE',
           password: password != 'UNSAFE'
         }
       end

data/controllers/session.rb

@@ -3,10 +3,14 @@
 require 'babosa'
 
 require 'fileutils'
+require 'rainbow'
 
 require_relative '../logic/helpers/hash'
+require_relative '../logic/cartridge/safety'
 require_relative '../logic/cartridge/streaming'
 require_relative '../logic/cartridge/interaction'
+require_relative '../logic/cartridge/fetch'
+require_relative 'interfaces/tools'
 require_relative '../components/storage'
 require_relative '../components/adapter'
 require_relative '../components/crypto'
@@ -14,6 +18,7 @@ require_relative '../components/crypto'
 module NanoBot
   module Controllers
     STREAM_TIMEOUT_IN_SECONDS = 5
+    INFINITE_LOOP_PREVENTION = 10
 
     class Session
       attr_accessor :stream
@@ -41,9 +46,9 @@ module NanoBot
       end
 
       def load_state
-        @state = Logic::Helpers::Hash.symbolize_keys(JSON.parse(
-                                                       Components::Crypto.decrypt(File.read(@state_path))
-                                                     ))
+        @state = Logic::Helpers::Hash.symbolize_keys(
+          JSON.parse(Components::Crypto.decrypt(File.read(@state_path)))
+        )
       end
 
       def store_state!
@@ -68,7 +73,7 @@ module NanoBot
           mode: mode.to_s,
           input: message,
           message: Components::Adapter.apply(
-            :input, Logic::Cartridge::Interaction.input(@cartridge, mode.to_sym, message)
+            Logic::Cartridge::Interaction.input(@cartridge, mode.to_sym, message), @cartridge
           )
         }
 
@@ -78,41 +83,88 @@ module NanoBot
       end
 
       def process(input, mode:)
+        interface = Logic::Helpers::Hash.fetch(@cartridge, [:interfaces, mode.to_sym]) || {}
+
+        input[:interface] = interface
+        input[:tools] = @cartridge[:tools]
+
+        needs_another_round = true
+
+        rounds = 0
+
+        while needs_another_round
+          needs_another_round = process_interaction(input, mode:)
+          rounds += 1
+          raise StandardError, 'infinite loop prevention' if rounds > INFINITE_LOOP_PREVENTION
+        end
+      end
+
+      def process_interaction(input, mode:)
         prefix = Logic::Cartridge::Affixes.get(@cartridge, mode.to_sym, :output, :prefix)
         suffix = Logic::Cartridge::Affixes.get(@cartridge, mode.to_sym, :output, :suffix)
 
-        interface = Logic::Helpers::Hash.fetch(@cartridge, [:interfaces, mode.to_sym]) || {}
+        color = Logic::Cartridge::Fetch.cascate(
+          @cartridge, [[:interfaces, mode.to_sym, :output, :color], %i[interfaces output color]]
+        )
 
-        streaming = Logic::Cartridge::Streaming.enabled?(@cartridge, mode.to_sym)
+        color = color.to_sym if color
 
-        input[:interface] = interface
+        streaming = Logic::Cartridge::Streaming.enabled?(@cartridge, mode.to_sym)
 
         updated_at = Time.now
 
         ready = false
-        @provider.evaluate(input) do |output, finished|
-          updated_at = Time.now
-
-          if finished
-            event = Marshal.load(Marshal.dump(output))
 
-            output = Logic::Cartridge::Interaction.output(
-              @cartridge, mode.to_sym, output, streaming, finished
-            )
+        needs_another_round = false
 
-            output[:message] = Components::Adapter.apply(:output, output[:message])
+        @provider.evaluate(input, streaming, @cartridge) do |feedback|
+          needs_another_round = true if feedback[:needs_another_round]
 
-            event[:mode] = mode.to_s
-            event[:output] = "#{prefix}#{output[:message]}#{suffix}"
-
-            @state[:history] << event
-
-            self.print(output[:message]) unless streaming
+          updated_at = Time.now
 
-            ready = true
-            flush
-          elsif streaming
-            self.print(output[:message])
+          if feedback[:interaction] &&
+             feedback.dig(:interaction, :meta, :tool, :action) &&
+             feedback[:interaction][:meta][:tool][:action] == 'confirming'
+            Interfaces::Tool.confirming(self, @cartridge, mode, feedback[:interaction][:meta][:tool])
+          else
+
+            if feedback[:interaction] && feedback.dig(:interaction, :meta, :tool, :action)
+              Interfaces::Tool.dispatch_feedback(
+                self, @cartridge, mode, feedback[:interaction][:meta][:tool]
+              )
+            end
+
+            if feedback[:interaction]
+              event = Marshal.load(Marshal.dump(feedback[:interaction]))
+              event[:mode] = mode.to_s
+              event[:output] = nil
+
+              if feedback[:interaction][:who] == 'AI' && feedback[:interaction][:message]
+                event[:output] = feedback[:interaction][:message]
+                unless streaming
+                  output = Logic::Cartridge::Interaction.output(
+                    @cartridge, mode.to_sym, feedback[:interaction], streaming, feedback[:finished]
+                  )
+                  output[:message] = Components::Adapter.apply(output[:message], @cartridge)
+                  event[:output] = (output[:message]).to_s
+                end
+              end
+
+              @state[:history] << event if feedback[:should_be_stored]
+
+              if event[:output] && ((!feedback[:finished] && streaming) || (!streaming && feedback[:finished]))
+                self.print(color ? Rainbow(event[:output]).send(color) : event[:output])
+              end
+
+              # The `print` function already outputs a prefix and a suffix, so
+              # we should add them afterwards to avoid printing them twice.
+              event[:output] = "#{prefix}#{event[:output]}#{suffix}"
+            end
+
+            if feedback[:finished]
+              flush
+              ready = true
+            end
           end
         end
 
@@ -122,6 +174,8 @@ module NanoBot
         end
 
         store_state! unless @stateless
+
+        needs_another_round
       end
 
       def flush

data/docker-compose.example.yml

@@ -1,9 +1,8 @@
-version: '3.7'
-
+---
 services:
   nano-bots:
-    image: ruby:3.2.2-slim-bullseye
-    command: sh -c "apt-get update && apt-get install -y --no-install-recommends build-essential libffi-dev libsodium-dev lua5.4-dev && gem install nano-bots -v 0.1.1 && bash"
+    image: ruby:3.2.2-slim-bookworm
+    command: sh -c "apt-get update && apt-get install -y --no-install-recommends build-essential libffi-dev libsodium-dev lua5.4-dev curl && curl -s https://raw.githubusercontent.com/babashka/babashka/master/install | bash && gem install nano-bots -v 1.0.1 && bash"
     environment:
       OPENAI_API_ADDRESS: https://api.openai.com
       OPENAI_API_KEY: your-access-token

data/logic/cartridge/adapters.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../helpers/hash'
-require_relative './default'
+require_relative 'default'
 
 module NanoBot
   module Logic

data/logic/cartridge/affixes.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../helpers/hash'
-require_relative './default'
+require_relative 'default'
 
 module NanoBot
   module Logic

data/logic/cartridge/default.rb

@@ -15,7 +15,7 @@ module NanoBot
           return @values if @values
 
           path = File.expand_path('../../static/cartridges/default.yml', __dir__)
-          cartridge = YAML.safe_load(File.read(path), permitted_classes: [Symbol])
+          cartridge = YAML.safe_load_file(path, permitted_classes: [Symbol])
           @values = Logic::Helpers::Hash.symbolize_keys(cartridge)
           @values
         end
@@ -24,7 +24,7 @@ module NanoBot
           return @baseline if @baseline
 
           path = File.expand_path('../../static/cartridges/baseline.yml', __dir__)
-          cartridge = YAML.safe_load(File.read(path), permitted_classes: [Symbol])
+          cartridge = YAML.safe_load_file(path, permitted_classes: [Symbol])
           @baseline = Logic::Helpers::Hash.symbolize_keys(cartridge)
           @baseline
         end

data/logic/cartridge/fetch.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'default'
+require_relative '../helpers/hash'
+
+module NanoBot
+  module Logic
+    module Cartridge
+      module Fetch
+        def self.cascate(cartridge, paths)
+          results = paths.map { |path| Helpers::Hash.fetch(cartridge, path) }
+          result = results.find { |candidate| !candidate.nil? }
+          return result unless result.nil?
+
+          results = paths.map { |path| Helpers::Hash.fetch(Default.instance.values, path) }
+          result = results.find { |candidate| !candidate.nil? }
+          return result unless result.nil?
+
+          nil
+        end
+      end
+    end
+  end
+end

data/logic/cartridge/interaction.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require 'sweet-moon'
-
-require_relative './affixes'
-require_relative './adapters'
+require_relative 'affixes'
+require_relative 'adapters'
 
 module NanoBot
   module Logic
@@ -12,23 +10,25 @@ module NanoBot
         def self.input(cartridge, interface, content)
           lua = Adapter.expression(cartridge, interface, :input, :lua)
           fennel = Adapter.expression(cartridge, interface, :input, :fennel)
+          clojure = Adapter.expression(cartridge, interface, :input, :clojure)
 
           prefix = Affixes.get(cartridge, interface, :input, :prefix)
           suffix = Affixes.get(cartridge, interface, :input, :suffix)
 
-          { content:, prefix:, suffix:, lua:, fennel: }
+          { content:, prefix:, suffix:, lua:, fennel:, clojure: }
         end
 
         def self.output(cartridge, interface, result, streaming, _finished)
           if streaming
-            result[:message] = { content: result[:message], lua: nil, fennel: nil }
+            result[:message] = { content: result[:message], lua: nil, fennel: nil, clojure: nil }
             return result
           end
 
           lua = Adapter.expression(cartridge, interface, :output, :lua)
           fennel = Adapter.expression(cartridge, interface, :output, :fennel)
+          clojure = Adapter.expression(cartridge, interface, :output, :clojure)
 
-          result[:message] = { content: result[:message], lua:, fennel: }
+          result[:message] = { content: result[:message], lua:, fennel:, clojure: }
 
           result
         end

data/logic/cartridge/safety.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'fetch'
+
+module NanoBot
+  module Logic
+    module Cartridge
+      module Safety
+        def self.default_answer(cartridge)
+          default = Fetch.cascate(cartridge, [%i[interfaces tools confirming default]])
+          return [] if default.nil?
+
+          default
+        end
+
+        def self.yeses(cartridge)
+          yeses_values = Fetch.cascate(cartridge, [%i[interfaces tools confirming yeses]])
+          return [] if yeses_values.nil?
+
+          yeses_values
+        end
+
+        def self.confirmable?(cartridge)
+          confirmable = Fetch.cascate(cartridge, [%i[safety tools confirmable]])
+          return true if confirmable.nil?
+
+          confirmable
+        end
+
+        def self.sandboxed?(cartridge)
+          sandboxed = Fetch.cascate(cartridge, [%i[safety functions sandboxed]])
+          return true if sandboxed.nil?
+
+          sandboxed
+        end
+      end
+    end
+  end
+end