ruby-openai-swarm 0.1.0

data/examples/weather_agent/agents.rb

@@ -0,0 +1,59 @@
+
+OpenAI.configure do |config|
+  config.access_token = ENV['OPEN_ROUTER_ACCESS_TOKEN']
+  config.uri_base = "https://openrouter.ai/api/v1"
+end
+
+client = OpenAISwarm.new
+
+# Client chat parameters: {:model=>"gpt-4", :messages=>[{:role=>"system", :content=>"You are a helpful agent."}, {"role"=>"user", "content"=>"Do I need an umbrella today? I'm in chicago."}, {"role"=>"assistant", "content"=>nil, "refusal"=>nil, "tool_calls"=>[{"index"=>0, "id"=>"call_spvHva4SFuDfTUk57EhuhArl", "type"=>"function", "function"=>{"name"=>"get_weather", "arguments"=>"{\n  \"location\": \"chicago\"\n}"}}], :sender=>"Weather Agent"}, {:role=>"tool", :tool_call_id=>"call_spvHva4SFuDfTUk57EhuhArl", :tool_name=>"get_weather", :content=>"{\"location\":{},\"temperature\":\"65\",\"time\":\"now\"}"}], :tools=>[{:type=>"function", :function=>{:name=>"send_email", :description=>"", :parameters=>{:type=>"object", :properties=>{:recipient=>{:type=>"string"}, :subject=>{:type=>"string"}, :body=>{:type=>"string"}}, :required=>["recipient", "subject", "body"]}}}, {:type=>"function", :function=>{:name=>"get_weather", :description=>"Get the current weather in a given location. Location MUST be a city.", :parameters=>{:type=>"object", :properties=>{:location=>{:type=>"string"}, :time=>{:type=>"string"}}, :required=>["location"]}}}], :stream=>false, :parallel_tool_calls=>true}
+def get_weather(location, time= Time.now)
+  { location: location, temperature: "65", time: time }.to_json
+end
+
+def send_email(recipient, subject, body)
+  puts "Sending email..."
+  puts "To: #{recipient}"
+  puts "Subject: #{subject}"
+  puts "Body: #{body}"
+  puts "Sent!"
+end
+
+function_instance_send_email = OpenAISwarm::FunctionDescriptor.new(
+  target_method: :send_email
+)
+
+function_instance_get_weather = OpenAISwarm::FunctionDescriptor.new(
+  target_method: :get_weather,
+  description: 'Get the current weather in a given location. Location MUST be a city.'
+)
+
+weather_agent = OpenAISwarm::Agent.new(
+  name: "Weather Agent",
+  instructions: "You are a helpful agent.",
+  model: "gpt-4o-mini",
+  functions: [
+    function_instance_send_email,
+    function_instance_get_weather
+  ]
+)
+
+msg1 = "Do I need an umbrella today? I'm in chicago."
+# model: "gpt-4",
+# return: The current temperature in Chicago is 65 degrees. It doesn't look like you'll need an umbrella today!
+msg2 = "Tell me the weather in London."
+# return: The current temperature in London is 65°F.
+response = client.run(
+  messages: [{"role" => "user", "content" => msg2}],
+  agent: weather_agent,
+  debug: true,
+)
+# print(response.messages[-1]["content"])
+
+response = client.run(
+  messages: [{"role" => "user", "content" => "What is the time right now?",}],
+  agent: weather_agent,
+  debug: true,
+)
+# p response.messages[-1]["content"]
+# return: I'm sorry for the confusion, but as an AI, I don't have the ability to provide real-time information such as the current time. Please check the time on your device.

data/lib/ruby-openai-swarm/agent.rb

@@ -0,0 +1,21 @@
+module OpenAISwarm
+  class Agent
+    attr_accessor :name, :model, :instructions, :functions, :tool_choice, :parallel_tool_calls
+
+    def initialize(
+      name: "Agent",
+      model: "gpt-4",
+      instructions: "You are a helpful agent.",
+      functions: [],
+      tool_choice: nil,
+      parallel_tool_calls: true
+    )
+      @name = name
+      @model = model
+      @instructions = instructions
+      @functions = functions
+      @tool_choice = tool_choice
+      @parallel_tool_calls = parallel_tool_calls
+    end
+  end
+end

data/lib/ruby-openai-swarm/core.rb

@@ -0,0 +1,269 @@
+require 'ruby/openai'
+begin
+  require 'pry'
+rescue LoadError
+end
+
+module OpenAISwarm
+  class Core
+    include Util
+    CTX_VARS_NAME = 'context_variables'
+
+    def initialize(client = nil)
+      @client = client || OpenAI::Client.new
+    end
+
+    def get_chat_completion(agent, history, context_variables, model_override, stream, debug)
+      context_variables = context_variables.dup
+      instructions = agent.instructions.respond_to?(:call) ? agent.instructions.call(context_variables) : agent.instructions
+      messages = [{ role: 'system', content: instructions }] + history
+      Util.debug_print(debug, "Getting chat completion for...:", messages)
+
+      tools = agent.functions.map { |f| Util.function_to_json(f) }
+      # hide context_variables from model
+      tools.each do |tool|
+        params = tool[:function][:parameters]
+        params[:properties].delete(CTX_VARS_NAME.to_sym)
+        params[:required]&.delete(CTX_VARS_NAME.to_sym)
+      end
+
+      create_params = {
+        model: model_override || agent.model,
+        messages: messages,
+        tools: tools.empty? ? nil : tools,
+        stream: stream
+      }
+
+      # TODO: https://platform.openai.com/docs/guides/function-calling/how-do-functions-differ-from-tools
+      # create_params[:functions] = tools unless tools.empty?
+      # create_params[:function_call] = agent.tool_choice if agent.tool_choice
+
+      create_params[:tool_choice] = agent.tool_choice if agent.tool_choice
+      create_params[:parallel_tool_calls] = agent.parallel_tool_calls if tools.any?
+
+      Util.debug_print(debug, "Client chat parameters:", create_params)
+      response = @client.chat(parameters: create_params)
+      Util.debug_print(debug, "API Response:", response)
+      response
+    rescue OpenAI::Error => e
+      Util.debug_print(true, "OpenAI API Error:", e.message)
+      raise
+    end
+
+    def handle_function_result(result, debug)
+      case result
+      when Result
+        result
+      when Agent
+        Result.new(
+          value: JSON.generate({ assistant: result.name }),
+          agent: result
+        )
+      else
+        begin
+          Result.new(value: result.to_s)
+        rescue => e
+          error_message = "Failed to cast response to string: #{result}. Make sure agent functions return a string or Result object. Error: #{e}"
+          Util.debug_print(debug, error_message)
+          raise TypeError, error_message
+        end
+      end
+    end
+
+    def handle_tool_calls(tool_calls, active_agent, context_variables, debug)
+      functions = active_agent.functions
+
+      function_map = functions.map do |f|
+        if f.is_a?(OpenAISwarm::FunctionDescriptor)
+          [f.target_method.name, f.target_method]
+        else
+          [f.name, f]
+        end
+      end.to_h.transform_keys(&:to_s)
+
+      partial_response = Response.new(
+        messages: [],
+        agent: nil,
+        context_variables: {}
+      )
+
+      tool_calls.each do |tool_call|
+        name = tool_call.dig('function', 'name')
+        unless function_map.key?(name)
+          Util.debug_print(debug, "Tool #{name} not found in function map.")
+          partial_response.messages << {
+            role: 'tool',
+            tool_call_id: tool_call.id,
+            tool_name: name,
+            content: "Error: Tool #{name} not found."
+          }
+          next
+        end
+
+        args = JSON.parse(tool_call.dig('function', 'arguments') || '{}')
+        Util.debug_print(debug, "Processing tool call: #{name} with arguments #{args}")
+
+        func = function_map[name]
+        # pass context_variables to agent functions
+        args[CTX_VARS_NAME] = context_variables if func.parameters.map(&:last).include?(CTX_VARS_NAME.to_sym)
+        is_parameters = func.parameters.any?
+        arguments = args.transform_keys(&:to_sym)
+
+        raw_result = is_parameters ? func.call(**arguments) : func.call
+        result = handle_function_result(raw_result, debug)
+
+        partial_response.messages << {
+          role: 'tool',
+          tool_call_id: tool_call['id'],
+          tool_name: name,
+          content: result.value
+        }
+
+        partial_response.context_variables.merge!(result.context_variables)
+        partial_response.agent = result.agent if result.agent
+      end
+
+      partial_response
+    end
+
+    def run(agent:, messages:, context_variables: {}, model_override: nil, stream: false, debug: false, max_turns: Float::INFINITY, execute_tools: true)
+      if stream
+        return run_and_stream(
+          agent: agent,
+          messages: messages,
+          context_variables: context_variables,
+          model_override: model_override,
+          debug: debug,
+          max_turns: max_turns,
+          execute_tools: execute_tools
+        )
+      end
+
+      active_agent = agent
+      context_variables = context_variables.dup
+      history = messages.dup
+      init_len = messages.length
+
+      while history.length - init_len < max_turns && active_agent
+        completion = get_chat_completion(
+          active_agent,
+          history,
+          context_variables,
+          model_override,
+          stream,
+          debug
+        )
+
+        message = completion.dig('choices', 0, 'message')
+        Util.debug_print(debug, "Received completion:", message)
+
+        message['sender'] = active_agent.name
+        history << message
+
+        break if !message['tool_calls'] || !execute_tools
+
+        partial_response = handle_tool_calls(
+          message['tool_calls'],
+          active_agent,
+          context_variables,
+          debug
+        )
+
+        history.concat(partial_response.messages)
+        context_variables.merge!(partial_response.context_variables)
+        active_agent = partial_response.agent if partial_response.agent
+      end
+
+      Response.new(
+        messages: history[init_len..],
+        agent: active_agent,
+        context_variables: context_variables
+      )
+    end
+
+    private
+
+    def run_and_stream(agent:, messages:, context_variables: {}, model_override: nil, debug: false, max_turns: Float::INFINITY, execute_tools: true)
+      active_agent = agent
+      context_variables = context_variables.dup
+      history = messages.dup
+      init_len = messages.length
+
+      while history.length - init_len < max_turns && active_agent
+        message = {
+          content: "",
+          sender: agent.name,
+          role: "assistant",
+          function_call: nil,
+          tool_calls: Hash.new do |h, k|
+            h[k] = {
+              function: { arguments: "", name: "" },
+              id: "",
+              type: ""
+            }
+          end
+        }
+
+        completion = get_chat_completion(
+          active_agent,
+          history,
+          context_variables,
+          model_override,
+          true, # stream
+          debug
+        )
+
+        yield({ delim: "start" })
+        completion.each do |chunk|
+          delta = JSON.parse(chunk.choices[0].delta.to_json, symbolize_names: true)
+          if delta[:role] == "assistant"
+            delta[:sender] = active_agent.name
+          end
+          yield delta
+          delta.delete(:role)
+          delta.delete(:sender)
+          Util.merge_chunk(message, delta)
+        end
+        yield({ delim: "end" })
+
+        message[:tool_calls] = message[:tool_calls].values
+        message[:tool_calls] = nil if message[:tool_calls].empty?
+        Util.debug_print(debug, "Received completion:", message)
+        history << message
+
+        break if !message[:tool_calls] || !execute_tools
+
+        # convert tool_calls to objects
+        tool_calls = message[:tool_calls].map do |tool_call|
+          OpenStruct.new(
+            id: tool_call[:id],
+            function: OpenStruct.new(
+              arguments: tool_call[:function][:arguments],
+              name: tool_call[:function][:name]
+            ),
+            type: tool_call[:type]
+          )
+        end
+
+        partial_response = handle_tool_calls(
+          tool_calls,
+          active_agent.functions, # TODO: will check
+          context_variables,
+          debug
+        )
+
+        history.concat(partial_response.messages)
+        context_variables.merge!(partial_response.context_variables)
+        active_agent = partial_response.agent if partial_response.agent
+      end
+
+      yield({
+        response: Response.new(
+          messages: history[init_len..],
+          agent: active_agent,
+          context_variables: context_variables
+        )
+      })
+    end
+  end
+end

data/lib/ruby-openai-swarm/function_descriptor.rb

@@ -0,0 +1,10 @@
+module OpenAISwarm
+  class FunctionDescriptor
+    attr_reader :target_method, :description
+
+    def initialize(target_method:, description: '')
+      @target_method = target_method.is_a?(Method) ? target_method : method(target_method)
+      @description = description
+    end
+  end
+end

data/lib/ruby-openai-swarm/repl.rb

@@ -0,0 +1,90 @@
+module OpenAISwarm
+  class Repl
+    class << self
+      def process_and_print_streaming_response(response)
+        content = ""
+        last_sender = ""
+        response.each do |chunk|
+          last_sender = chunk['sender'] if chunk.key?('sender')
+
+          if chunk.key?("content") && !chunk["content"].nil?
+            if content.empty? && !last_sender.empty?
+              print "\033[94m#{last_sender}:\033[0m "
+              last_sender = ""
+            end
+            print chunk["content"]
+            content += chunk["content"]
+          end
+
+          if chunk.key?("tool_calls") && !chunk["tool_calls"].nil?
+            chunk["tool_calls"].each do |tool_call|
+              f = tool_call["function"]
+              name = f["name"]
+              next if name.empty?
+              print "\033[94m#{last_sender}:\033[95m#{name}\033[0m()"
+            end
+          end
+
+          if chunk.key?("delim") && chunk["delim"] == "end" && !content.empty?
+            puts
+            content = ""
+          end
+
+          return chunk["response"] if chunk.key?("response")
+        end
+      end
+
+      def pretty_print_messages(messages)
+        messages.each do |message|
+          next unless message["role"] == "assistant"
+
+          print "\033[94m#{message[:sender]}\033[0m: "
+
+          puts message["content"] if message["content"]
+
+          tool_calls = message.fetch("tool_calls", [])
+          puts if tool_calls.length > 1
+          tool_calls.each do |tool_call|
+            func = tool_call["function"]
+            name = func["name"]
+            args = JSON.parse(func["arguments"] || "{}").map { |k, v| "#{k}=#{v}" }.join(", ")
+            puts "\e[95m#{name}\e[0m(#{args})"
+          end
+        end
+      end
+
+      def run_demo_loop(starting_agent, context_variables: {}, stream: false, debug: false)
+        client = OpenAISwarm.new
+        puts "Starting Swarm CLI 🐝"
+
+        messages = []
+        agent = starting_agent
+
+        loop do
+          print "\033[90mUser\033[0m: "
+          user_input = gets.chomp
+          break if user_input.downcase == "exit"
+
+          messages << { "role" => "user", "content" => user_input }
+
+          response = client.run(
+            agent: agent,
+            messages: messages,
+            context_variables: context_variables,
+            stream: stream,
+            debug: debug
+          )
+
+          if stream
+            response = process_and_print_streaming_response(response)
+          else
+            pretty_print_messages(response.messages)
+          end
+
+          messages.concat(response.messages)
+          agent = response.agent
+        end
+      end
+    end
+  end
+end

data/lib/ruby-openai-swarm/response.rb

@@ -0,0 +1,11 @@
+module OpenAISwarm
+  class Response
+    attr_accessor :messages, :agent, :context_variables
+
+    def initialize(messages: [], agent: nil, context_variables: {})
+      @messages = messages
+      @agent = agent
+      @context_variables = context_variables
+    end
+  end
+end

data/lib/ruby-openai-swarm/result.rb

@@ -0,0 +1,11 @@
+module OpenAISwarm
+  class Result
+    attr_accessor :value, :agent, :context_variables
+
+    def initialize(value: "", agent: nil, context_variables: {})
+      @value = value
+      @agent = agent
+      @context_variables = context_variables
+    end
+  end
+end

data/lib/ruby-openai-swarm/util.rb

@@ -0,0 +1,78 @@
+module OpenAISwarm
+  module Util
+    def self.debug_print(debug, *args)
+      return unless debug
+      timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      message = args.map(&:to_s).join(' ')
+      puts "\e[97m[\e[90m#{timestamp}\e[97m]\e[90m #{message}\e[0m"
+    end
+
+    def self.merge_fields(target, source)
+      source.each do |key, value|
+        if value.is_a?(String)
+          target[key] = target[key].to_s + value
+        elsif value && value.is_a?(Hash)
+          target[key] ||= {}
+          merge_fields(target[key], value)
+        end
+      end
+    end
+
+    def self.merge_chunk(final_response, delta)
+      delta.delete(:role)
+      merge_fields(final_response, delta)
+
+      if delta[:tool_calls]&.any?
+        index = delta[:tool_calls][0].delete(:index)
+        merge_fields(final_response[:tool_calls][index], delta[:tool_calls][0])
+      end
+    end
+
+    def self.function_to_json(func_instance)
+      is_target_method = func_instance.respond_to?(:target_method) || func_instance.is_a?(OpenAISwarm::FunctionDescriptor)
+      func = is_target_method ? func_instance.target_method : func_instance
+
+      function_name = func.name
+      function_parameters = func.parameters
+
+      type_map = {
+        String => "string",
+        Integer => "integer",
+        Float => "number",
+        TrueClass => "boolean",
+        FalseClass => "boolean",
+        Array => "array",
+        Hash => "object",
+        NilClass => "null"
+      }
+      parameters = {}
+
+      function_parameters.each do |type, param_name|
+        param_type = type_map[param_name.class] || "string"
+        if param_name.to_s == 'context_variables' && type == :opt #type == :keyreq
+          param_type = 'object'
+        end
+        parameters[param_name] = { type: param_type }
+      end
+
+      required = function_parameters
+        .select { |type, _| [:req, :keyreq].include?(type) }
+        .map { |_, name| name.to_s }
+
+      description = func_instance.respond_to?(:description) ? func_instance&.description : nil
+
+      {
+        type: "function",
+        function: {
+          name: function_name,
+          description: description || '',
+          parameters: {
+            type: "object",
+            properties: parameters,
+            required: required
+          }
+        }
+      }
+    end
+  end
+end

data/lib/ruby-openai-swarm/version.rb

@@ -0,0 +1,4 @@
+module OpenAISwarm
+  VERSION = "0.1.0"
+end
+

data/lib/ruby-openai-swarm.rb

@@ -0,0 +1,18 @@
+require 'ruby-openai-swarm/version'
+require 'ruby-openai-swarm/agent'
+require 'ruby-openai-swarm/response'
+require 'ruby-openai-swarm/result'
+require 'ruby-openai-swarm/util'
+require 'ruby-openai-swarm/core'
+require 'ruby-openai-swarm/function_descriptor'
+require 'ruby-openai-swarm/repl'
+
+module OpenAISwarm
+  class Error < StandardError; end
+
+  class << self
+    def new(client = nil)
+      Core.new(client)
+    end
+  end
+end

data/ruby-openai-swarm.gemspec

@@ -0,0 +1,28 @@
+require_relative 'lib/ruby-openai-swarm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby-openai-swarm"
+  spec.version       = OpenAISwarm::VERSION
+  spec.authors       = ["Grayson"]
+  spec.email         = ["cgg5207@gmail.com"]
+
+  spec.summary       = " A Ruby implementation of OpenAI function calling swarm"
+  spec.description   = "Allows for creating swarms of AI agents that can call functions and interact with each other"
+  spec.homepage      = "https://github.com/grayson/ruby-openai-swarm"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+
+  spec.require_paths = ["lib"]
+  spec.add_dependency "ruby-openai", "~> 7.3"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "pry"
+end