+ gem 'rubocop', '~> 1.59'

+ gemini-ai (~> 1.0)

+ addressable (2.8.6)

+ public_suffix (>= 2.0.2, < 6.0)

+ gemini-ai (1.0.0)

+ event_stream_parser (~> 1.0)

+ faraday (~> 2.7, >= 2.7.12)

+ googleauth (~> 1.9, >= 1.9.1)

+ google-cloud-env (2.1.0)

+ faraday (>= 1.0, < 3.a)

+ googleauth (1.9.1)

+ faraday (>= 1.0, < 3.a)

+ google-cloud-env (~> 2.1)

+ jwt (>= 1.4, < 3.0)

+ multi_json (~> 1.11)

+ os (>= 0.9, < 2.0)

+ signet (>= 0.16, < 2.a)

+ jwt (2.7.1)

+ multi_json (1.15.0)

+ os (1.1.4)

+ public_suffix (5.0.4)

+ rubocop (1.59.0)

+ signet (0.18.0)

+ addressable (~> 2.8)

+ faraday (>= 0.17.5, < 3.a)

+ jwt (>= 1.5, < 3.0)

+ multi_json (~> 1.10)

+ rubocop (~> 1.59)

+ - [OpenAI ChatGPT](#openai-chatgpt)

+ - [Google Gemini](#google-gemini)

+ - [Docker](#docker)

+ - [OpenAI ChatGPT](#openai-chatgpt-1)

+ - [Google Gemini](#google-gemini-1)

+ - [Command Line](#command-line)

+ - [Library](#library)

+ - [OpenAI ChatGPT](#openai-chatgpt-2)

+ - [Google Gemini](#google-gemini-2)

+ - [Tools (Functions)](#tools-functions)

+ - [Experimental Clojure Support](#experimental-clojure-support)

+ - [Marketplace](#marketplace)

+ - [Cryptography](#cryptography)

+ - [End-user IDs](#end-user-ids)

+ - [Decrypting](#decrypting)

+ - [Publish to RubyGems](#publish-to-rubygems)

+### OpenAI ChatGPT

+

+### Google Gemini

+

+Click [here](https://github.com/gbaptista/gemini-ai#credentials) to learn how to obtain your credentials.

+

+```sh

+export GOOGLE_CREDENTIALS_FILE_PATH=google-credentials.json

+export GOOGLE_PROJECT_ID=your-project-id

+export GOOGLE_REGION=us-east4

+

+export NANO_BOTS_ENCRYPTION_PASSWORD=UNSAFE

+export NANO_BOTS_END_USER=your-user

+

+# export NANO_BOTS_STATE_DIRECTORY=/home/user/.local/state/nano-bots

+# export NANO_BOTS_CARTRIDGES_DIRECTORY=/home/user/.local/share/nano-bots/cartridges

+```

+

+Alternatively, if your current directory has a `.env` file with the environment variables, they will be automatically loaded:

+

+```sh

+GOOGLE_CREDENTIALS_FILE_PATH=google-credentials.json

+GOOGLE_PROJECT_ID=your-project-id

+GOOGLE_REGION=us-east4

+

+NANO_BOTS_ENCRYPTION_PASSWORD=UNSAFE

+NANO_BOTS_END_USER=your-user

+

+# NANO_BOTS_STATE_DIRECTORY=/home/user/.local/state/nano-bots

+# NANO_BOTS_CARTRIDGES_DIRECTORY=/home/user/.local/share/nano-bots/cartridges

+```

+

+### OpenAI ChatGPT

+

+### Google Gemini

+

+```yaml

+---

+services:

+ nano-bots:

+ 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.1.2 && bash"

+ environment:

+ GOOGLE_CREDENTIALS_FILE_PATH: /root/.config/google-credentials.json

+ GOOGLE_PROJECT_ID: your-project-id

+ GOOGLE_REGION: us-east4

+ NANO_BOTS_ENCRYPTION_PASSWORD: UNSAFE

+ NANO_BOTS_END_USER: your-user

+ volumes:

+ - ./google-credentials.json:/root/.config/google-credentials.json

+ - ./your-cartridges:/root/.local/share/nano-bots/cartridges

+ - ./your-state-path:/root/.local/state/nano-bots

+```

+

+### Container

+

+Check the Nano Bots specification to learn more about [how to build cartridges](https://spec.nbots.io/#/README?id=cartridges).

+

+Try the [Nano Bots Clinic (Live Editor)](https://clinic.nbots.io) to learn about creating Cartridges.

+

+### OpenAI ChatGPT

+

+Read the [full specification](https://spec.nbots.io/#/README?id=open-ai-chatgpt) for OpenAI ChatGPT.

+

+ model: gpt-4-1106-preview

+### Google Gemini

+Read the [full specification](https://spec.nbots.io/#/README?id=google-gemini) for Google Gemini.

+

+```yaml

+---

+meta:

+ symbol: 🤖

+ name: Nano Bot Name

+ author: Your Name

+ version: 1.0.0

+ license: CC0-1.0

+ description: A helpful assistant.

+

+behaviors:

+ interaction:

+ directive: You are a helpful assistant.

+

+provider:

+ id: google

+ credentials:

+ project-id: ENV/GOOGLE_PROJECT_ID

+ file-path: ENV/GOOGLE_CREDENTIALS_FILE_PATH

+ region: ENV/GOOGLE_REGION

+ options:

+ model: gemini-pro

+```

+To successfully use Tools (Functions), you need to specify a provider and a model that supports them. As of the writing of this README, the provider that supports them is [OpenAI](https://platform.openai.com/docs/models), with models `gpt-3.5-turbo-1106` and `gpt-4-1106-preview`, and [Google](https://cloud.google.com/vertex-ai/docs/generative-ai/multimodal/function-calling#supported_models), with the model `gemini-pro`.

+Check the [Nano Bots specification](https://spec.nbots.io/#/README?id=tools-functions-2) to learn more about Tools (Functions).

+- [x] [Open AI ChatGPT](https://platform.openai.com/docs/api-reference)

+- [x] [Google Gemini](https://cloud.google.com/vertex-ai/docs/generative-ai/model-reference/gemini)

+- [ ] [Anthropic Claude](https://www.anthropic.com)

+- [ ] [Cohere Command](https://cohere.com)

+- [ ] [Meta Llama](https://ai.meta.com/llama/)

+- [ ] [01.AI Yi](https://01.ai)

+- [ ] [WizardLM](https://wizardlm.github.io)

+- [ ] [LMSYS Org FastChat Vicuna](https://github.com/lm-sys/FastChat)

+Although only OpenAI ChatGPT and Google Gemini have been officially tested, some alternative providers offer APIs that are compatible with, for example, OpenAI, such as [FastChat](https://github.com/lm-sys/FastChat#openai-compatible-restful-apis--sdk). Therefore, it is highly probable that they will work just fine.

+require_relative 'providers/google'

+ when 'google'

+ Providers::Google.new(provider[:options], provider[:settings], provider[:credentials], environment:)

+# frozen_string_literal: true

+

+require 'gemini-ai'

+

+require_relative 'base'

+

+require_relative '../../logic/providers/google/tools'

+require_relative '../../logic/providers/google/tokens'

+

+require_relative 'tools'

+

+module NanoBot

+ module Components

+ module Providers

+ class Google < Base

+ SETTINGS = {

+ generationConfig: %i[

+ temperature topP topK candidateCount maxOutputTokens stopSequences

+ ].freeze

+ }.freeze

+

+ SAFETY_SETTINGS = %i[category threshold].freeze

+

+ attr_reader :settings

+

+ def initialize(options, settings, credentials, _environment)

+ @settings = settings

+

+ @client = Gemini.new(

+ credentials: {

+ file_path: credentials[:'file-path'],

+ project_id: credentials[:'project-id'],

+ region: credentials[:region]

+ },

+ settings: { model: options[:model], stream: options[:stream] }

+ )

+ end

+

+ def evaluate(input, streaming, cartridge, &feedback)

+ messages = input[:history].map do |event|

+ if event[:message].nil? && event[:meta] && event[:meta][:tool_calls]

+ { role: 'model',

+ parts: event[:meta][:tool_calls],

+ _meta: { at: event[:at] } }

+ elsif event[:who] == 'tool'

+ { role: 'function',

+ parts: [

+ { functionResponse: {

+ name: event[:meta][:name],

+ response: { name: event[:meta][:name], content: event[:message].to_s }

+ } }

+ ],

+ _meta: { at: event[:at] } }

+ else

+ { role: event[:who] == 'user' ? 'user' : 'model',

+ parts: { text: event[:message] },

+ _meta: { at: event[:at] } }

+ end

+ end

+

+ %i[backdrop directive].each do |key|

+ next unless input[:behavior][key]

+

+ # TODO: Does Gemini have system messages?

+ messages.prepend(

+ { role: key == :directive ? 'user' : 'user',

+ parts: { text: input[:behavior][key] },

+ _meta: { at: Time.now } }

+ )

+ end

+

+ payload = { contents: messages, generationConfig: { candidateCount: 1 } }

+

+ if @settings

+ SETTINGS.each_key do |key|

+ SETTINGS[key].each do |sub_key|

+ if @settings.key?(key) && @settings[key].key?(sub_key)

+ payload[key] = {} unless payload.key?(key)

+ payload[key][sub_key] = @settings[key][sub_key]

+ end

+ end

+ end

+

+ if @settings[:safetySettings].is_a?(Array)

+ payload[:safetySettings] = [] unless payload.key?(:safetySettings)

+

+ @settings[:safetySettings].each do |safety_setting|

+ setting = {}

+ SAFETY_SETTINGS.each { |key| setting[key] = safety_setting[key] }

+ payload[:safetySettings] << setting

+ end

+ end

+ end

+

+ if input[:tools]

+ payload[:tools] = {

+ function_declarations: input[:tools].map { |raw| Logic::Google::Tools.adapt(raw) }

+ }

+ end

+

+ if streaming

+ content = ''

+ tools = []

+

+ stream_call_back = proc do |event, _parsed, _raw|

+ partial_content = event.dig('candidates', 0, 'content', 'parts').filter do |part|

+ part.key?('text')

+ end.map { |part| part['text'] }.join

+

+ partial_tools = event.dig('candidates', 0, 'content', 'parts').filter do |part|

+ part.key?('functionCall')

+ end

+

+ tools.concat(partial_tools) if partial_tools.size.positive?

+

+ if partial_content

+ content += partial_content

+ feedback.call(

+ { should_be_stored: false,

+ interaction: { who: 'AI', message: partial_content } }

+ )

+ end

+

+ if event.dig('candidates', 0, 'finishReason')

+ 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, Logic::Google::Tools

+ ).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

+

+ begin

+ @client.stream_generate_content(

+ Logic::Google::Tokens.apply_policies!(cartridge, payload),

+ stream: true, &stream_call_back

+ )

+ rescue StandardError => e

+ raise e.class, e.response[:body] if e.response && e.response[:body]

+

+ raise e

+ end

+ else

+ begin

+ result = @client.stream_generate_content(

+ Logic::Google::Tokens.apply_policies!(cartridge, payload),

+ stream: false

+ )

+ rescue StandardError => e

+ raise e.class, e.response[:body] if e.response && e.response[:body]

+

+ raise e

+ end

+

+ tools = result.dig(0, 'candidates', 0, 'content', 'parts').filter do |part|

+ part.key?('functionCall')

+ end

+

+ 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, Logic::Google::Tools

+ ).each do |interaction|

+ feedback.call({ should_be_stored: true, needs_another_round: true, interaction: })

+ end

+ end

+

+ content = result.map do |answer|

+ answer.dig('candidates', 0, 'content', 'parts').filter do |part|

+ part.key?('text')

+ end.map { |part| part['text'] }.join

+ end.join

+

+ feedback.call(

+ { should_be_stored: !(content.nil? || content.to_s.strip == ''),

+ interaction: content.nil? || content == '' ? nil : { who: 'AI', message: content },

+ finished: true }

+ )

+ end

+ end

+ end

+ end

+ end

+end

+require_relative '../../logic/providers/openai/tokens'

+require_relative 'tools'

+ presence_penalty frequency_penalty logit_bias seed response_format

+ { role: 'assistant', content: nil,

+ tool_calls: event[:meta][:tool_calls],

+ _meta: { at: event[:at] } }

+ tool_call_id: event[:meta][:id],

+ name: event[:meta][:name],

+ _meta: { at: event[:at] } }

+ { role: event[:who] == 'user' ? 'user' : 'assistant',

+ content: event[:message],

+ _meta: { at: event[:at] } }

+ content: input[:behavior][key],

+ _meta: { at: Time.now } }

+ payload[:tools] = input[:tools].map { |raw| Logic::OpenAI::Tools.adapt(raw) } if input[:tools]

+ Tools.apply(

+ cartridge, input[:tools], tools, feedback, Logic::OpenAI::Tools

+ ).each do |interaction|

+ { should_be_stored: !(content.nil? || content.to_s.strip == ''),

+ @client.chat(parameters: Logic::OpenAI::Tokens.apply_policies!(cartridge, payload))

+ result = @client.chat(parameters: Logic::OpenAI::Tokens.apply_policies!(cartridge, payload))

+ Tools.apply(

+ cartridge, input[:tools], tools, feedback, Logic::OpenAI::Tools

+ ).each do |interaction|

+# frozen_string_literal: true

+

+require_relative '../embedding'

+require_relative '../../logic/cartridge/safety'

+

+require 'concurrent'

+

+module NanoBot

+ module Components

+ module Providers

+ 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[:label], parameters: tool[:parameters] }

+ } } }

+ )

+ end

+

+ def self.apply(cartridge, function_cartridge, tools, feedback, tools_logic)

+ prepared_tools = tools_logic.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[:label], 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[:label],

+ parameters: tool[:parameters], output: tool[:output]

+ }

+ } } }

+ )

+

+ tool

+ end

+ end

+ end

+ end

+end

+ at: Time.now,

+ at: Time.now,

+ if feedback[:should_be_stored]

+ event[:at] = Time.now

+ @state[:history] << event

+ end

+ provider_stream = case Helpers::Hash.fetch(cartridge, %i[provider id])

+ when 'openai'

+ Helpers::Hash.fetch(cartridge, %i[provider settings stream])

+ when 'google'

+ Helpers::Hash.fetch(cartridge, %i[provider options stream])

+ end

+

+ return false if provider_stream == false

+# frozen_string_literal: true

+

+require 'openai'

+

+module NanoBot

+ module Logic

+ module Google

+ module Tokens

+ def self.apply_policies!(_cartridge, payload)

+ payload[:contents] = payload[:contents].map { |message| message.except(:_meta) }

+ payload

+ end

+ end

+ end

+ end

+end

+# frozen_string_literal: true

+

+require 'json'

+require 'babosa'

+

+require_relative '../../helpers/hash'

+

+module NanoBot

+ module Logic

+ module Google

+ module Tools

+ def self.prepare(cartridge, tools)

+ applies = []

+

+ tools = Marshal.load(Marshal.dump(tools))

+

+ tools.each do |tool|

+ tool = Helpers::Hash.symbolize_keys(tool)

+

+ cartridge.each do |candidate|

+ candidate_key = candidate[:name].to_slug.normalize.gsub('-', '_')

+ tool_key = tool[:functionCall][:name].to_slug.normalize.gsub('-', '_')

+

+ next unless candidate_key == tool_key

+

+ source = {}

+

+ source[:clojure] = candidate[:clojure] if candidate[:clojure]

+ source[:fennel] = candidate[:fennel] if candidate[:fennel]

+ source[:lua] = candidate[:lua] if candidate[:lua]

+

+ applies << {

+ label: candidate[:name],

+ name: tool[:functionCall][:name],

+ type: 'function',

+ parameters: tool[:functionCall][:args],

+ source:

+ }

+ end

+ end

+

+ raise 'missing tool' if applies.size != tools.size

+

+ applies

+ end

+

+ def self.adapt(cartridge)

+ output = {

+ name: cartridge[:name],

+ description: cartridge[:description]

+ }

+

+ output[:parameters] = (cartridge[:parameters] || { type: 'object', properties: {} })

+

+ output

+ end

+ end

+ end

+ end

+end

+# frozen_string_literal: true

+

+require 'openai'

+

+module NanoBot

+ module Logic

+ module OpenAI

+ module Tokens

+ def self.apply_policies!(_cartridge, payload)

+ payload[:messages] = payload[:messages].map { |message| message.except(:_meta) }

+ payload

+ end

+ end

+ end

+ end

+end

+require 'babosa'

+ candidate_key = candidate[:name].to_slug.normalize.gsub('-', '_')

+ tool_key = tool[:function][:name].to_slug.normalize.gsub('-', '_')

+

+ next unless candidate_key == tool_key

+ label: candidate[:name],

+ spec.add_dependency 'gemini-ai', '~> 1.0'

+ id: openai

+---

+- functionCall:

+ name: get_current_weather

+ args:

+ location: Tokyo, Japan

+- functionCall:

+ name: what_time_is_it

+ args:

+ timezone: local

+ context 'openai' do

+ let(:cartridge) { { provider: { id: 'openai' } } }

+ 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 'google' do

+ let(:cartridge) { { provider: { id: 'google' } } }

+

+ 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

+# frozen_string_literal: true

+

+require 'yaml'

+

+require_relative '../../../../logic/providers/google/tools'

+

+RSpec.describe NanoBot::Logic::Google::Tools do

+ context 'tools' do

+ let(:cartridge) { load_symbolized('cartridges/tools.yml') }

+

+ context 'adapt' do

+ it 'adapts to Google expected format' do

+ expect(described_class.adapt(cartridge[:tools][0])).to eq(

+ { name: 'what-time-is-it',

+ description: 'Returns the current date and time for a given timezone.',

+ parameters: {

+ type: 'object',

+ properties: {

+ timezone: {

+ type: 'string',

+ description: 'A string representing the timezone that should be used to provide a datetime, following the IANA (Internet Assigned Numbers Authority) Time Zone Database. Examples are "Asia/Tokyo" and "Europe/Paris".'

+ }

+ },

+ required: ['timezone']

+ } }

+ )

+

+ expect(described_class.adapt(cartridge[:tools][1])).to eq(

+ { 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][2])).to eq(

+ { 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' }

+ }

+ }

+ } }

+ )

+

+ expect(described_class.adapt(cartridge[:tools][3])).to eq(

+ { name: 'clock',

+ description: 'Returns the current date and time.',

+ parameters: { type: 'object', properties: {} } }

+ )

+ end

+ end

+

+ context 'prepare' do

+ let(:tools) { load_symbolized('providers/google/tools.yml') }

+

+ it 'prepare tools to be executed' do

+ expect(described_class.prepare(cartridge[:tools], tools)).to eq(

+ [{ name: 'get_current_weather',

+ label: '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" } },

+ { name: 'what_time_is_it',

+ label: 'what-time-is-it',

+ type: 'function', parameters: { timezone: 'local' },

+ source: { fennel: "(os.date)\n" } }]

+ )

+ end

+ end

+ end

+end

+ label: 'get-current-weather',

+ { id: 'call_ZYX',

+ name: 'what-time-is-it',

+ label: 'what-time-is-it',

+ type: 'function',

+ parameters: {},

+ options:

+ stream: true

+ summary: 'Ruby Implementation of Nano Bots: small, AI-powered bots for OpenAI ChatGPT and Google Gemini.',

+ description: 'Ruby Implementation of Nano Bots: small, AI-powered bots that can be easily shared as a single file, designed to support multiple providers such as OpenAI ChatGPT and Google Gemini, with support for calling Tools (Functions).',