nano-bots 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acc012feeff1090abe2df65283bdd02c8eb1c44bdb5cad13a91ce5dc481727a8
-  data.tar.gz: b34a3d078c723494e12bfcdf6793294d400adbe5150302d675eef569d471ff37
+  metadata.gz: 0fc904784fe79cd5bd873dc3861dd82412f037012ca125011ab795e5cb01e2b1
+  data.tar.gz: 76f64af2d36b5b2765d98f90281577a88e0fcb166143d859829e1b8607fe9e57
 SHA512:
-  metadata.gz: 617b3fda80392476c1943f3df9e5201d1cd5f377ede9b76b413748ca4197834b7058f4b48abc599af4eddff0879e111f7860a403759eda34cdcc3894f8d865e8
-  data.tar.gz: 7907c44f88d19ea62e57b1288410f80045438c4ba7a9bc962fe07cb4535467b88aea43e618e5165971403e2ac30d16c52a0cf56077916bbb5082d0cee4945892
+  metadata.gz: 3889cdb807954fb4b09add6e53d9ed314457b1d4c0f7e6b1969a0d421f10062b69d76505aa67eba0ee0f5de91e3fd44c7e4934606537ff688897ca0d13007156
+  data.tar.gz: f280c854038822d48ede7bdd1076256d1f8d535c5cc336948921cd1843e34f9a5fb4d207035ac1196efb7e72bc8fecd3d7be57b66b98fc7da94f5b3f7536430e

data/.ruby-version

@@ -0,0 +1 @@
+3.1.4

data/Gemfile

@@ -5,7 +5,8 @@ source 'https://rubygems.org'
 gemspec
 
 group :test, :development do
+  gem 'pry-byebug', '~> 3.10', '>= 3.10.1'
   gem 'rspec', '~> 3.12'
-  gem 'rubocop', '~> 1.47'
-  gem 'rubocop-rspec', '~> 2.22'
+  gem 'rubocop', '~> 1.57', '>= 1.57.2'
+  gem 'rubocop-rspec', '~> 2.25'
 end

data/Gemfile.lock

@@ -1,14 +1,15 @@
 PATH
   remote: .
   specs:
-    nano-bots (0.1.1)
+    nano-bots (1.0.0)
       babosa (~> 2.0)
+      concurrent-ruby (~> 1.2, >= 1.2.2)
       dotenv (~> 2.8, >= 2.8.1)
-      faraday (~> 2.7, >= 2.7.5)
+      faraday (~> 2.7, >= 2.7.12)
       pry (~> 0.14.2)
       rainbow (~> 3.1, >= 3.1.1)
       rbnacl (~> 7.1, >= 7.1.1)
-      ruby-openai (~> 4.0)
+      ruby-openai (~> 6.3)
       sweet-moon (~> 0.0.7)
 
 GEM
@@ -16,30 +17,41 @@ GEM
   specs:
     ast (2.4.2)
     babosa (2.0.0)
+    base64 (0.2.0)
+    byebug (11.1.3)
     coderay (1.1.3)
+    concurrent-ruby (1.2.2)
     diff-lcs (1.5.0)
     dotenv (2.8.1)
-    faraday (2.7.5)
+    event_stream_parser (1.0.0)
+    faraday (2.7.12)
+      base64
       faraday-net_http (>= 2.0, < 3.1)
       ruby2_keywords (>= 0.0.4)
     faraday-multipart (1.0.4)
       multipart-post (~> 2)
     faraday-net_http (3.0.2)
-    ffi (1.15.5)
+    ffi (1.16.3)
     json (2.6.3)
+    language_server-protocol (3.17.0.3)
     method_source (1.0.0)
     multipart-post (2.3.0)
     parallel (1.23.0)
-    parser (3.2.2.1)
+    parser (3.2.2.4)
       ast (~> 2.4.1)
+      racc
     pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
+    pry-byebug (3.10.1)
+      byebug (~> 11.0)
+      pry (>= 0.13, < 0.15)
+    racc (1.7.3)
     rainbow (3.1.1)
     rbnacl (7.1.1)
       ffi
-    regexp_parser (2.8.0)
-    rexml (3.2.5)
+    regexp_parser (2.8.2)
+    rexml (3.2.6)
     rspec (3.12.0)
       rspec-core (~> 3.12.0)
       rspec-expectations (~> 3.12.0)
@@ -49,47 +61,50 @@ GEM
     rspec-expectations (3.12.3)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
-    rspec-mocks (3.12.5)
+    rspec-mocks (3.12.6)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
-    rspec-support (3.12.0)
-    rubocop (1.52.0)
+    rspec-support (3.12.1)
+    rubocop (1.57.2)
       json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
-      parser (>= 3.2.0.0)
+      parser (>= 3.2.2.4)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.28.0, < 2.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.29.0)
+    rubocop-ast (1.30.0)
       parser (>= 3.2.1.0)
-    rubocop-capybara (2.18.0)
+    rubocop-capybara (2.19.0)
       rubocop (~> 1.41)
-    rubocop-factory_bot (2.23.1)
-      rubocop (~> 1.33)
-    rubocop-rspec (2.22.0)
+    rubocop-factory_bot (2.24.0)
       rubocop (~> 1.33)
+    rubocop-rspec (2.25.0)
+      rubocop (~> 1.40)
       rubocop-capybara (~> 2.17)
       rubocop-factory_bot (~> 2.22)
-    ruby-openai (4.1.0)
+    ruby-openai (6.3.0)
+      event_stream_parser (>= 0.3.0, < 2.0.0)
       faraday (>= 1)
       faraday-multipart (>= 1)
     ruby-progressbar (1.13.0)
     ruby2_keywords (0.0.5)
     sweet-moon (0.0.7)
       ffi (~> 1.15, >= 1.15.5)
-    unicode-display_width (2.4.2)
+    unicode-display_width (2.5.0)
 
 PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
   nano-bots!
+  pry-byebug (~> 3.10, >= 3.10.1)
   rspec (~> 3.12)
-  rubocop (~> 1.47)
-  rubocop-rspec (~> 2.22)
+  rubocop (~> 1.57, >= 1.57.2)
+  rubocop-rspec (~> 2.25)
 
 BUNDLED WITH
    2.4.13

data/README.md

@@ -28,13 +28,13 @@ https://user-images.githubusercontent.com/113217272/238141567-c58a240c-7b67-4b3b
 For a system usage:
 
 ```sh
-gem install nano-bots -v 0.1.1
+gem install nano-bots -v 1.0.0
 ```
 
 To use it in a project, add it to your `Gemfile`:
 
 ```ruby
-gem 'nano-bots', '~> 0.1.1'
+gem 'nano-bots', '~> 1.0.0'
 ```
 
 ```sh
@@ -85,7 +85,7 @@ version: '3.7'
 services:
   nano-bots:
     image: ruby:3.2.2-slim-bullseye
-    command: sh -c "gem install nano-bots -v 0.1.1 && bash"
+    command: sh -c "gem install nano-bots -v 1.0.0 && bash"
     environment:
       OPENAI_API_ADDRESS: https://api.openai.com
       OPENAI_API_KEY: your-access-token
@@ -309,7 +309,7 @@ NanoBot.security.check
 # => { encryption: true, password: true }
 ```
 
-#### End-user IDs
+### End-user IDs
 
 A common strategy for deploying Nano Bots to multiple users through APIs or automations is to assign a unique [end-user ID](https://platform.openai.com/docs/guides/safety-best-practices/end-user-ids) for each user. This can be useful if any of your users violate the provider's policy due to abusive behavior. By providing the end-user ID, you can unravel that even though the activity originated from your API Key, the actions taken were not your own.
 
@@ -362,7 +362,7 @@ Actually, to enhance privacy, neither your user nor your users' identifiers will
 
 In this manner, you possess identifiers if required, however, their actual content can only be decrypted by you via your secure password (`NANO_BOTS_ENCRYPTION_PASSWORD`).
 
-## Decrypting
+### Decrypting
 
 To decrypt your encrypted data, once you have properly configured your password, you can simply run:
 
@@ -408,5 +408,5 @@ gem build nano-bots.gemspec
 
 gem signin
 
-gem push nano-bots-0.1.1.gem
+gem push nano-bots-1.0.0.gem
 ```

data/components/adapter.rb

@@ -1,48 +1,34 @@
 # frozen_string_literal: true
 
-require 'sweet-moon'
+require_relative 'embedding'
+require_relative '../logic/cartridge/safety'
 
 module NanoBot
   module Components
     class Adapter
-      def self.apply(_direction, params)
+      def self.apply(params, cartridge)
         content = params[:content]
 
-        if params[:fennel] && params[:lua]
-          raise StandardError, 'Adapter conflict: You can only use either Lua or Fennel, not both.'
-        end
+        raise StandardError, 'conflicting adapters' if %i[fennel lua clojure].count { |key| !params[key].nil? } > 1
+
+        call = {
+          parameters: %w[content], values: [content],
+          safety: { sandboxed: Logic::Cartridge::Safety.sandboxed?(cartridge) }
+        }
 
         if params[:fennel]
-          content = fennel(content, params[:fennel])
+          call[:source] = params[:fennel]
+          content = Components::Embedding.fennel(**call)
+        elsif params[:clojure]
+          call[:source] = params[:clojure]
+          content = Components::Embedding.clojure(**call)
         elsif params[:lua]
-          content = lua(content, params[:lua])
+          call[:source] = params[:lua]
+          content = Components::Embedding.lua(**call)
         end
 
         "#{params[:prefix]}#{content}#{params[:suffix]}"
       end
-
-      def self.fennel(content, expression)
-        path = "#{File.expand_path('../static/fennel', __dir__)}/?.lua"
-        state = SweetMoon::State.new(package_path: path).fennel
-        # TODO: global is deprecated...
-        state.fennel.eval(
-          "(global adapter (fn [content] #{expression}))", 1,
-          { allowedGlobals: %w[math string table] }
-        )
-        adapter = state.get(:adapter)
-        adapter.call([content])
-      end
-
-      def self.lua(content, expression)
-        state = SweetMoon::State.new
-        code = "_, adapter = pcall(load('return function(content) return #{
-          expression.gsub("'", "\\\\'")
-        }; end', nil, 't', {math=math,string=string,table=table}))"
-
-        state.eval(code)
-        adapter = state.get(:adapter)
-        adapter.call([content])
-      end
     end
   end
 end

data/components/embedding.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'sweet-moon'
+
+require 'open3'
+require 'json'
+require 'tempfile'
+
+module NanoBot
+  module Components
+    class Embedding
+      def self.ensure_safety!(safety)
+        raise 'missing safety definitions' unless safety.key?(:sandboxed)
+      end
+
+      def self.lua(source:, parameters:, values:, safety:)
+        ensure_safety!(safety)
+
+        allowed = ''
+        allowed = ', {math=math,string=string,table=table}' if safety[:sandboxed]
+
+        state = SweetMoon::State.new
+        code = "_, embedded = pcall(load([[\nreturn function(#{parameters.join(', ')})\n#{source}\nend\n]], nil, 't'#{allowed}))"
+
+        state.eval(code)
+        embedded = state.get(:embedded)
+        embedded.call(values)
+      end
+
+      def self.fennel(source:, parameters:, values:, safety:)
+        ensure_safety!(safety)
+
+        path = "#{File.expand_path('../static/fennel', __dir__)}/?.lua"
+        state = SweetMoon::State.new(package_path: path).fennel
+
+        # TODO: `global` is deprecated.
+        state.fennel.eval(
+          "(global embedded (fn [#{parameters.join(' ')}] #{source}))", 1,
+          safety[:sandboxed] ? { allowedGlobals: %w[math string table] } : nil
+        )
+        embedded = state.get(:embedded)
+        embedded.call(values)
+      end
+
+      def self.clojure(source:, parameters:, values:, safety:)
+        ensure_safety!(safety)
+
+        raise 'TODO: sandboxed Clojure through Babashka not implemented' if safety[:sandboxed]
+
+        raise 'invalid Clojure parameter name' if parameters.include?('injected-parameters')
+
+        key_value = {}
+
+        parameters.each_with_index { |key, index| key_value[key] = values[index] }
+
+        parameters_json = key_value.to_json
+
+        json_file = Tempfile.new(['nano-bot', '.json'])
+        clojure_file = Tempfile.new(['nano-bot', '.clj'])
+
+        begin
+          json_file.write(parameters_json)
+          json_file.close
+
+          clojure_source = <<~CLOJURE
+            (require '[cheshire.core :as json])
+            (def injected-parameters (json/parse-string (slurp (java.io.FileReader. "#{json_file.path}"))))
+
+            #{parameters.map { |p| "(def #{p} (get injected-parameters \"#{p}\"))" }.join("\n")}
+
+            #{source}
+          CLOJURE
+
+          clojure_file.write(clojure_source)
+          clojure_file.close
+
+          bb_command = "bb --prn #{clojure_file.path} | bb -e \"(->> *in* slurp read-string print)\""
+
+          stdout, stderr, status = Open3.capture3(bb_command)
+
+          status.success? ? stdout : stderr
+        ensure
+          json_file&.unlink
+          clojure_file&.unlink
+        end
+      end
+    end
+  end
+end

data/components/provider.rb

@@ -2,7 +2,7 @@
 
 require 'openai'
 
-require_relative './providers/openai'
+require_relative 'providers/openai'
 
 module NanoBot
   module Components

data/components/providers/openai/tools.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative '../../embedding'
+require_relative '../../../logic/cartridge/safety'
+
+require 'concurrent'
+
+module NanoBot
+  module Components
+    module Providers
+      class OpenAI < Base
+        module Tools
+          def self.confirming(tool, feedback)
+            feedback.call(
+              { should_be_stored: false,
+                interaction: { who: 'AI', message: nil, meta: {
+                  tool: { action: 'confirming', id: tool[:id], name: tool[:name], parameters: tool[:parameters] }
+                } } }
+            )
+          end
+
+          def self.apply(cartridge, function_cartridge, tools, feedback)
+            prepared_tools = NanoBot::Logic::OpenAI::Tools.prepare(function_cartridge, tools)
+
+            if Logic::Cartridge::Safety.confirmable?(cartridge)
+              prepared_tools.each { |tool| tool[:allowed] = confirming(tool, feedback) }
+            else
+              prepared_tools.each { |tool| tool[:allowed] = true }
+            end
+
+            futures = prepared_tools.map do |tool|
+              Concurrent::Promises.future do
+                if tool[:allowed]
+                  process!(tool, feedback, function_cartridge, cartridge)
+                else
+                  tool[:output] =
+                    "We asked the user you're chatting with for permission, but the user did not allow you to run this tool or function."
+                  tool
+                end
+              end
+            end
+
+            results = Concurrent::Promises.zip(*futures).value!
+
+            results.map do |applied_tool|
+              {
+                who: 'tool',
+                message: applied_tool[:output],
+                meta: { id: applied_tool[:id], name: applied_tool[:name] }
+              }
+            end
+          end
+
+          def self.process!(tool, feedback, _function_cartridge, cartridge)
+            feedback.call(
+              { should_be_stored: false,
+                interaction: { who: 'AI', message: nil, meta: {
+                  tool: { action: 'executing', id: tool[:id], name: tool[:name], parameters: tool[:parameters] }
+                } } }
+            )
+
+            call = {
+              parameters: %w[parameters],
+              values: [tool[:parameters]],
+              safety: { sandboxed: Logic::Cartridge::Safety.sandboxed?(cartridge) }
+            }
+
+            if %i[fennel lua clojure].count { |key| !tool[:source][key].nil? } > 1
+              raise StandardError, 'conflicting tools'
+            end
+
+            if !tool[:source][:fennel].nil?
+              call[:source] = tool[:source][:fennel]
+              tool[:output] = Components::Embedding.fennel(**call)
+            elsif !tool[:source][:clojure].nil?
+              call[:source] = tool[:source][:clojure]
+              tool[:output] = Components::Embedding.clojure(**call)
+            elsif !tool[:source][:lua].nil?
+              call[:source] = tool[:source][:lua]
+              tool[:output] = Components::Embedding.lua(**call)
+            else
+              raise 'missing source code'
+            end
+
+            feedback.call(
+              { should_be_stored: false,
+                interaction: { who: 'AI', message: nil, meta: {
+                  tool: {
+                    action: 'responding', id: tool[:id], name: tool[:name],
+                    parameters: tool[:parameters], output: tool[:output]
+                  }
+                } } }
+            )
+
+            tool
+          end
+        end
+      end
+    end
+  end
+end

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/,