diff options
29 files changed, 889 insertions, 103 deletions
diff --git a/components/adapter.rb b/components/adapter.rb index a361437..a79fee6 100644 --- a/components/adapter.rb +++ b/components/adapter.rb @@ -1,6 +1,6 @@ # frozen_string_literal: true -require 'sweet-moon' +require_relative 'embedding' module NanoBot module Components @@ -8,41 +8,23 @@ module NanoBot def self.apply(_direction, params) 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: false } 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 diff --git a/components/embedding.rb b/components/embedding.rb new file mode 100644 index 0000000..c464244 --- /dev/null +++ b/components/embedding.rb @@ -0,0 +1,75 @@ +# frozen_string_literal: true + +require 'sweet-moon' + +require 'open3' +require 'json' +require 'tempfile' + +module NanoBot + module Components + class Embedding + def self.lua(source:, parameters:, values:, safety:) + state = SweetMoon::State.new + # code = "_, embedded = pcall(load([[\nreturn function(#{parameters.join(', ')})\nreturn #{source}\nend\n]], nil, 't', {math=math,string=string,table=table}))" + code = "_, embedded = pcall(load([[\nreturn function(#{parameters.join(', ')})\n#{source}\nend\n]], nil, 't'))" + + state.eval(code) + embedded = state.get(:embedded) + embedded.call(values) + end + + def self.fennel(source:, parameters:, values:, 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 ? { allowedGlobals: %w[math string table] } : nil + ) + embedded = state.get(:embedded) + embedded.call(values) + end + + def self.clojure(source:, parameters:, values:, safety:) + 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 diff --git a/components/provider.rb b/components/provider.rb index 163b099..3414009 100644 --- a/components/provider.rb +++ b/components/provider.rb @@ -2,7 +2,7 @@ require 'openai' -require_relative './providers/openai' +require_relative 'providers/openai' module NanoBot module Components diff --git a/components/providers/openai.rb b/components/providers/openai.rb index ce6fb33..437114c 100644 --- a/components/providers/openai.rb +++ b/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 @@ -34,15 +39,23 @@ module NanoBot def stream(input) provider = @settings.key?(:stream) ? @settings[:stream] : true + + # TODO: There's a bug here... interface = input[:interface].key?(:stream) ? input[:interface][:stream] : true provider && interface end - def evaluate(input, &block) + def evaluate(input, &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], + 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,17 +75,65 @@ module NanoBot payload.delete(:logit_bias) if payload.key?(:logit_bias) && payload[:logit_bias].nil? + payload[:tools] = input[:tools].map { |raw| NanoBot::Logic::OpenAI::Tools.adapt(raw) } if input[:tools] + if stream(input) 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 + + if partial_content + content += partial_content + feedback.call( + { should_be_stored: false, + interaction: { who: 'AI', message: partial_content } } + ) end - block.call({ who: 'AI', message: content }, true) if chunk.dig('choices', 0, 'finish_reason') + 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(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) @@ -81,7 +142,26 @@ module NanoBot 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(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 diff --git a/components/providers/openai/tools.rb b/components/providers/openai/tools.rb new file mode 100644 index 0000000..ea34ae6 --- /dev/null +++ b/components/providers/openai/tools.rb @@ -0,0 +1,73 @@ +# frozen_string_literal: true + +require_relative '../../embedding' + +require 'concurrent' + +module NanoBot + module Components + module Providers + class OpenAI < Base + module Tools + def self.apply(cartridge, tools, feedback) + prepared_tools = NanoBot::Logic::OpenAI::Tools.prepare(cartridge, tools) + + futures = prepared_tools.map do |tool| + Concurrent::Promises.future { process!(tool, feedback) } + 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) + feedback.call( + { should_be_stored: false, + interaction: { who: 'AI', message: nil, meta: { + tool: { action: 'call', id: tool[:id], name: tool[:name], parameters: tool[:parameters] } + } } } + ) + + call = { parameters: %w[parameters], values: [tool[:parameters]], safety: false } + + 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: 'response', id: tool[:id], name: tool[:name], + parameters: tool[:parameters], output: tool[:output] + } + } } } + ) + + tool + end + end + end + end + end +end diff --git a/components/storage.rb b/components/storage.rb index 577ce67..6a3fe13 100644 --- a/components/storage.rb +++ b/components/storage.rb @@ -3,7 +3,7 @@ require 'babosa' require_relative '../logic/helpers/hash' -require_relative './crypto' +require_relative 'crypto' module NanoBot module Components diff --git a/components/stream.rb b/components/stream.rb index 45c4a2b..347eb87 100644 --- a/components/stream.rb +++ b/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 diff --git a/controllers/cartridges.rb b/controllers/cartridges.rb index fe0d56e..df474a9 100644 --- a/controllers/cartridges.rb +++ b/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/, diff --git a/controllers/instance.rb b/controllers/instance.rb index d4e0c1b..259a548 100644 --- a/controllers/instance.rb +++ b/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)) diff --git a/controllers/interfaces/repl.rb b/controllers/interfaces/repl.rb index fd16ea6..d4191b1 100644 --- a/controllers/interfaces/repl.rb +++ b/controllers/interfaces/repl.rb @@ -37,6 +37,8 @@ module NanoBot [proc { prompt }, proc { 'MISSING INPUT' }] ) + Logic::Cartridge::Streaming.enabled?(cartridge, :repl) + Pry.commands.block_command(/(.*)/, 'handler') do |line| session.print(prefix) unless prefix.nil? session.evaluate_and_print(line, mode: 'repl') diff --git a/controllers/interfaces/tools.rb b/controllers/interfaces/tools.rb new file mode 100644 index 0000000..5105da1 --- /dev/null +++ b/controllers/interfaces/tools.rb @@ -0,0 +1,90 @@ +# frozen_string_literal: true + +require 'rainbow' + +require_relative '../../logic/cartridge/tools' +require_relative '../../components/embedding' + +module NanoBot + module Controllers + module Interfaces + module Tool + def self.adapt(feedback, adapter) + call = { + parameters: %w[id name parameters parameters-as-json output], + values: [ + feedback[:id], feedback[:name], feedback[:parameters], + feedback[:parameters].to_json, + feedback[:output] + ], + safety: false + } + + 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) + + 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) + else + message = "(#{feedback[:name]} #{feedback[:parameters].to_json})" + + message += " =>\n#{feedback[:output]}" if feedback[:action].to_sym == :response + 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 diff --git a/controllers/session.rb b/controllers/session.rb index 4694911..d20deb2 100644 --- a/controllers/session.rb +++ b/controllers/session.rb @@ -3,10 +3,13 @@ require 'babosa' require 'fileutils' +require 'rainbow' require_relative '../logic/helpers/hash' 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' @@ -41,9 +44,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! @@ -78,42 +81,78 @@ 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 + + # TODO: Improve infinite loop prevention. + needs_another_round = process_interaction(input, mode:) while needs_another_round + 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]) - - event[:mode] = mode.to_s - event[:output] = "#{prefix}#{output[:message]}#{suffix}" + @provider.evaluate(input) do |feedback| + updated_at = Time.now - @state[:history] << event + needs_another_round = true if feedback[:needs_another_round] - self.print(output[:message]) unless streaming + if feedback[:interaction] && feedback.dig(:interaction, :meta, :tool, :action) + Interfaces::Tool.dispatch_feedback(self, @cartridge, mode, feedback[:interaction][:meta][:tool]) + end - ready = true - flush - elsif streaming - self.print(output[:message]) + 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, output[:message]) + 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])) + # TODO: Color? + if color + self.print(Rainbow(event[:output]).send(color)) + else + self.print(event[:output]) + end + + flush if feedback[:finished] + end + + # `.print` already adds a prefix and suffix, so we add them after printing to avoid duplications. + event[:output] = "#{prefix}#{event[:output]}#{suffix}" end + + ready = true if feedback[:finished] end until ready @@ -122,6 +161,8 @@ module NanoBot end store_state! unless @stateless + + needs_another_round end def flush diff --git a/logic/cartridge/adapters.rb b/logic/cartridge/adapters.rb index bc8ddaf..4a3fadf 100644 --- a/logic/cartridge/adapters.rb +++ b/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 diff --git a/logic/cartridge/affixes.rb b/logic/cartridge/affixes.rb index 0b40fa2..bf94d92 100644 --- a/logic/cartridge/affixes.rb +++ b/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 diff --git a/logic/cartridge/default.rb b/logic/cartridge/default.rb index 43d45d4..24a8e7c 100644 --- a/logic/cartridge/default.rb +++ b/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 diff --git a/logic/cartridge/fetch.rb b/logic/cartridge/fetch.rb new file mode 100644 index 0000000..2335358 --- /dev/null +++ b/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 diff --git a/logic/cartridge/interaction.rb b/logic/cartridge/interaction.rb index 160d818..5e8264e 100644 --- a/logic/cartridge/interaction.rb +++ b/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 diff --git a/logic/cartridge/tools.rb b/logic/cartridge/tools.rb new file mode 100644 index 0000000..6a45bf0 --- /dev/null +++ b/logic/cartridge/tools.rb @@ -0,0 +1,53 @@ +# frozen_string_literal: true + +require_relative 'fetch' +require_relative 'affixes' +require_relative 'adapters' + +module NanoBot + module Logic + module Cartridge + module Tools + def self.fetch_from_interface(cartridge, interface, action, path) + Fetch.cascate(cartridge, [ + [:interfaces, interface, :tools, action].concat(path), + [:interfaces, :tools, action].concat(path), + %i[interfaces tools].concat(path) + ]) + end + + def self.feedback?(cartridge, interface, action) + Fetch.cascate(cartridge, [ + [:interfaces, interface, :tools, action, :feedback], + [:interfaces, :tools, action, :feedback], + %i[interfaces tools feedback] + ]) + end + + def self.input(cartridge, interface, content) + lua = Adapter.expression(cartridge, interface, :input, :lua) + fennel = Adapter.expression(cartridge, interface, :input, :fennel) + + prefix = Affixes.get(cartridge, interface, :input, :prefix) + suffix = Affixes.get(cartridge, interface, :input, :suffix) + + { content:, prefix:, suffix:, lua:, fennel: } + end + + def self.output(cartridge, interface, result, streaming, _finished) + if streaming + result[:message] = { content: result[:message], lua: nil, fennel: nil } + return result + end + + lua = Adapter.expression(cartridge, interface, :output, :lua) + fennel = Adapter.expression(cartridge, interface, :output, :fennel) + + result[:message] = { content: result[:message], lua:, fennel: } + + result + end + end + end + end +end diff --git a/logic/providers/openai.rb b/logic/providers/openai.rb new file mode 100644 index 0000000..00e7a43 --- /dev/null +++ b/logic/providers/openai.rb @@ -0,0 +1,57 @@ +# frozen_string_literal: true + +require 'json' + +module NanoBot + module Logic + module OpenAI + def self.prepare_tools(cartridge, tools) + applies = [] + tools.each do |tool| + cartridge.each do |candidate| + next unless candidate[:type] == 'function' && + tool[:type] == candidate[:type] && + tool[:function][:name] == candidate[:name] + + source = {} + + source[:fennel] = candidate[:fennel] if candidate[:fennel] + source[:lua] = candidate[:lua] if candidate[:lua] + + applies << { + name: tool[:function][:name], + type: candidate[:type], + parameters: JSON.parse(tool[:function][:arguments]), + source: + } + end + end + + applies + end + + def self.adapt_tool(cartridge) + raise 'unsupported tool' if cartridge[:type] != 'function' + + adapted = { + type: 'function', + function: { + name: cartridge[:name], description: cartridge[:description], + parameters: { type: 'object', properties: {} } + } + } + + properties = adapted[:function][:parameters][:properties] + + cartridge[:parameters].each do |parameter| + key = parameter[:name].to_sym + properties[key] = {} + properties[key][:type] = parameter[:type] || 'string' + properties[key][:description] = parameter[:description] if parameter[:description] + end + + adapted + end + end + end +end diff --git a/logic/providers/openai/tools.rb b/logic/providers/openai/tools.rb new file mode 100644 index 0000000..080d81e --- /dev/null +++ b/logic/providers/openai/tools.rb @@ -0,0 +1,70 @@ +# frozen_string_literal: true + +require 'json' + +require_relative '../../helpers/hash' + +module NanoBot + module Logic + module OpenAI + module Tools + def self.prepare(cartridge, tools) + applies = [] + tools.each do |tool| + # TODO: Does this mutate the hash? + tool = Helpers::Hash.symbolize_keys(tool) + + cartridge.each do |candidate| + next unless ( + candidate[:type].nil? || + (candidate[:type] == 'function' && tool[:type] == candidate[:type]) + ) && tool[:function][:name] == candidate[:name] + + source = {} + + source[:clojure] = candidate[:clojure] if candidate[:clojure] + source[:fennel] = candidate[:fennel] if candidate[:fennel] + source[:lua] = candidate[:lua] if candidate[:lua] + + applies << { + id: tool[:id], + name: tool[:function][:name], + type: candidate[:type] || 'function', + parameters: JSON.parse(tool[:function][:arguments]), + source: + } + end + end + + applies + end + + def self.adapt(cartridge) + raise 'unsupported tool' if cartridge[:type] != 'function' && !cartridge[:type].nil? + + adapted = { + type: cartridge[:type] || 'function', + function: { + name: cartridge[:name], description: cartridge[:description], + parameters: { type: 'object', properties: {} } + } + } + + properties = adapted[:function][:parameters][:properties] + + adapted[:function][:parameters][:required] = cartridge[:required] if cartridge[:required] + + cartridge[:parameters]&.each do |parameter| + key = parameter[:name].to_sym + properties[key] = {} + properties[key][:type] = parameter[:type] || 'string' + properties[key][:description] = parameter[:description] if parameter[:description] + properties[key][:items] = parameter[:items].slice(:type) if parameter[:items] + end + + adapted + end + end + end + end +end diff --git a/spec/data/cartridges/tools.yml b/spec/data/cartridges/tools.yml new file mode 100644 index 0000000..0c2a30b --- /dev/null +++ b/spec/data/cartridges/tools.yml @@ -0,0 +1,28 @@ +--- +tools: + - name: get-current-weather + type: function + description: Get the current weather in a given location. + parameters: + - name: location + - name: unit + fennel: | + (let [{:location location :unit unit} parameters] + (.. "Here is the weather in " location ", in " unit ": 35.8°C.")) + + - name: what-time-is-it + description: Returns the current date and time. + fennel: | + (os.date) + + - name: sh + description: It has access to computer users' data and can be used to run shell commands, similar to those in a Linux terminal, to extract information. Please be mindful and careful to avoid running dangerous commands on users' computers. + parameters: + - name: command + type: array + items: + type: string + description: An array of strings that represents a shell command along with its arguments or options. For instance, `["df", "-h"]` executes the `df -h` command, where each array element specifies either the command itself or an associated argument/option. + clojure: | + (require '[clojure.java.shell :refer [sh]]) + (println (apply sh (get parameters "command"))) diff --git a/spec/data/providers/openai/tools.yml b/spec/data/providers/openai/tools.yml new file mode 100644 index 0000000..681fb2c --- /dev/null +++ b/spec/data/providers/openai/tools.yml @@ -0,0 +1,11 @@ +--- +- id: call_XYZ + type: function + function: + name: get-current-weather + arguments: '{"location":"Tokyo, Japan"}' +- id: call_ZYX + type: function + function: + name: what-time-is-it + arguments: "{}" diff --git a/spec/logic/cartridge/affixes_spec.rb b/spec/logic/cartridge/affixes_spec.rb index 8f08e1d..7263008 100644 --- a/spec/logic/cartridge/affixes_spec.rb +++ b/spec/logic/cartridge/affixes_spec.rb @@ -6,7 +6,7 @@ require_relative '../../../logic/cartridge/affixes' RSpec.describe NanoBot::Logic::Cartridge::Affixes do context 'interfaces' do - let(:cartridge) { load_cartridge('affixes.yml') } + let(:cartridge) { load_symbolized('cartridges/affixes.yml') } it 'gets the expected affixes' do expect(described_class.get(cartridge, :repl, :input, :prefix)).to eq('E') @@ -22,7 +22,7 @@ RSpec.describe NanoBot::Logic::Cartridge::Affixes do end context 'interfaces fallback' do - let(:cartridge) { load_cartridge('affixes.yml') } + let(:cartridge) { load_symbolized('cartridges/affixes.yml') } it 'gets the expected affixes' do cartridge[:interfaces][:repl][:input].delete(:prefix) @@ -48,7 +48,7 @@ RSpec.describe NanoBot::Logic::Cartridge::Affixes do end context 'interfaces nil' do - let(:cartridge) { load_cartridge('affixes.yml') } + let(:cartridge) { load_symbolized('cartridges/affixes.yml') } it 'gets the expected affixes' do cartridge[:interfaces][:repl][:input][:prefix] = nil diff --git a/spec/logic/cartridge/interaction_spec.rb b/spec/logic/cartridge/interaction_spec.rb index 347ac45..f3ba46e 100644 --- a/spec/logic/cartridge/interaction_spec.rb +++ b/spec/logic/cartridge/interaction_spec.rb @@ -6,41 +6,41 @@ require_relative '../../../logic/cartridge/interaction' RSpec.describe NanoBot::Logic::Cartridge::Interaction do context 'input' do - let(:cartridge) { load_cartridge('affixes.yml') } + let(:cartridge) { load_symbolized('cartridges/affixes.yml') } it 'prepares the input' do expect(described_class.input(cartridge, :repl, 'hello')).to eq( - { content: 'hello', fennel: nil, lua: nil, prefix: 'E', suffix: 'F' } + { content: 'hello', fennel: nil, lua: nil, clojure: nil, prefix: 'E', suffix: 'F' } ) expect(described_class.input({}, :repl, 'hello')).to eq( - { content: 'hello', fennel: nil, lua: nil, prefix: nil, suffix: nil } + { content: 'hello', fennel: nil, lua: nil, clojure: nil, prefix: nil, suffix: nil } ) expect(described_class.input(cartridge, :eval, 'hello')).to eq( - { content: 'hello', fennel: nil, lua: nil, prefix: 'I', suffix: 'J' } + { content: 'hello', fennel: nil, lua: nil, clojure: nil, prefix: 'I', suffix: 'J' } ) expect(described_class.input({}, :eval, 'hello')).to eq( - { content: 'hello', fennel: nil, lua: nil, prefix: nil, suffix: nil } + { content: 'hello', fennel: nil, lua: nil, clojure: nil, prefix: nil, suffix: nil } ) end it 'prepares the non-streamming output' do expect(described_class.output(cartridge, :repl, { message: 'hello' }, false, true)).to eq( - { message: { content: 'hello', fennel: nil, lua: nil } } + { message: { content: 'hello', fennel: nil, lua: nil, clojure: nil } } ) expect(described_class.output({}, :repl, { message: 'hello' }, false, true)).to eq( - { message: { content: 'hello', fennel: nil, lua: nil } } + { message: { content: 'hello', fennel: nil, lua: nil, clojure: nil } } ) expect(described_class.output(cartridge, :eval, { message: 'hello' }, false, true)).to eq( - { message: { content: 'hello', fennel: nil, lua: nil } } + { message: { content: 'hello', fennel: nil, lua: nil, clojure: nil } } ) expect(described_class.output({}, :eval, { message: 'hello' }, false, true)).to eq( - { message: { content: 'hello', fennel: nil, lua: nil } } + { message: { content: 'hello', fennel: nil, lua: nil, clojure: nil } } ) end end diff --git a/spec/logic/cartridge/streaming_spec.rb b/spec/logic/cartridge/streaming_spec.rb index e5ad012..466dd0b 100644 --- a/spec/logic/cartridge/streaming_spec.rb +++ b/spec/logic/cartridge/streaming_spec.rb @@ -5,8 +5,28 @@ require 'yaml' require_relative '../../../logic/cartridge/streaming' RSpec.describe NanoBot::Logic::Cartridge::Streaming do + context 'interfaces override' do + context 'defaults' do + let(:cartridge) { {} } + + it 'uses default values when appropriate' do + expect(described_class.enabled?(cartridge, :repl)).to be(true) + expect(described_class.enabled?(cartridge, :eval)).to be(true) + end + end + + context 'top-level overrides' do + let(:cartridge) { { interfaces: { output: { stream: false } } } } + + it 'overrides default values when appropriate' do + expect(described_class.enabled?(cartridge, :repl)).to be(false) + expect(described_class.enabled?(cartridge, :eval)).to be(false) + end + end + end + context 'provider' do - let(:cartridge) { load_cartridge('streaming.yml') } + let(:cartridge) { load_symbolized('cartridges/streaming.yml') } it 'checks if stream is enabled' do cartridge[:provider][:settings][:stream] = false @@ -15,7 +35,7 @@ RSpec.describe NanoBot::Logic::Cartridge::Streaming do end context 'repl' do - let(:cartridge) { load_cartridge('streaming.yml') } + let(:cartridge) { load_symbolized('cartridges/streaming.yml') } it 'checks if stream is enabled' do cartridge[:interfaces][:repl][:output][:stream] = false @@ -24,7 +44,7 @@ RSpec.describe NanoBot::Logic::Cartridge::Streaming do end context 'interface + repl' do - let(:cartridge) { load_cartridge('streaming.yml') } + let(:cartridge) { load_symbolized('cartridges/streaming.yml') } it 'checks if stream is enabled' do cartridge[:interfaces][:output][:stream] = false @@ -34,7 +54,7 @@ RSpec.describe NanoBot::Logic::Cartridge::Streaming do end context 'interface' do - let(:cartridge) { load_cartridge('streaming.yml') } + let(:cartridge) { load_symbolized('cartridges/streaming.yml') } it 'checks if stream is enabled' do cartridge[:interfaces][:output][:stream] = false @@ -44,7 +64,7 @@ RSpec.describe NanoBot::Logic::Cartridge::Streaming do end context '- repl' do - let(:cartridge) { load_cartridge('streaming.yml') } + let(:cartridge) { load_symbolized('cartridges/streaming.yml') } it 'checks if stream is enabled' do cartridge[:interfaces][:repl][:output].delete(:stream) @@ -53,7 +73,7 @@ RSpec.describe NanoBot::Logic::Cartridge::Streaming do end context '- interface' do - let(:cartridge) { load_cartridge('streaming.yml') } + let(:cartridge) { load_symbolized('cartridges/streaming.yml') } it 'checks if stream is enabled' do cartridge[:interfaces][:output].delete(:stream) @@ -63,7 +83,7 @@ RSpec.describe NanoBot::Logic::Cartridge::Streaming do end context '- provider' do - let(:cartridge) { load_cartridge('streaming.yml') } + let(:cartridge) { load_symbolized('cartridges/streaming.yml') } it 'checks if stream is enabled' do cartridge[:provider][:settings].delete(:stream) diff --git a/spec/logic/cartridge/tools_spec.rb b/spec/logic/cartridge/tools_spec.rb new file mode 100644 index 0000000..42b8c57 --- /dev/null +++ b/spec/logic/cartridge/tools_spec.rb @@ -0,0 +1,97 @@ +# frozen_string_literal: true + +require 'yaml' + +require_relative '../../../logic/cartridge/tools' + +RSpec.describe NanoBot::Logic::Cartridge::Tools do + context 'interfaces override' do + context 'defaults' do + let(:cartridge) { {} } + + it 'uses default values when appropriate' do + expect(described_class.feedback?(cartridge, :repl, :call)).to be(true) + expect(described_class.feedback?(cartridge, :eval, :call)).to be(true) + + expect(described_class.feedback?(cartridge, :repl, :response)).to be(false) + expect(described_class.feedback?(cartridge, :eval, :response)).to be(false) + end + end + + context 'top-level overrides' do + let(:cartridge) do + { interfaces: { tools: { feedback: false } } } + end + + it 'overrides default values when appropriate' do + expect(described_class.feedback?(cartridge, :repl, :call)).to be(false) + expect(described_class.feedback?(cartridge, :eval, :call)).to be(false) + + expect(described_class.feedback?(cartridge, :repl, :response)).to be(false) + expect(described_class.feedback?(cartridge, :eval, :response)).to be(false) + end + end + + context 'top-level overrides' do + let(:cartridge) do + { interfaces: { tools: { feedback: true } } } + end + + it 'overrides default values when appropriate' do + expect(described_class.feedback?(cartridge, :repl, :call)).to be(true) + expect(described_class.feedback?(cartridge, :eval, :call)).to be(true) + + expect(described_class.feedback?(cartridge, :repl, :response)).to be(true) + expect(described_class.feedback?(cartridge, :eval, :response)).to be(true) + end + end + + context 'top-level-specific overrides' do + let(:cartridge) do + { interfaces: { tools: { call: { feedback: false }, response: { feedback: true } } } } + end + + it 'overrides default values when appropriate' do + expect(described_class.feedback?(cartridge, :repl, :call)).to be(false) + expect(described_class.feedback?(cartridge, :eval, :call)).to be(false) + + expect(described_class.feedback?(cartridge, :repl, :response)).to be(true) + expect(described_class.feedback?(cartridge, :eval, :response)).to be(true) + end + end + + context 'repl interface overrides' do + let(:cartridge) do + { interfaces: { + tools: { call: { feedback: false }, response: { feedback: true } }, + repl: { tools: { call: { feedback: true }, response: { feedback: false } } } + } } + end + + it 'overrides default values when appropriate' do + expect(described_class.feedback?(cartridge, :repl, :call)).to be(true) + expect(described_class.feedback?(cartridge, :eval, :call)).to be(false) + + expect(described_class.feedback?(cartridge, :repl, :response)).to be(false) + expect(described_class.feedback?(cartridge, :eval, :response)).to be(true) + end + end + + context 'eval interface overrides' do + let(:cartridge) do + { interfaces: { + tools: { call: { feedback: false }, response: { feedback: true } }, + eval: { tools: { call: { feedback: true }, response: { feedback: false } } } + } } + end + + it 'overrides default values when appropriate' do + expect(described_class.feedback?(cartridge, :repl, :call)).to be(false) + expect(described_class.feedback?(cartridge, :eval, :call)).to be(true) + + expect(described_class.feedback?(cartridge, :repl, :response)).to be(true) + expect(described_class.feedback?(cartridge, :eval, :response)).to be(false) + end + end + end +end diff --git a/spec/logic/providers/openai/tools_spec.rb b/spec/logic/providers/openai/tools_spec.rb new file mode 100644 index 0000000..c92c374 --- /dev/null +++ b/spec/logic/providers/openai/tools_spec.rb @@ -0,0 +1,73 @@ +# frozen_string_literal: true + +require 'yaml' + +require_relative '../../../../logic/providers/openai/tools' + +RSpec.describe NanoBot::Logic::OpenAI::Tools do + context 'tools' do + let(:cartridge) { load_symbolized('cartridges/tools.yml') } + + context 'adapt' do + it 'adapts to OpenAI expected format' do + expect(described_class.adapt(cartridge[:tools][0])).to eq( + { type: 'function', + function: { + name: 'get-current-weather', + description: 'Get the current weather in a given location.', + parameters: { + type: 'object', + properties: { + location: { type: 'string' }, + unit: { type: 'string' } + } + } + } } + ) + + expect(described_class.adapt(cartridge[:tools][1])).to eq( + { type: 'function', + function: { + name: 'what-time-is-it', + description: 'Returns the current date and time.', + parameters: { properties: {}, type: 'object' } + } } + ) + + expect(described_class.adapt(cartridge[:tools][2])).to eq( + { type: 'function', + function: { + name: 'sh', + description: "It has access to computer users' data and can be used to run shell commands, similar to those in a Linux terminal, to extract information. Please be mindful and careful to avoid running dangerous commands on users' computers.", + parameters: { + type: 'object', + properties: { + command: { + type: 'array', + description: 'An array of strings that represents a shell command along with its arguments or options. For instance, `["df", "-h"]` executes the `df -h` command, where each array element specifies either the command itself or an associated argument/option.', + items: { type: 'string' } + } + } + } + } } + ) + end + end + + context 'prepare' do + let(:tools) { load_symbolized('providers/openai/tools.yml') } + + it 'prepare tools to be executed' do + expect(described_class.prepare(cartridge[:tools], tools)).to eq( + [{ id: 'call_XYZ', + name: 'get-current-weather', + type: 'function', + parameters: { 'location' => 'Tokyo, Japan' }, + source: { fennel: "(let [{:location location :unit unit} parameters]\n (.. \"Here is the weather in \" location \", in \" unit \": 35.8°C.\"))\n" } }, + { id: 'call_ZYX', name: 'what-time-is-it', type: 'function', parameters: {}, + source: { fennel: "(os.date)\n" } }] + ) + end + end + end +end diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb index ad9038d..cb46554 100644 --- a/spec/spec_helper.rb +++ b/spec/spec_helper.rb @@ -16,8 +16,8 @@ RSpec.configure do |config| config.shared_context_metadata_behavior = :apply_to_host_groups end -def load_cartridge(path) - cartridge = YAML.safe_load(File.read("spec/data/cartridges/#{path}"), permitted_classes: [Symbol]) +def load_symbolized(path) + cartridge = YAML.safe_load_file("spec/data/#{path}", permitted_classes: [Symbol]) NanoBot::Logic::Helpers::Hash.symbolize_keys(cartridge) end diff --git a/static/cartridges/default.yml b/static/cartridges/default.yml index 2cadc8c..167fa83 100644 --- a/static/cartridges/default.yml +++ b/static/cartridges/default.yml @@ -12,6 +12,11 @@ interfaces: output: stream: true suffix: "\n" + tools: + call: + feedback: true + response: + feedback: false provider: settings: |